This is an alternative site for discovering Elm packages. You may be looking for the official Elm package site instead.
1.0.0
README

Html.Decoder

List of Decoders made to capture DOM events. The types match their equivalent DOM interfaces.

Mouse Events

Wheel Events

Keyboard Events

Composition Events

Gamepad Events

Animation Events

Device Motion / Orientation Events

module Html.Decoder
  ( MouseEvent
  , mouseEvent
  , WheelEvent
  , wheelEvent
  , dom_delta_pixel
  , dom_delta_line
  , dom_delta_page
  , KeyboardEvent
  , keyboardEvent
  , dom_key_location_standard
  , dom_key_location_left
  , dom_key_location_right
  , dom_key_location_numpad
  , CompositionEvent
  , compositionEvent
  , Gamepad
  , gamepad
  , GamepadButton
  , gamepadButton
  , GamepadEvent
  , gamepadEvent
  , AnimationEvent
  , animationEvent
  , DeviceMotionEvent
  , deviceMotionEvent
  , DeviceOrientationEvent
  , deviceOrientationEvent
  , DeviceAcceleration
  , deviceAcceleration
  , DeviceRotationRate
  , deviceRotationRate
  ) where
{-| List of Decoders made to capture DOM events. The types match their
equivalent DOM interfaces.

# Mouse Events
@docs MouseEvent, mouseEvent

# Wheel Events
@docs WheelEvent, wheelEvent, dom_delta_pixel, dom_delta_line, dom_delta_page

# Keyboard Events
@docs KeyboardEvent, keyboardEvent, dom_key_location_standard, dom_key_location_left, dom_key_location_right, dom_key_location_right, dom_key_location_numpad

# Composition Events
@docs CompositionEvent, compositionEvent

# Gamepad Events
@docs GamepadEvent, gamepadEvent, Gamepad, gamepad, GamepadButton, gamepadButton

# Animation Events
@docs AnimationEvent, animationEvent

# Device Motion / Orientation Events
@docs DeviceMotionEvent, deviceMotionEvent, DeviceOrientationEvent, deviceOrientationEvent, deviceAcceleration, deviceAcceleration, DeviceRotationRate, deviceRotationRate

-}


import Json.Decode exposing (Decoder, map, object2, int, bool, float, string, (:=), list)


-- helper --
andMap =
  object2 (<|)


infixl 0 `map`
infixl 0 `andMap`
-----------------
-- Mouse Event --
-----------------

type alias MouseEvent =
  { screenX   : Int
  , screenY   : Int
  , clientX   : Int
  , clientY   : Int
  , ctrlKey   : Bool
  , shiftKey  : Bool
  , altKey    : Bool
  , metaKey   : Bool
  , button    : Int
  }


mouseEvent : Decoder MouseEvent
mouseEvent =
  MouseEvent
    `map`    "screenX"  := int
    `andMap` "screenY"  := int
    `andMap` "clientX"  := int
    `andMap` "clientY"  := int
    `andMap` "ctrlKey"  := bool
    `andMap` "shiftKey" := bool
    `andMap` "altKey"   := bool
    `andMap` "metaKey"  := bool
    `andMap` "button"   := int


-----------------
-- Wheel Event --
-----------------

type alias WheelEvent =
  { screenX   : Int
  , screenY   : Int
  , clientX   : Int
  , clientY   : Int
  , ctrlKey   : Bool
  , shiftKey  : Bool
  , altKey    : Bool
  , metaKey   : Bool
  , button    : Int
  , deltaX    : Float
  , deltaY    : Float
  , deltaZ    : Float
  , deltaMode : Int
  }

wheelEvent : Decoder WheelEvent
wheelEvent =
  WheelEvent
    `map`    "screenX"    := int
    `andMap` "screenY"    := int
    `andMap` "clientX"    := int
    `andMap` "clientY"    := int
    `andMap` "ctrlKey"    := bool
    `andMap` "shiftKey"   := bool
    `andMap` "altKey"     := bool
    `andMap` "metaKey"    := bool
    `andMap` "button"     := int
    `andMap` "deltaX"     := float
    `andMap` "deltaY"     := float
    `andMap` "deltaZ"     := float
    `andMap` "deltaMode"  := int


-- Delta Mode Code
dom_delta_pixel : Int
dom_delta_pixel = 0

dom_delta_line : Int
dom_delta_line = 1

dom_delta_page : Int
dom_delta_page = 2


--------------------
-- Keyboard Event --
--------------------

type alias KeyboardEvent =
  { key         : String
  , code        : String
  , location    : Int
  , ctrlKey     : Bool
  , shiftKey    : Bool
  , altKey      : Bool
  , metaKey     : Bool
  , repeat      : Bool
  , isComposing : Bool
  }


keyboardEvent : Decoder KeyboardEvent
keyboardEvent =
  KeyboardEvent
    `map`    "key"          := string
    `andMap` "code"         := string
    `andMap` "location"     := int
    `andMap` "ctrlKey"      := bool
    `andMap` "shiftKey"     := bool
    `andMap` "altKey"       := bool
    `andMap` "metaKey"      := bool
    `andMap` "repeat"       := bool
    `andMap` "isComposing"  := bool

-- Key location code
dom_key_location_standard : Int
dom_key_location_standard = 0

dom_key_location_left : Int
dom_key_location_left = 1

dom_key_location_right : Int
dom_key_location_right = 2

dom_key_location_numpad : Int
dom_key_location_numpad = 3


-- Composition Event

type alias CompositionEvent =
  { data : String }


compositionEvent : Decoder CompositionEvent
compositionEvent =
  CompositionEvent
    `map` "data" := string

-----------------
-- Touch Event --
-----------------

-- TODO: Figure out getter problem for touch lists
{-}
type alias Touch =
  { identifier  : Int
  , screenX     : Int
  , screenY     : Int
  , clientX     : Int
  , clientY     : Int
  , pageX       : Int
  , pageY       : Int
  }

touch : Decoder Touch
touch =
  Touch
    `map`    "identifier" := int
    `andMap` "screenX"    := int
    `andMap` "screenY"    := int
    `andMap` "clientX"    := int
    `andMap` "clientY"    := int
    `andMap` "pageX"      := int
    `andMap` "pageY"      := int


type alias TouchEvent =
  { touches         : List Touch
  , targetTouches   : List Touch
  , changedTouches  : List Touch
  , altKey    : Bool
  , metaKey   : Bool
  , ctrlKey   : Bool
  , shiftKey  : Bool
  }


touchEvent : Decoder TouchEvent
touchEvent =
  TouchEvent
    `map`    "touches"        := list touch
    `andMap` "targetTouches"  := list touch
    `andMap` "changedTouches" := list touch
    `andMap` "altKey"         := bool
    `andMap` "metaKey"        := bool
    `andMap` "ctrlKey"        := bool
    `andMap` "shiftKey"       := bool
-}
-------------------
-- Gamepad Event --
-------------------

type alias Gamepad =
  { id        : String
  , index     : Int
  , connected : Bool
  , timestamp : Float
  , mapping   : String
  , axes      : List Float
  , buttons   : List GamepadButton
  }

gamepad : Decoder Gamepad
gamepad =
  Gamepad
    `map`    "id"         := string
    `andMap` "index"      := int
    `andMap` "connected"  := bool
    `andMap` "timestamp"  := float
    `andMap` "mapping"    := string
    `andMap` "axes"       := list float
    `andMap` "buttons"    := list gamepadButton


type alias GamepadButton =
  { pressed : Bool
  , value   : Float
  }

gamepadButton : Decoder GamepadButton
gamepadButton =
  GamepadButton
    `map`    "pressed"  := bool
    `andMap` "value"    := float

type alias GamepadEvent =
  { gamepad : Gamepad }

gamepadEvent : Decoder GamepadEvent
gamepadEvent =
  GamepadEvent
    `map` "gamepad" := gamepad

---------------------
-- Animation Event --
---------------------

type alias AnimationEvent =
  { animationName : String
  , elapsedTime   : Float
  , pseudoElement : String
  }

animationEvent : Decoder AnimationEvent
animationEvent =
  AnimationEvent
    `map`    "animationName" := string
    `andMap` "elapsedTime"   := float
    `andMap` "pseudoElement" := string

-------------------------
-- Device Motion Event --
-------------------------

type alias DeviceMotionEvent =
  { acceleration                  : DeviceAcceleration
  , accelerationIncludingGravity  : DeviceAcceleration
  , rotationRate                  : DeviceRotationRate
  , interval                      : Float
  }

deviceMotionEvent : Decoder DeviceMotionEvent
deviceMotionEvent =
  DeviceMotionEvent
    `map`    "acceleration"                 := deviceAcceleration
    `andMap` "accelerationIncludingGravity" := deviceAcceleration
    `andMap` "rotationRate"                 := deviceRotationRate
    `andMap` "interval"                     := float

type alias DeviceOrientationEvent =
  { alpha     : Float
  , beta      : Float
  , gamma     : Float
  , absolute  : Bool
  }

deviceOrientationEvent : Decoder DeviceOrientationEvent
deviceOrientationEvent =
  DeviceOrientationEvent
    `map`    "alpha"    := float
    `andMap` "beta"     := float
    `andMap` "gamma"    := float
    `andMap` "absolute" := bool


type alias DeviceAcceleration =
  { x : Float
  , y : Float
  , z : Float
  }


deviceAcceleration : Decoder DeviceAcceleration
deviceAcceleration =
  DeviceAcceleration
    `map`    "x" := float
    `andMap` "y" := float
    `andMap` "z" := float



type alias DeviceRotationRate =
  { alpha : Float
  , beta  : Float
  , gamma : Float
  }


deviceRotationRate : Decoder DeviceRotationRate
deviceRotationRate =
  DeviceRotationRate
    `map`    "alpha" := float
    `andMap` "beta"  := float
    `andMap` "gamma" := float