React.Basic.Events

type EventHandler = EffectFn1 SyntheticEvent Unit

An event handler, which receives a SyntheticEvent and performs some effects in return.

data SyntheticEvent :: Type

Event data that we receive from React.

newtype EventFn a b

Encapsulates a safe event operation. EventFns can be composed to perform multiple operations.

For example:

input { onChange: handler (preventDefault >>> targetValue)
                    \value -> setState \_ -> { value }
      }

Instances

• Semigroupoid EventFn
• Category EventFn
• (IsSymbol l, Cons l (EventFn a b) fns_rest fns, Cons l b r_rest r, Lacks l fns_rest, Lacks l r_rest, Merge rest fns_rest a r_rest) => Merge (Cons l (EventFn a b) rest) fns a r

unsafeEventFn :: forall b a. (a -> b) -> EventFn a b

Unsafely create an EventFn. This function should be avoided as it can allow a SyntheticEvent to escape its scope. Accessing a React event's properties is only valid in a synchronous event callback.

Instead, use the helper functions specific to your platform, such as React.Basic.DOM.Events.

handler :: forall a. EventFn SyntheticEvent a -> (a -> Effect Unit) -> EventHandler

Create an EventHandler, given an EventFn and a callback.

For example:

input { onChange: handler targetValue
                    \value -> setState \_ -> { value }
      }

handler_ :: Effect Unit -> EventHandler

Create an EventHandler which discards the SyntheticEvent.

For example:

input { onChange: handler_ (setState \_ -> { value })
      }

syntheticEvent :: EventFn SyntheticEvent SyntheticEvent

merge :: forall r fns_list fns a. RowToList fns fns_list => Merge fns_list fns a r => Record fns -> EventFn a (Record r)

Merge multiple EventFn operations and collect their results.

For example:

input { onChange: handler (merge { targetValue, timeStamp })
                    \{ targetValue, timeStamp } -> setState \_ -> { ... }
      }

class Merge (rl :: RowList) fns a r | rl -> fns, rl a -> r where

Members

• mergeImpl :: RLProxy rl -> Record fns -> EventFn a (Record r)

Instances

• Merge Nil () a ()
• (IsSymbol l, Cons l (EventFn a b) fns_rest fns, Cons l b r_rest r, Lacks l fns_rest, Lacks l r_rest, Merge rest fns_rest a r_rest) => Merge (Cons l (EventFn a b) rest) fns a r