https://lynxjs.org/api/elements/built-in/view.html#touchstart

It belongs to touch event, which is triggered when the finger starts to touch the touch surface.

@ data Action = HandleTouch TouchEvent

view model = view_ [ onTouchStart HandleTouch ]

update :: Action -> Effect props Model Action update (HandleTouch TouchEvent {..}) = do io_ (consoleLog "touch event received")

Like onTouchStart, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTouchStart, but dispatched on the Lynx main thread (MTS).

data Action = HandleTouch TouchEvent

view_ [ event (static (onTouchStartMain HandleTouch)) ] [ "some view" ]

Like onTouchStartMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTouch TouchEvent Model DOMRef

view_ [ event (static (onTouchStartMainWith HandleTouch)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#touchmove

It belongs to touch event, which is triggered when the finger moves on the touch surface.

data Action = HandleTouch TouchEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onTouchMove HandleTouch ]

update :: Action -> Effect context props Model Action
update (HandleTouch TouchEvent {..}) = do
  io_ (consoleLog "touch event received")

Like onTouchMove, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTouchMove, but dispatched on the Lynx main thread (MTS).

data Action = HandleTouch TouchEvent

view_ [ event (static (onTouchMoveMain HandleTouch)) ] [ "some view" ]

Like onTouchMoveMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTouch TouchEvent Model DOMRef

view_ [ event (static (onTouchMoveMainWith HandleTouch)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#touchend

It belongs to touch event, which is triggered when the finger leaves the touch surface.

data Action = HandleTouch TouchEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onTouchEnd HandleTouch ]

update :: Action -> Effect context props Model Action
update (HandleTouch TouchEvent {..}) = do
  io_ (consoleLog "touch event received")

Like onTouchEnd, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTouchEnd, but dispatched on the Lynx main thread (MTS).

data Action = HandleTouch TouchEvent

view_ [ event (static (onTouchEndMain HandleTouch)) ] [ "some view" ]

Like onTouchEndMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTouch TouchEvent Model DOMRef

view_ [ event (static (onTouchEndMainWith HandleTouch)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#touchcancel

It belongs to touch event, which is triggered when the touch event, is interrupted by the system or Lynx external gesture.

data Action = HandleTouch TouchEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onTouchCancel HandleTouch ]

update :: Action -> Effect context props Model Action
update (HandleTouch TouchEvent {..}) =
  io_ (consoleLog "touch event received")

Like onTouchCancel, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTouchCancel, but dispatched on the Lynx main thread (MTS).

data Action = HandleTouch TouchEvent

view_ [ event (static (onTouchCancelMain HandleTouch)) ] [ "some view" ]

Like onTouchCancelMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTouch TouchEvent Model DOMRef

view_ [ event (static (onTouchCancelMainWith HandleTouch)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#tap

It belongs to touch event, which is triggered when the finger clicks on the touch surface.

data Action = HandleTap

view :: context -> props -> Model -> View context Action
view model = view_ [ onTap HandleTap ]

update :: Action -> Effect context props Model Action
update HandleTap = io_ (consoleLog "touch event received")

https://lynxjs.org/api/elements/built-in/view.html#tap

It belongs to touch event, which is triggered when the finger clicks on the touch surface.

Unlike onTap, onTapMain is necessary for handling tap events on the main thread (MTS).

data Action = HandleTap

view :: context -> props -> Model -> View context Action
view model = view_ [ event $ static (onTapMain HandleTap) ]

update :: Action -> Effect context props Model Action
update HandleTap = io_ (consoleLog "touch event received")

Like onTap, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

https://lynxjs.org/api/elements/built-in/view.html#tap

It belongs to touch event, which is triggered when the finger clicks on the touch surface.

Unlike onTap, onTapMain is necessary for handling tap events on the main thread (MTS).

data Action = HandleTap

view :: context -> props -> Model -> View context Action
view model = view_ [ event $ static (onTapMain HandleTap) ]

update :: Action -> Effect context props Model Action
update HandleTap = io_ (consoleLog "touch event received")

https://lynxjs.org/api/elements/built-in/view.html#tap

It belongs to touch event, which is triggered when the finger clicks on the touch surface.

Unlike onTap, onTapMain is necessary for handling tap events on the main thread (MTS).

data Action = HandleTap

view :: context -> props -> Model -> View context Action
view model = view_ [ event $ static (onTapMain HandleTap) ]

update :: Action -> Effect context props Model Action
update HandleTap = io_ (consoleLog "touch event received")

https://lynxjs.org/api/elements/built-in/view.html#longpress

It belongs to the touch event, which is triggered when the finger is long pressed on the touch surface, and the interval between long press triggers is `500 ms`.

data Action = HandleTouch TouchEvent

view :: context -> props -> Model -> View context Action
view model = view_ [ onLongPress HandleTouch ]

update :: Action -> Effect context props Model Action
update (HandleTouch TouchEvent {..}) = io_ (consoleLog "touch event received")

Like onLongPress, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onLongPress, but dispatched on the Lynx main thread (MTS).

data Action = HandleTouch TouchEvent

view_ [ event (static (onLongPressMain HandleTouch)) ] [ "some view" ]

Like onLongPressMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTouch TouchEvent Model DOMRef

view_ [ event (static (onLongPressMainWith HandleTouch)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#layoutchange

It belongs to a custom event, which is triggered when the target node layout is completed, and returns the position information of the target node relative to the LynxView viewport coordinate system.

data Action = HandleLayout LayoutChangeDetailEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onLayoutChange HandleLayout ]

update :: Action -> Effect context props Model Action
update (HandleLayout LayoutChangeDetailEvent {..}) =
  io_ (consoleLog "layout changed")

Like onLayoutChange, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onLayoutChange, but dispatched on the Lynx main thread (MTS).

data Action = HandleLayout LayoutChangeDetailEvent

view_ [ event (static (onLayoutChangeMain HandleLayout)) ] [ "some view" ]

Like onLayoutChangeMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleLayout LayoutChangeDetailEvent Model DOMRef

view_ [ event (static (onLayoutChangeMainWith HandleLayout)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#uiappear

It belongs to custom event, which is triggered when the target node appears on the screen.

data Action = HandleUI UIAppearanceDetailEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onAppear HandleUI ]

update :: Action -> Effect context props Model Action
update (HandleUI UIAppearanceDetailEvent {..}) = do
  io_ (consoleLog "appearance detail event received")

Like onAppear, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onAppear, but dispatched on the Lynx main thread (MTS).

data Action = HandleAppear UIAppearanceDetailEvent

view_ [ event (static (onAppearMain HandleAppear)) ] [ "some view" ]

Like onAppearMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleAppear UIAppearanceDetailEvent Model DOMRef

view_ [ event (static (onAppearMainWith HandleAppear)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#uidisappear

It belongs to custom event, which is triggered when the target node appears on the screen.

data Action = HandleUI UIAppearanceDetailEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onDisappear HandleUI ]

update :: Action -> Effect props Model Action
update (HandleUI UIAppearanceDetailEvent {..}) = do
  io_ (consoleLog "appearance detail event received")

Like onDisappear, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onDisappear, but dispatched on the Lynx main thread (MTS).

data Action = HandleDisappear UIAppearanceDetailEvent

view_ [ event (static (onDisappearMain HandleDisappear)) ] [ "some view" ]

Like onDisappearMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleDisappear UIAppearanceDetailEvent Model DOMRef

view_ [ event (static (onDisappearMainWith HandleDisappear)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#animationstart

It belongs to animation event, which is triggered when the Animation animation starts.

data Action = HandleAnimation AnimationEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onAnimationStart HandleAnimation ]

update :: Action -> Effect context props Model Action
update (HandleAnimation AnimationEvent {..}) =
  io_ (consoleLog "animation event received")

Like onAnimationStart, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onAnimationStart, but dispatched on the Lynx main thread (MTS).

data Action = HandleAnimation AnimationEvent

view_ [ event (static (onAnimationStartMain HandleAnimation)) ] [ "some view" ]

Like onAnimationStartMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleAnimation AnimationEvent Model DOMRef

view_ [ event (static (onAnimationStartMainWith HandleAnimation)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#animationend

It belongs to animation event, which is triggered when the Animation animation ends.

data Action = HandleAnimation AnimationEvent

view :: context -> props -> Model -> View context Action
view model = view_ [ onAnimationEnd HandleAnimation ]

update :: Action -> Effect context props Model Action
update (HandleAnimation AnimationEvent {..}) =
  io_ (consoleLog "animation event received")

Like onAnimationEnd, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onAnimationEnd, but dispatched on the Lynx main thread (MTS).

data Action = HandleAnimation AnimationEvent

view_ [ event (static (onAnimationEndMain HandleAnimation)) ] [ "some view" ]

Like onAnimationEndMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleAnimation AnimationEvent Model DOMRef

view_ [ event (static (onAnimationEndMainWith HandleAnimation)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#animationcancel

It belongs to animation event, which is triggered when the Animation animation cancels.

data Action = HandleAnimation AnimationEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onAnimationCancel HandleAnimation ]

update :: Action -> Effect context props Model Action
update (HandleAnimation AnimationEvent {..}) =
  io_ (consoleLog "animation event received")

Like onAnimationCancel, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onAnimationCancel, but dispatched on the Lynx main thread (MTS).

data Action = HandleAnimation AnimationEvent

view_ [ event (static (onAnimationCancelMain HandleAnimation)) ] [ "some view" ]

Like onAnimationCancelMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleAnimation AnimationEvent Model DOMRef

view_ [ event (static (onAnimationCancelMainWith HandleAnimation)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#animationiteration

It belongs to animation event, which is triggered when the Animation animation iterates.

data Action = HandleAnimation AnimationEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onAnimationIteration HandleAnimation ]

update :: Action -> Effect context props Model Action
update (HandleAnimation AnimationEvent {..}) =
  io_ (consoleLog "animation event received")

Like onAnimationIteration, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onAnimationIteration, but dispatched on the Lynx main thread (MTS).

data Action = HandleAnimation AnimationEvent

view_ [ event (static (onAnimationIterationMain HandleAnimation)) ] [ "some view" ]

Like onAnimationIterationMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleAnimation AnimationEvent Model DOMRef

view_ [ event (static (onAnimationIterationMainWith HandleAnimation)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#transitionstart

It belongs to animation event, which is triggered when the Transition animation starts.

data Action = HandleTransition AnimationEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onTransitionStart HandleTransition ]

update :: Action -> Effect context props Model Action
update (HandleTransition TransitionEvent {..}) =
  io_ (consoleLog "transition event received")

Like onTransitionStart, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTransitionStart, but dispatched on the Lynx main thread (MTS).

data Action = HandleTransition AnimationEvent

view_ [ event (static (onTransitionStartMain HandleTransition)) ] [ "some view" ]

Like onTransitionStartMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTransition AnimationEvent Model DOMRef

view_ [ event (static (onTransitionStartMainWith HandleTransition)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#transitionend

It belongs to animation event, which is triggered when the Transition animation ends.

data Action = HandleTransition AnimationEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onTransitionEnd HandleTransition ]

update :: Action -> Effect context props Model Action
update (HandleTransition TransitionEvent {..}) =
  io_ (consoleLog "transition event received")

Like onTransitionEnd, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTransitionEnd, but dispatched on the Lynx main thread (MTS).

data Action = HandleTransition AnimationEvent

view_ [ event (static (onTransitionEndMain HandleTransition)) ] [ "some view" ]

Like onTransitionEndMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTransition AnimationEvent Model DOMRef

view_ [ event (static (onTransitionEndMainWith HandleTransition)) ] [ "some view" ]

https://lynxjs.org/api/elements/built-in/view.html#transitioncancel

It belongs to animation event, which is triggered when the Transition animation cancels.

data Action = HandleTransition AnimationEvent

view :: context -> props -> Model -> View context Action
view _ _ model = view_ [ onTransitionCancel HandleTransition ]

update :: Action -> Effect context props Model Action
update (HandleTransition TransitionEvent {..}) =
  io_ (consoleLog "transition event received")

Like onTransitionCancel, but the handler also receives the target element's DOMRef. Use for main-thread (MTS) handlers that imperatively mutate the element.

Like onTransitionCancel, but dispatched on the Lynx main thread (MTS).

data Action = HandleTransition AnimationEvent

view_ [ event (static (onTransitionCancelMain HandleTransition)) ] [ "some view" ]

Like onTransitionCancelMain, but also receives read-only access to the model and the target element's DOMRef (for imperative MTS mutation).

data Action = HandleTransition AnimationEvent Model DOMRef

view_ [ event (static (onTransitionCancelMainWith HandleTransition)) ] [ "some view" ]

https://lynxjs.org/api/lynx-api/event/touch-event.html

https://lynxjs.org/api/lynx-api/event/animation-event.html

Touch decoder for use with events like onTap

Animation decoder for use with events like onAnimationStart