atomvm_gleam/emscripten

Typed Gleam wrappers for AtomVM emscripten JS interop (emscripten module).

Emscripten / WASM platform only. On other platforms NIFs are undefined and calls return NotSupported.

JavaScript can send messages to a registered Erlang process:

Module.cast('proc', 'message') → {emscripten, {cast, <<"message">>}}
await Module.call('proc', 'message') → {emscripten, {call, Promise, <<"message">>}}

Resolve or reject the opaque Promise with promise_resolve / promise_reject. Tracked handles from run_script_tracked keep JS values alive until GC.

HTML5 event callbacks

Register with register_*_with (target + options), the no-options register_* form, or register_*_with_user_data for the upstream /3 arity. Unregister with unregister_* using a ListenerHandle (preferred) or Html5Target.

Inbound message shape

Without user data: {emscripten, {EventName, EventMap}}.

With user data (register_*_with_user_data): {emscripten, {EventName, EventMap}, UserData} — an outer 3-tuple; the third element is the term you passed at register time (copied into the listener handle). User data is any Erlang term: Gleam Int, String, tuples, lists, atoms via FFI, etc. Keep it small — the handle retains a copy for the listener lifetime.

If the registering process dies, that callback and any other callback for the same event on the same target are unregistered (upstream behaviour).

HTML5 exports

Keyboard: keypress, keydown, keyup. Mouse: click, dblclick, mousedown, mouseup, mousemove, mouseenter, mouseleave, mouseover, mouseout. Other: wheel, resize, scroll, blur, focus, focusin, focusout, touchstart, touchend, touchmove, touchcancel.

Upstream: libs/avm_emscripten/src/emscripten.erl · Docs: Module emscripten

Types

Error

</>

Errors from emscripten NIFs and helpers.

Known reason atoms are Gleam constructors (so {error, not_supported} is Error(NotSupported)). Bare AtomVM error becomes Failed. Integer HTML5 register codes become Code(n). Anything else lands in Other.

pub type Error {
  Failed
  NotSupported
  Badarg
  Timeout
  InvalidTarget
  UnknownTarget
  FailedNotDeferred
  NoData
  TimedOut
  Code(Int)
  Other(String)
}

Constructors

```
Failed
```
```
NotSupported
```
```
Badarg
```
```
Timeout
```
```
InvalidTarget
```
```
UnknownTarget
```
```
FailedNotDeferred
```
```
NoData
```
```
TimedOut
```
```
Code(Int)
```
```
Other(String)
```

FocusEvent

</>

Focus event map from blur / focus / focusin / focusout.

Keys: node_name / id (UTF-8 binary).

pub type FocusEvent

GetTracked

</>

Result of get_tracked: integer keys or per-handle values.

pub type GetTracked {
  Keys(List(Int))
  Values(List(Result(BitArray, TrackedFetchError)))
}

Constructors

```
Keys(List(Int))
```

Values(List(Result(BitArray, TrackedFetchError)))

Html5Target

</>

HTML5 register target. Maps to Erlang window / document / screen or a CSS selector string (iodata).

Screen is accepted by upstream but may not deliver events (emscripten#19865).

pub type Html5Target {
  Window
  Document
  Screen
  CssSelector(String)
}

Constructors

```
Window
```
```
Document
```
```
Screen
```
```
CssSelector(String)
```

KeyboardEvent

</>

Keyboard event map from keypress / keydown / keyup.

Delivered as {emscripten, {keypress | keydown | keyup, Event}}. Erlang map keys: timestamp (Float), location (Int), ctrl_key / shift_key / alt_key / meta_key / repeat (Bool), char_code / key_code / which (Int), key / code / char_value / locale (UTF-8 binary).

pub type KeyboardEvent

ListenerHandle

</>

Opaque listener resource from a successful HTML5 register call.

Prefer passing this to unregister over a bare target so the handle can be garbage-collected. Upstream type is an opaque binary.

pub type ListenerHandle

ListenerOrTarget

</>

Argument to HTML5 unregister: a listener handle (preferred) or a target.

Unregistering by target removes every listener for that event on the target. Passing a handle is recommended for memory efficiency.

pub type ListenerOrTarget {
  Handle(ListenerHandle)
  Target(Html5Target)
}

Constructors

```
Handle(ListenerHandle)
```
```
Target(Html5Target)
```

MouseEvent

</>

Mouse event map from click / dblclick / mouse* callbacks.

Delivered as {emscripten, {click | …, Event}}. Keys: timestamp (Float), screen_x / screen_y / client_x / client_y / button / buttons / movement_x / movement_y / target_x / target_y / padding (Int), ctrl_key / shift_key / alt_key / meta_key (Bool).

pub type MouseEvent

Promise

</>

Opaque promise resource from {emscripten, {call, Promise, Msg}}.

Pass to promise_resolve or promise_reject. Upstream type is an opaque binary.

pub type Promise

PromiseValue

</>

Value passed to promise_resolve_with / promise_reject_with.

Upstream accepts an integer or iodata (string).

pub type PromiseValue {
  IntValue(Int)
  StringValue(String)
}

Constructors

```
IntValue(Int)
```
```
StringValue(String)
```

RegisterOk

</>

Successful HTML5 register result.

Upstream {ok, Handle} → Registered; {ok, Handle, deferred} → Deferred (listener queued until the main thread applied it).

pub type RegisterOk {
  Registered(ListenerHandle)
  Deferred(ListenerHandle)
}

Constructors

```
Registered(ListenerHandle)
```
```
Deferred(ListenerHandle)
```

RegisterOption

</>

Single option for HTML5 register calls.

Maps to Erlang {use_capture, Bool} / {prevent_default, Bool}. PreventDefault(True) means the handler tells JavaScript to prevent the default action.

pub type RegisterOption {
  UseCapture(Bool)
  PreventDefault(Bool)
}

Constructors

```
UseCapture(Bool)
```
```
PreventDefault(Bool)
```

RunScriptOption

</>

Options for run_script_with. Map to Erlang main_thread / async.

Async only applies when MainThread is also specified.

pub type RunScriptOption {
  MainThread
  Async
}

Constructors

```
MainThread
```
```
Async
```

TouchEvent

</>

Touch event map from touchstart / touchend / touchmove / touchcancel.

Keys: timestamp (Float), ctrl_key / shift_key / alt_key / meta_key (Bool), touches (list of touch-point maps with identifier, screen_x / screen_y, client_x / client_y, page_x / page_y, is_changed / on_target, target_x / target_y).

pub type TouchEvent

TrackedFetchError

</>

Per-handle result when fetching tracked values (TrackedValue).

Upstream: {ok, Binary} | {error, badkey} | {error, badvalue}.

pub type TrackedFetchError {
  BadKey
  BadValue
}

Constructors

```
BadKey
```
```
BadValue
```

TrackedField

</>

Field selector for get_tracked. FFI remaps to Erlang key / value (Gleam atoms would be tracked_key / tracked_value).

pub type TrackedField {
  TrackedKey
  TrackedValue
}

Constructors

```
TrackedKey
```
```
TrackedValue
```

TrackedObject

</>

Opaque handle to a JavaScript value kept alive in Module.trackedObjectsMap until this term is garbage-collected.

pub type TrackedObject

UiEvent

</>

UI event map from resize / scroll.

Keys: detail, document_body_client_width / document_body_client_height, window_inner_width / window_inner_height, window_outer_width / window_outer_height, scroll_top / scroll_left (all Int).

pub type UiEvent

WheelEvent

</>

Wheel event map (extends mouse fields with deltas).

Keys: all MouseEvent keys plus delta_x / delta_y / delta_z / delta_mode (Int).

pub type WheelEvent

Values

error_to_string

</>

pub fn error_to_string(error: Error) -> String

Format an Error for logging.

get_tracked

</>

pub fn get_tracked(
  objects: List(TrackedObject),
  field: TrackedField,
) -> Result(GetTracked, Error)

Get keys or current string values of tracked object handles.

TrackedKey returns integer map keys (no main-thread round-trip). TrackedValue fetches UTF-8 string values via the main-thread hook.

See emscripten:get_tracked/2.

promise_reject

</>

pub fn promise_reject(promise: Promise) -> Result(Nil, Error)

Reject a promise with 0 (default rejection value).

See emscripten:promise_reject/1.

promise_reject_with

</>

pub fn promise_reject_with(
  promise: Promise,
  value: PromiseValue,
) -> Result(Nil, Error)

Reject a promise with an integer or string value.

See emscripten:promise_reject/2.

promise_resolve

</>

pub fn promise_resolve(promise: Promise) -> Result(Nil, Error)

Resolve a promise with 0 (default success value).

See emscripten:promise_resolve/1.

promise_resolve_with

</>

pub fn promise_resolve_with(
  promise: Promise,
  value: PromiseValue,
) -> Result(Nil, Error)

Resolve a promise with an integer or string value.

See emscripten:promise_resolve/2.

register_blur

</>

pub fn register_blur(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {blur, FocusEvent}}.

See emscripten:register_blur_callback/1.

register_blur_with

</>

pub fn register_blur_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_blur_callback/2.

register_blur_with_user_data

</>

pub fn register_blur_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {blur, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {blur, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_blur_callback/3.

register_click

</>

pub fn register_click(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {click, MouseEvent}}.

See emscripten:register_click_callback/1.

register_click_with

</>

pub fn register_click_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_click_callback/2.

register_click_with_user_data

</>

pub fn register_click_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {click, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {click, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_click_callback/3.

register_dblclick

</>

pub fn register_dblclick(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_dblclick_callback/1.

register_dblclick_with

</>

pub fn register_dblclick_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_dblclick_callback/2.

register_dblclick_with_user_data

</>

pub fn register_dblclick_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {dblclick, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {dblclick, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_dblclick_callback/3.

register_focus

</>

pub fn register_focus(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_focus_callback/1.

register_focus_with

</>

pub fn register_focus_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_focus_callback/2.

register_focus_with_user_data

</>

pub fn register_focus_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {focus, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {focus, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_focus_callback/3.

register_focusin

</>

pub fn register_focusin(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_focusin_callback/1.

register_focusin_with

</>

pub fn register_focusin_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_focusin_callback/2.

register_focusin_with_user_data

</>

pub fn register_focusin_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {focusin, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {focusin, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_focusin_callback/3.

register_focusout

</>

pub fn register_focusout(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_focusout_callback/1.

register_focusout_with

</>

pub fn register_focusout_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_focusout_callback/2.

register_focusout_with_user_data

</>

pub fn register_focusout_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {focusout, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {focusout, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_focusout_callback/3.

register_keydown

</>

pub fn register_keydown(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_keydown_callback/1.

register_keydown_with

</>

pub fn register_keydown_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_keydown_callback/2.

register_keydown_with_user_data

</>

pub fn register_keydown_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {keydown, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {keydown, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_keydown_callback/3.

register_keypress

</>

pub fn register_keypress(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {keypress, KeyboardEvent}}. Dying processes unregister callbacks for this event/target.

See emscripten:register_keypress_callback/1.

register_keypress_with

</>

pub fn register_keypress_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_keypress_callback/2.

register_keypress_with_user_data

</>

pub fn register_keypress_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {keypress, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {keypress, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_keypress_callback/3.

register_keyup

</>

pub fn register_keyup(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_keyup_callback/1.

register_keyup_with

</>

pub fn register_keyup_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_keyup_callback/2.

register_keyup_with_user_data

</>

pub fn register_keyup_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {keyup, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {keyup, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_keyup_callback/3.

register_mousedown

</>

pub fn register_mousedown(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mousedown_callback/1.

register_mousedown_with

</>

pub fn register_mousedown_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mousedown_callback/2.

register_mousedown_with_user_data

</>

pub fn register_mousedown_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mousedown, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mousedown, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mousedown_callback/3.

register_mouseenter

</>

pub fn register_mouseenter(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mouseenter_callback/1.

register_mouseenter_with

</>

pub fn register_mouseenter_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mouseenter_callback/2.

register_mouseenter_with_user_data

</>

pub fn register_mouseenter_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mouseenter, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mouseenter, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mouseenter_callback/3.

register_mouseleave

</>

pub fn register_mouseleave(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mouseleave_callback/1.

register_mouseleave_with

</>

pub fn register_mouseleave_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mouseleave_callback/2.

register_mouseleave_with_user_data

</>

pub fn register_mouseleave_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mouseleave, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mouseleave, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mouseleave_callback/3.

register_mousemove

</>

pub fn register_mousemove(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mousemove_callback/1.

register_mousemove_with

</>

pub fn register_mousemove_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mousemove_callback/2.

register_mousemove_with_user_data

</>

pub fn register_mousemove_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mousemove, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mousemove, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mousemove_callback/3.

register_mouseout

</>

pub fn register_mouseout(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mouseout_callback/1.

register_mouseout_with

</>

pub fn register_mouseout_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mouseout_callback/2.

register_mouseout_with_user_data

</>

pub fn register_mouseout_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mouseout, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mouseout, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mouseout_callback/3.

register_mouseover

</>

pub fn register_mouseover(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mouseover_callback/1.

register_mouseover_with

</>

pub fn register_mouseover_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mouseover_callback/2.

register_mouseover_with_user_data

</>

pub fn register_mouseover_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mouseover, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mouseover, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mouseover_callback/3.

register_mouseup

</>

pub fn register_mouseup(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_mouseup_callback/1.

register_mouseup_with

</>

pub fn register_mouseup_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_mouseup_callback/2.

register_mouseup_with_user_data

</>

pub fn register_mouseup_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {mouseup, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {mouseup, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_mouseup_callback/3.

register_resize

</>

pub fn register_resize(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {resize, UiEvent}}.

See emscripten:register_resize_callback/1.

register_resize_with

</>

pub fn register_resize_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_resize_callback/2.

register_resize_with_user_data

</>

pub fn register_resize_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {resize, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {resize, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_resize_callback/3.

register_scroll

</>

pub fn register_scroll(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {scroll, UiEvent}}.

See emscripten:register_scroll_callback/1.

register_scroll_with

</>

pub fn register_scroll_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_scroll_callback/2.

register_scroll_with_user_data

</>

pub fn register_scroll_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {scroll, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {scroll, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_scroll_callback/3.

register_touchcancel

</>

pub fn register_touchcancel(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_touchcancel_callback/1.

register_touchcancel_with

</>

pub fn register_touchcancel_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_touchcancel_callback/2.

register_touchcancel_with_user_data

</>

pub fn register_touchcancel_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {touchcancel, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {touchcancel, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_touchcancel_callback/3.

register_touchend

</>

pub fn register_touchend(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_touchend_callback/1.

register_touchend_with

</>

pub fn register_touchend_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_touchend_callback/2.

register_touchend_with_user_data

</>

pub fn register_touchend_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {touchend, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {touchend, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_touchend_callback/3.

register_touchmove

</>

pub fn register_touchmove(
  target: Html5Target,
) -> Result(RegisterOk, Error)

See emscripten:register_touchmove_callback/1.

register_touchmove_with

</>

pub fn register_touchmove_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_touchmove_callback/2.

register_touchmove_with_user_data

</>

pub fn register_touchmove_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {touchmove, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {touchmove, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_touchmove_callback/3.

register_touchstart

</>

pub fn register_touchstart(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {touchstart, TouchEvent}}.

See emscripten:register_touchstart_callback/1.

register_touchstart_with

</>

pub fn register_touchstart_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_touchstart_callback/2.

register_touchstart_with_user_data

</>

pub fn register_touchstart_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {touchstart, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {touchstart, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_touchstart_callback/3.

register_wheel

</>

pub fn register_wheel(
  target: Html5Target,
) -> Result(RegisterOk, Error)

Events: {emscripten, {wheel, WheelEvent}}.

See emscripten:register_wheel_callback/1.

register_wheel_with

</>

pub fn register_wheel_with(
  target: Html5Target,
  options: List(RegisterOption),
) -> Result(RegisterOk, Error)

See emscripten:register_wheel_callback/2.

register_wheel_with_user_data

</>

pub fn register_wheel_with_user_data(
  target: Html5Target,
  options: List(RegisterOption),
  user_data: user_data,
) -> Result(RegisterOk, Error)

Events: {emscripten, {wheel, Event}, UserData} (outer 3-tuple). Without user data the shape is {emscripten, {wheel, Event}}. user_data is any Erlang term; the listener handle retains a copy.

See emscripten:register_wheel_callback/3.

run_script

</>

pub fn run_script(script: String) -> Result(Nil, Error)

Run a script on the current worker thread (rarely useful alone).

Prefer run_script_with with [MainThread] or [MainThread, Async]. Exception handling is disabled — a throw or compile error crashes the VM.

See emscripten:run_script/1.

run_script_tracked

</>

pub fn run_script_tracked(
  script: String,
) -> Result(List(TrackedObject), Error)

Run a script on the main thread and return tracked handles for the JS values it evaluates to (default hook expects an array).

See emscripten:run_script_tracked/1.

run_script_with

</>

pub fn run_script_with(
  script: String,
  options: List(RunScriptOption),
) -> Result(Nil, Error)

Run a script with options (MainThread, Async).

See emscripten:run_script/2.

unregister_blur

</>

pub fn unregister_blur(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister blur listeners.

See emscripten:unregister_blur_callback/1.

unregister_click

</>

pub fn unregister_click(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister click listeners.

See emscripten:unregister_click_callback/1.

unregister_dblclick

</>

pub fn unregister_dblclick(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister dblclick listeners.

See emscripten:unregister_dblclick_callback/1.

unregister_focus

</>

pub fn unregister_focus(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister focus listeners.

See emscripten:unregister_focus_callback/1.

unregister_focusin

</>

pub fn unregister_focusin(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister focusin listeners.

See emscripten:unregister_focusin_callback/1.

unregister_focusout

</>

pub fn unregister_focusout(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister focusout listeners.

See emscripten:unregister_focusout_callback/1.

unregister_keydown

</>

pub fn unregister_keydown(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister keydown listeners.

See emscripten:unregister_keydown_callback/1.

unregister_keypress

</>

pub fn unregister_keypress(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister keypress listeners (by handle or target).

See emscripten:unregister_keypress_callback/1.

unregister_keyup

</>

pub fn unregister_keyup(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister keyup listeners.

See emscripten:unregister_keyup_callback/1.

unregister_mousedown

</>

pub fn unregister_mousedown(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mousedown listeners.

See emscripten:unregister_mousedown_callback/1.

unregister_mouseenter

</>

pub fn unregister_mouseenter(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mouseenter listeners.

See emscripten:unregister_mouseenter_callback/1.

unregister_mouseleave

</>

pub fn unregister_mouseleave(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mouseleave listeners.

See emscripten:unregister_mouseleave_callback/1.

unregister_mousemove

</>

pub fn unregister_mousemove(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mousemove listeners.

See emscripten:unregister_mousemove_callback/1.

unregister_mouseout

</>

pub fn unregister_mouseout(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mouseout listeners.

See emscripten:unregister_mouseout_callback/1.

unregister_mouseover

</>

pub fn unregister_mouseover(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mouseover listeners.

See emscripten:unregister_mouseover_callback/1.

unregister_mouseup

</>

pub fn unregister_mouseup(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister mouseup listeners.

See emscripten:unregister_mouseup_callback/1.

unregister_resize

</>

pub fn unregister_resize(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister resize listeners.

See emscripten:unregister_resize_callback/1.

unregister_scroll

</>

pub fn unregister_scroll(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister scroll listeners.

See emscripten:unregister_scroll_callback/1.

unregister_touchcancel

</>

pub fn unregister_touchcancel(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister touchcancel listeners.

See emscripten:unregister_touchcancel_callback/1.

unregister_touchend

</>

pub fn unregister_touchend(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister touchend listeners.

See emscripten:unregister_touchend_callback/1.

unregister_touchmove

</>

pub fn unregister_touchmove(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister touchmove listeners.

See emscripten:unregister_touchmove_callback/1.

unregister_touchstart

</>

pub fn unregister_touchstart(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister touchstart listeners.

See emscripten:unregister_touchstart_callback/1.

unregister_wheel

</>

pub fn unregister_wheel(
  arg: ListenerOrTarget,
) -> Result(Nil, Error)

Unregister wheel listeners.

See emscripten:unregister_wheel_callback/1.