From 52fb86dab3bbd0d95e20f9044474856cb2eda8ab Mon Sep 17 00:00:00 2001 From: "Ian D. Bollinger" Date: Thu, 21 Jul 2016 16:06:36 -0400 Subject: [PATCH 1/2] Add API entries for UIEvents This commit implements a large portion of the https://www.w3.org/TR/uievents/ specification. --- src/DOM/Event/CompositionEvent.js | 14 ++++ src/DOM/Event/CompositionEvent.purs | 21 ++++++ src/DOM/Event/FocusEvent.js | 14 ++++ src/DOM/Event/FocusEvent.purs | 26 +++++++ src/DOM/Event/KeyboardEvent.js | 54 +++++++++++++++ src/DOM/Event/KeyboardEvent.purs | 102 ++++++++++++++++++++++++++++ src/DOM/Event/MouseEvent.js | 62 +++++++++++++++++ src/DOM/Event/MouseEvent.purs | 65 ++++++++++++++++++ src/DOM/Event/WheelEvent.js | 26 +++++++ src/DOM/Event/WheelEvent.purs | 75 ++++++++++++++++++++ 10 files changed, 459 insertions(+) create mode 100644 src/DOM/Event/CompositionEvent.js create mode 100644 src/DOM/Event/CompositionEvent.purs create mode 100644 src/DOM/Event/FocusEvent.js create mode 100644 src/DOM/Event/FocusEvent.purs create mode 100644 src/DOM/Event/KeyboardEvent.js create mode 100644 src/DOM/Event/KeyboardEvent.purs create mode 100644 src/DOM/Event/MouseEvent.js create mode 100644 src/DOM/Event/MouseEvent.purs create mode 100644 src/DOM/Event/WheelEvent.js create mode 100644 src/DOM/Event/WheelEvent.purs diff --git a/src/DOM/Event/CompositionEvent.js b/src/DOM/Event/CompositionEvent.js new file mode 100644 index 0000000..10a58fc --- /dev/null +++ b/src/DOM/Event/CompositionEvent.js @@ -0,0 +1,14 @@ +/* global CompositionEvent */ +"use strict"; + +exports._eventToCompositionEvent = function (just) { + return function (nothing) { + return function (e) { + return e instanceof CompositionEvent ? just(e) : nothing; + }; + }; +}; + +exports.data_ = function (e) { + return e.data; +}; diff --git a/src/DOM/Event/CompositionEvent.purs b/src/DOM/Event/CompositionEvent.purs new file mode 100644 index 0000000..4680630 --- /dev/null +++ b/src/DOM/Event/CompositionEvent.purs @@ -0,0 +1,21 @@ +module DOM.Event.CompositionEvent ( + module T, + eventToCompositionEvent, + data_ + ) where + +import Data.Maybe (Maybe(..)) +import DOM.Event.Types (CompositionEvent, Event) +import DOM.Event.Types (CompositionEvent, compositionEventToEvent, readCompositionEvent) as T + +eventToCompositionEvent :: Event -> Maybe CompositionEvent +eventToCompositionEvent = _eventToCompositionEvent Just Nothing + +foreign import _eventToCompositionEvent + :: forall a + . (a -> Maybe a) + -> Maybe a + -> Event + -> Maybe CompositionEvent + +foreign import data_ :: CompositionEvent -> String diff --git a/src/DOM/Event/FocusEvent.js b/src/DOM/Event/FocusEvent.js new file mode 100644 index 0000000..ac503f6 --- /dev/null +++ b/src/DOM/Event/FocusEvent.js @@ -0,0 +1,14 @@ +/* global FocusEvent */ +"use strict"; + +exports._eventToFocusEvent = function (just) { + return function (nothing) { + return function (e) { + return e instanceof FocusEvent ? just(e) : nothing; + }; + }; +}; + +exports.relatedTargetNullable = function (e) { + return e.relatedTarget; +}; diff --git a/src/DOM/Event/FocusEvent.purs b/src/DOM/Event/FocusEvent.purs new file mode 100644 index 0000000..7707823 --- /dev/null +++ b/src/DOM/Event/FocusEvent.purs @@ -0,0 +1,26 @@ +module DOM.Event.FocusEvent + ( module T + , eventToFocusEvent + , relatedTarget + ) where + +import Prelude +import Data.Maybe (Maybe (..)) +import Data.Nullable (Nullable, toMaybe) +import DOM.Event.Types (Event, EventTarget, FocusEvent) +import DOM.Event.Types (FocusEvent, focusEventToEvent, readFocusEvent) as T + +eventToFocusEvent :: Event -> Maybe FocusEvent +eventToFocusEvent = _eventToFocusEvent Just Nothing + +foreign import _eventToFocusEvent + :: forall a + . (a -> Maybe a) + -> Maybe a + -> Event + -> Maybe FocusEvent + +foreign import relatedTargetNullable :: FocusEvent -> Nullable EventTarget + +relatedTarget :: FocusEvent -> Maybe EventTarget +relatedTarget = toMaybe <$> relatedTargetNullable diff --git a/src/DOM/Event/KeyboardEvent.js b/src/DOM/Event/KeyboardEvent.js new file mode 100644 index 0000000..94fd16a --- /dev/null +++ b/src/DOM/Event/KeyboardEvent.js @@ -0,0 +1,54 @@ +/* global KeyboardEvent */ +"use strict"; + +exports._eventToKeyboardEvent = function (just) { + return function (nothing) { + return function (e) { + return e instanceof KeyboardEvent ? just(e) : nothing; + }; + }; +}; + +exports.key = function (e) { + return e.key; +}; + +exports.code = function (e) { + return e.code; +}; + +exports.locationIndex = function (e) { + return e.location; +}; + +exports.ctrlKey = function (e) { + return e.ctrlKey; +}; + +exports.shiftKey = function (e) { + return e.shiftKey; +}; + +exports.altKey = function (e) { + return e.altKey; +}; + +exports.metaKey = function (e) { + return e.metaKey; +}; + +exports.repeat = function (e) { + return e.repeat; +}; + +exports.isComposing = function (e) { + return e.isComposing; +}; + +exports.getModifierState = function (s) { + return function (e) { + return function () { + return e.getModifierState(s); + }; + }; +}; diff --git a/src/DOM/Event/KeyboardEvent.purs b/src/DOM/Event/KeyboardEvent.purs new file mode 100644 index 0000000..2981734 --- /dev/null +++ b/src/DOM/Event/KeyboardEvent.purs @@ -0,0 +1,102 @@ +module DOM.Event.KeyboardEvent + ( module T + , eventToKeyboardEvent + , key + , code + , locationIndex + , location + , KeyLocation(..) + , toEnumKeyLocation + , fromEnumKeyLocation + , ctrlKey + , shiftKey + , altKey + , metaKey + , repeat + , isComposing + , getModifierState + ) where + +import Prelude +import Control.Monad.Eff (Eff) +import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum) +import Data.Maybe (Maybe(..), fromJust) +import DOM (DOM) +import DOM.Event.Types (Event, KeyboardEvent) +import DOM.Event.Types (KeyboardEvent, keyboardEventToEvent, readKeyboardEvent) as T + +eventToKeyboardEvent :: Event -> Maybe KeyboardEvent +eventToKeyboardEvent = _eventToKeyboardEvent Just Nothing + +foreign import _eventToKeyboardEvent + :: forall a + . (a -> Maybe a) + -> Maybe a + -> Event + -> Maybe KeyboardEvent + +foreign import key :: KeyboardEvent -> String + +foreign import code :: KeyboardEvent -> String + +foreign import locationIndex :: KeyboardEvent -> Int + +location :: Partial => KeyboardEvent -> KeyLocation +location = fromJust <<< toEnum <<< locationIndex + +data KeyLocation + = Standard + | Left + | Right + | Numpad + +derive instance eqKeyLocation :: Eq KeyLocation +derive instance ordKeyLocation :: Ord KeyLocation + +instance boundedKeyLocation :: Bounded KeyLocation where + bottom = Standard + top = Numpad + +instance enumKeyLocation :: Enum KeyLocation where + succ = defaultSucc toEnumKeyLocation fromEnumKeyLocation + pred = defaultPred toEnumKeyLocation fromEnumKeyLocation + +instance boundedEnumKeyLocation :: BoundedEnum KeyLocation where + cardinality = Cardinality 4 + toEnum = toEnumKeyLocation + fromEnum = fromEnumKeyLocation + +toEnumKeyLocation :: Int -> Maybe KeyLocation +toEnumKeyLocation = + case _ of + 0 -> Just Standard + 1 -> Just Left + 2 -> Just Right + 3 -> Just Numpad + _ -> Nothing + +fromEnumKeyLocation :: KeyLocation -> Int +fromEnumKeyLocation = + case _ of + Standard -> 0 + Left -> 1 + Right -> 2 + Numpad -> 3 + +foreign import ctrlKey :: KeyboardEvent -> Boolean + +foreign import shiftKey :: KeyboardEvent -> Boolean + +foreign import altKey :: KeyboardEvent -> Boolean + +foreign import metaKey :: KeyboardEvent -> Boolean + +foreign import repeat :: KeyboardEvent -> Boolean + +foreign import isComposing :: KeyboardEvent -> Boolean + +foreign import getModifierState + :: forall eff + . String + -> KeyboardEvent + -> Eff (dom :: DOM | eff) Boolean diff --git a/src/DOM/Event/MouseEvent.js b/src/DOM/Event/MouseEvent.js new file mode 100644 index 0000000..a8f7f2f --- /dev/null +++ b/src/DOM/Event/MouseEvent.js @@ -0,0 +1,62 @@ +/* global MouseEvent */ +"use strict"; + +exports._eventToMouseEvent = function (just) { + return function (nothing) { + return function (e) { + return e instanceof MouseEvent ? just(e) : nothing; + }; + }; +}; + +exports.screenX = function (e) { + return e.screenX; +}; + +exports.screenY = function (e) { + return e.screenY; +}; + +exports.clientX = function (e) { + return e.clientX; +}; + +exports.clientY = function (e) { + return e.clientY; +}; + +exports.ctrlKey = function (e) { + return e.ctrlKey; +}; + +exports.shiftKey = function (e) { + return e.shiftKey; +}; + +exports.altKey = function (e) { + return e.altKey; +}; + +exports.metaKey = function (e) { + return e.metaKey; +}; + +exports.button = function (e) { + return e.button; +}; + +exports.relatedTargetNullable = function (e) { + return e.relatedTarget; +}; + +exports.buttons = function (e) { + return e.buttons; +}; + +exports.getModifierState = function (s) { + return function (e) { + return function () { + return e.getModifierState(s); + }; + }; +}; diff --git a/src/DOM/Event/MouseEvent.purs b/src/DOM/Event/MouseEvent.purs new file mode 100644 index 0000000..4c5505a --- /dev/null +++ b/src/DOM/Event/MouseEvent.purs @@ -0,0 +1,65 @@ +module DOM.Event.MouseEvent + ( module T + , eventToMouseEvent + , screenX + , screenY + , clientX + , clientY + , ctrlKey + , shiftKey + , altKey + , metaKey + , button + , relatedTarget + , buttons + , getModifierState + ) where + +import Prelude +import Control.Monad.Eff (Eff) +import Data.Maybe (Maybe(..)) +import Data.Nullable (Nullable, toMaybe) +import DOM (DOM) +import DOM.Event.Types (Event, EventTarget, MouseEvent) +import DOM.Event.Types (MouseEvent, mouseEventToEvent, readMouseEvent) as T + +eventToMouseEvent :: Event -> Maybe MouseEvent +eventToMouseEvent = _eventToMouseEvent Just Nothing + +foreign import _eventToMouseEvent + :: forall a + . (a -> Maybe a) + -> Maybe a + -> Event + -> Maybe MouseEvent + +foreign import screenX :: MouseEvent -> Int + +foreign import screenY :: MouseEvent -> Int + +foreign import clientX :: MouseEvent -> Int + +foreign import clientY :: MouseEvent -> Int + +foreign import ctrlKey :: MouseEvent -> Boolean + +foreign import shiftKey :: MouseEvent -> Boolean + +foreign import altKey :: MouseEvent -> Boolean + +foreign import metaKey :: MouseEvent -> Boolean + +foreign import button :: MouseEvent -> Int + +foreign import relatedTargetNullable :: MouseEvent -> Nullable EventTarget + +relatedTarget :: MouseEvent -> Maybe EventTarget +relatedTarget = toMaybe <$> relatedTargetNullable + +foreign import buttons :: MouseEvent -> Int + +foreign import getModifierState + :: forall eff + . String + -> MouseEvent + -> Eff (dom :: DOM | eff) Boolean diff --git a/src/DOM/Event/WheelEvent.js b/src/DOM/Event/WheelEvent.js new file mode 100644 index 0000000..d0bf583 --- /dev/null +++ b/src/DOM/Event/WheelEvent.js @@ -0,0 +1,26 @@ +/* global WheelEvent */ +"use strict"; + +exports._eventToWheelEvent = function (just) { + return function (nothing) { + return function (e) { + return e instanceof WheelEvent ? just(e) : nothing; + }; + }; +}; + +exports.deltaX = function (e) { + return e.deltaX; +}; + +exports.deltaY = function (e) { + return e.deltaY; +}; + +exports.deltaZ = function (e) { + return e.deltaZ; +}; + +exports.deltaModeIndex = function (e) { + return e.deltaModeIndex; +}; diff --git a/src/DOM/Event/WheelEvent.purs b/src/DOM/Event/WheelEvent.purs new file mode 100644 index 0000000..0714be3 --- /dev/null +++ b/src/DOM/Event/WheelEvent.purs @@ -0,0 +1,75 @@ +module DOM.Event.WheelEvent + ( module T + , eventToWheelEvent + , deltaX + , deltaY + , deltaZ + , deltaModeIndex + , deltaMode + , DeltaMode(..) + , toEnumDeltaMode + , fromEnumDeltaMode + ) where + +import Prelude +import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum) +import Data.Maybe (Maybe(..), fromJust) +import DOM.Event.Types (Event, WheelEvent) +import DOM.Event.Types (WheelEvent, readWheelEvent, wheelEventToEvent) as T + +eventToWheelEvent :: Event -> Maybe WheelEvent +eventToWheelEvent = _eventToWheelEvent Just Nothing + +foreign import _eventToWheelEvent + :: forall a + . (a -> Maybe a) + -> Maybe a + -> Event + -> Maybe WheelEvent + +foreign import deltaX :: WheelEvent -> Number + +foreign import deltaY :: WheelEvent -> Number + +foreign import deltaZ :: WheelEvent -> Number + +foreign import deltaModeIndex :: WheelEvent -> Int + +deltaMode :: Partial => WheelEvent -> DeltaMode +deltaMode = fromJust <<< toEnum <<< deltaModeIndex + +data DeltaMode + = Pixel + | Line + | Page + +derive instance eqDeltaMode :: Eq DeltaMode +derive instance ordDeltaMode :: Ord DeltaMode + +instance boundedDeltaMode :: Bounded DeltaMode where + bottom = Pixel + top = Page + +instance enumDeltaMode :: Enum DeltaMode where + succ = defaultSucc toEnumDeltaMode fromEnumDeltaMode + pred = defaultPred toEnumDeltaMode fromEnumDeltaMode + +instance boundedEnumDeltaMode :: BoundedEnum DeltaMode where + cardinality = Cardinality 3 + toEnum = toEnumDeltaMode + fromEnum = fromEnumDeltaMode + +toEnumDeltaMode :: Int -> Maybe DeltaMode +toEnumDeltaMode = + case _ of + 0 -> Just Pixel + 1 -> Just Line + 2 -> Just Page + _ -> Nothing + +fromEnumDeltaMode :: DeltaMode -> Int +fromEnumDeltaMode = + case _ of + Pixel -> 0 + Line -> 1 + Page -> 2 From 9a3533326a4c28154ed2670d88a50d532b2e52a0 Mon Sep 17 00:00:00 2001 From: "Ian D. Bollinger" Date: Fri, 22 Jul 2016 14:00:48 -0400 Subject: [PATCH 2/2] Use Data.Foreign.unsafeReadTagged for coercions This replaces the usage of the FFI for type coercions with Data.Foreign. --- src/DOM/Event/CompositionEvent.js | 9 --------- src/DOM/Event/CompositionEvent.purs | 16 +++++----------- src/DOM/Event/FocusEvent.js | 9 --------- src/DOM/Event/FocusEvent.purs | 16 +++++----------- src/DOM/Event/KeyboardEvent.js | 9 --------- src/DOM/Event/KeyboardEvent.purs | 14 ++++---------- src/DOM/Event/MouseEvent.js | 9 --------- src/DOM/Event/MouseEvent.purs | 16 +++++----------- src/DOM/Event/WheelEvent.js | 9 --------- src/DOM/Event/WheelEvent.purs | 14 ++++---------- 10 files changed, 23 insertions(+), 98 deletions(-) diff --git a/src/DOM/Event/CompositionEvent.js b/src/DOM/Event/CompositionEvent.js index 10a58fc..4437f21 100644 --- a/src/DOM/Event/CompositionEvent.js +++ b/src/DOM/Event/CompositionEvent.js @@ -1,14 +1,5 @@ -/* global CompositionEvent */ "use strict"; -exports._eventToCompositionEvent = function (just) { - return function (nothing) { - return function (e) { - return e instanceof CompositionEvent ? just(e) : nothing; - }; - }; -}; - exports.data_ = function (e) { return e.data; }; diff --git a/src/DOM/Event/CompositionEvent.purs b/src/DOM/Event/CompositionEvent.purs index 4680630..28e79d3 100644 --- a/src/DOM/Event/CompositionEvent.purs +++ b/src/DOM/Event/CompositionEvent.purs @@ -4,18 +4,12 @@ module DOM.Event.CompositionEvent ( data_ ) where -import Data.Maybe (Maybe(..)) -import DOM.Event.Types (CompositionEvent, Event) +import Prelude +import Data.Foreign (F, toForeign) +import DOM.Event.Types (CompositionEvent, Event, readCompositionEvent) import DOM.Event.Types (CompositionEvent, compositionEventToEvent, readCompositionEvent) as T -eventToCompositionEvent :: Event -> Maybe CompositionEvent -eventToCompositionEvent = _eventToCompositionEvent Just Nothing - -foreign import _eventToCompositionEvent - :: forall a - . (a -> Maybe a) - -> Maybe a - -> Event - -> Maybe CompositionEvent +eventToCompositionEvent :: Event -> F CompositionEvent +eventToCompositionEvent = readCompositionEvent <<< toForeign foreign import data_ :: CompositionEvent -> String diff --git a/src/DOM/Event/FocusEvent.js b/src/DOM/Event/FocusEvent.js index ac503f6..ec69558 100644 --- a/src/DOM/Event/FocusEvent.js +++ b/src/DOM/Event/FocusEvent.js @@ -1,14 +1,5 @@ -/* global FocusEvent */ "use strict"; -exports._eventToFocusEvent = function (just) { - return function (nothing) { - return function (e) { - return e instanceof FocusEvent ? just(e) : nothing; - }; - }; -}; - exports.relatedTargetNullable = function (e) { return e.relatedTarget; }; diff --git a/src/DOM/Event/FocusEvent.purs b/src/DOM/Event/FocusEvent.purs index 7707823..c619f99 100644 --- a/src/DOM/Event/FocusEvent.purs +++ b/src/DOM/Event/FocusEvent.purs @@ -5,20 +5,14 @@ module DOM.Event.FocusEvent ) where import Prelude -import Data.Maybe (Maybe (..)) +import Data.Foreign (F, toForeign) +import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) -import DOM.Event.Types (Event, EventTarget, FocusEvent) +import DOM.Event.Types (Event, EventTarget, FocusEvent, readFocusEvent) import DOM.Event.Types (FocusEvent, focusEventToEvent, readFocusEvent) as T -eventToFocusEvent :: Event -> Maybe FocusEvent -eventToFocusEvent = _eventToFocusEvent Just Nothing - -foreign import _eventToFocusEvent - :: forall a - . (a -> Maybe a) - -> Maybe a - -> Event - -> Maybe FocusEvent +eventToFocusEvent :: Event -> F FocusEvent +eventToFocusEvent = readFocusEvent <<< toForeign foreign import relatedTargetNullable :: FocusEvent -> Nullable EventTarget diff --git a/src/DOM/Event/KeyboardEvent.js b/src/DOM/Event/KeyboardEvent.js index 94fd16a..3e7c602 100644 --- a/src/DOM/Event/KeyboardEvent.js +++ b/src/DOM/Event/KeyboardEvent.js @@ -1,14 +1,5 @@ -/* global KeyboardEvent */ "use strict"; -exports._eventToKeyboardEvent = function (just) { - return function (nothing) { - return function (e) { - return e instanceof KeyboardEvent ? just(e) : nothing; - }; - }; -}; - exports.key = function (e) { return e.key; }; diff --git a/src/DOM/Event/KeyboardEvent.purs b/src/DOM/Event/KeyboardEvent.purs index 2981734..073f113 100644 --- a/src/DOM/Event/KeyboardEvent.purs +++ b/src/DOM/Event/KeyboardEvent.purs @@ -20,20 +20,14 @@ module DOM.Event.KeyboardEvent import Prelude import Control.Monad.Eff (Eff) import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum) +import Data.Foreign (F, toForeign) import Data.Maybe (Maybe(..), fromJust) import DOM (DOM) -import DOM.Event.Types (Event, KeyboardEvent) +import DOM.Event.Types (Event, KeyboardEvent, readKeyboardEvent) import DOM.Event.Types (KeyboardEvent, keyboardEventToEvent, readKeyboardEvent) as T -eventToKeyboardEvent :: Event -> Maybe KeyboardEvent -eventToKeyboardEvent = _eventToKeyboardEvent Just Nothing - -foreign import _eventToKeyboardEvent - :: forall a - . (a -> Maybe a) - -> Maybe a - -> Event - -> Maybe KeyboardEvent +eventToKeyboardEvent :: Event -> F KeyboardEvent +eventToKeyboardEvent = readKeyboardEvent <<< toForeign foreign import key :: KeyboardEvent -> String diff --git a/src/DOM/Event/MouseEvent.js b/src/DOM/Event/MouseEvent.js index a8f7f2f..90a3789 100644 --- a/src/DOM/Event/MouseEvent.js +++ b/src/DOM/Event/MouseEvent.js @@ -1,14 +1,5 @@ -/* global MouseEvent */ "use strict"; -exports._eventToMouseEvent = function (just) { - return function (nothing) { - return function (e) { - return e instanceof MouseEvent ? just(e) : nothing; - }; - }; -}; - exports.screenX = function (e) { return e.screenX; }; diff --git a/src/DOM/Event/MouseEvent.purs b/src/DOM/Event/MouseEvent.purs index 4c5505a..5d14b46 100644 --- a/src/DOM/Event/MouseEvent.purs +++ b/src/DOM/Event/MouseEvent.purs @@ -17,21 +17,15 @@ module DOM.Event.MouseEvent import Prelude import Control.Monad.Eff (Eff) -import Data.Maybe (Maybe(..)) +import Data.Foreign (F, toForeign) +import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import DOM (DOM) -import DOM.Event.Types (Event, EventTarget, MouseEvent) +import DOM.Event.Types (Event, EventTarget, MouseEvent, readMouseEvent) import DOM.Event.Types (MouseEvent, mouseEventToEvent, readMouseEvent) as T -eventToMouseEvent :: Event -> Maybe MouseEvent -eventToMouseEvent = _eventToMouseEvent Just Nothing - -foreign import _eventToMouseEvent - :: forall a - . (a -> Maybe a) - -> Maybe a - -> Event - -> Maybe MouseEvent +eventToMouseEvent :: Event -> F MouseEvent +eventToMouseEvent = readMouseEvent <<< toForeign foreign import screenX :: MouseEvent -> Int diff --git a/src/DOM/Event/WheelEvent.js b/src/DOM/Event/WheelEvent.js index d0bf583..6828b06 100644 --- a/src/DOM/Event/WheelEvent.js +++ b/src/DOM/Event/WheelEvent.js @@ -1,14 +1,5 @@ -/* global WheelEvent */ "use strict"; -exports._eventToWheelEvent = function (just) { - return function (nothing) { - return function (e) { - return e instanceof WheelEvent ? just(e) : nothing; - }; - }; -}; - exports.deltaX = function (e) { return e.deltaX; }; diff --git a/src/DOM/Event/WheelEvent.purs b/src/DOM/Event/WheelEvent.purs index 0714be3..fc00476 100644 --- a/src/DOM/Event/WheelEvent.purs +++ b/src/DOM/Event/WheelEvent.purs @@ -13,19 +13,13 @@ module DOM.Event.WheelEvent import Prelude import Data.Enum (class BoundedEnum, class Enum, Cardinality(..), defaultPred, defaultSucc, toEnum) +import Data.Foreign (F, toForeign) import Data.Maybe (Maybe(..), fromJust) -import DOM.Event.Types (Event, WheelEvent) +import DOM.Event.Types (Event, WheelEvent, readWheelEvent) import DOM.Event.Types (WheelEvent, readWheelEvent, wheelEventToEvent) as T -eventToWheelEvent :: Event -> Maybe WheelEvent -eventToWheelEvent = _eventToWheelEvent Just Nothing - -foreign import _eventToWheelEvent - :: forall a - . (a -> Maybe a) - -> Maybe a - -> Event - -> Maybe WheelEvent +eventToWheelEvent :: Event -> F WheelEvent +eventToWheelEvent = readWheelEvent <<< toForeign foreign import deltaX :: WheelEvent -> Number