packages/wasm-api-dom/src/generated/api.ts
/**
* Generated by @thi.ng/wasm-api-bindgen at 2023-03-26T00:14:48.760Z
* DO NOT EDIT!
*/
// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type MemorySlice, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
export enum EventType {
UNKOWN = -1,
DRAG,
FOCUS,
INPUT,
KEY,
MOUSE,
POINTER,
SCROLL,
TOUCH,
WHEEL,
}
export enum MouseButton {
NONE,
PRIMARY = 1,
SECONDARY = 2,
MIDDLE = 4,
}
export enum PointerType {
MOUSE,
PEN,
TOUCH,
}
export enum WheelDeltaMode {
PIXEL,
LINE,
PAGE,
}
export enum KeyModifier {
SHIFT = 1,
CTRL = 2,
ALT = 4,
META = 8,
}
/**
* Various browser window related information [TODO]
*/
export interface WindowInfo extends WasmTypeBase {
/**
* Zig type: `u16`
*/
innerWidth: number;
/**
* Zig type: `u16`
*/
innerHeight: number;
/**
* Horizontal scroll offset in fractional CSS pixels
*
* @remarks
* Zig type: `f32`
*/
scrollX: number;
/**
* Vertical scroll offset in fractional CSS pixels
*
* @remarks
* Zig type: `f32`
*/
scrollY: number;
/**
* Current device pixel ratio
*
* @remarks
* Zig type: `u8`
*/
dpr: number;
/**
* Encoded bitmask indicating fullscreen status / capability:
* - 1 (bit 0): fullscreen active
* - 2 (bit 1): fullscreen supported
*
* @remarks
* Zig type: `u8`
*/
fullscreen: number;
}
export const $WindowInfo: WasmTypeConstructor<WindowInfo> = (mem) => ({
get align() {
return 4;
},
get size() {
return 16;
},
instanceArray(base, num) {
const items: WindowInfo[] = [];
for (; num --> 0; base += 16) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 16);
},
get innerWidth(): number {
return mem.u16[base >>> 1];
},
set innerWidth(x: number) {
mem.u16[base >>> 1] = x;
},
get innerHeight(): number {
return mem.u16[(base + 2) >>> 1];
},
set innerHeight(x: number) {
mem.u16[(base + 2) >>> 1] = x;
},
get scrollX(): number {
return mem.f32[(base + 4) >>> 2];
},
set scrollX(x: number) {
mem.f32[(base + 4) >>> 2] = x;
},
get scrollY(): number {
return mem.f32[(base + 8) >>> 2];
},
set scrollY(x: number) {
mem.f32[(base + 8) >>> 2] = x;
},
get dpr(): number {
return mem.u8[(base + 12)];
},
set dpr(x: number) {
mem.u8[(base + 12)] = x;
},
get fullscreen(): number {
return mem.u8[(base + 13)];
},
set fullscreen(x: number) {
mem.u8[(base + 13)] = x;
},
};
}
});
export interface DragEvent extends WasmTypeBase {
/**
* Mouse X position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientX: number;
/**
* Mouse Y position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientY: number;
/**
* If non-zero, data that is being dragged during a drag & drop operation can be
* obtained via various DnD related API calls (only available when called from
* event handler).
*
* @remarks
* Zig type: `u8`
*/
isDataTransfer: number;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
/**
* Encoded bitmask of all currently pressed mouse buttons, see `MouseButton`
* enum
*
* @remarks
* Zig type: `u8`
*/
buttons: number;
/**
* Event related mouse button ID (if any)
*/
button: MouseButton;
fromEvent(e: globalThis.DragEvent): void;
}
export const $DragEvent: WasmTypeConstructor<DragEvent> = (mem) => ({
get align() {
return 2;
},
get size() {
return 8;
},
instanceArray(base, num) {
const items: DragEvent[] = [];
for (; num --> 0; base += 8) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 8);
},
get clientX(): number {
return mem.i16[base >>> 1];
},
set clientX(x: number) {
mem.i16[base >>> 1] = x;
},
get clientY(): number {
return mem.i16[(base + 2) >>> 1];
},
set clientY(x: number) {
mem.i16[(base + 2) >>> 1] = x;
},
get isDataTransfer(): number {
return mem.u8[(base + 4)];
},
set isDataTransfer(x: number) {
mem.u8[(base + 4)] = x;
},
get modifiers(): number {
return mem.u8[(base + 5)];
},
set modifiers(x: number) {
mem.u8[(base + 5)] = x;
},
get buttons(): number {
return mem.u8[(base + 6)];
},
set buttons(x: number) {
mem.u8[(base + 6)] = x;
},
get button(): MouseButton {
return mem.u8[(base + 7)];
},
set button(x: MouseButton) {
mem.u8[(base + 7)] = x;
},
fromEvent(e: globalThis.DragEvent) {
const bounds = (<Element>(e.target)).getBoundingClientRect();
this.clientX = e.clientX - bounds.left;
this.clientY = e.clientY - bounds.top;
this.buttons = e.buttons;
this.button = e.button;
this.isDataTransfer = e.dataTransfer ? 1 : 0;
}
};
}
});
export interface InputEvent extends WasmTypeBase {
/**
* Value of the targeted input element.
* The memory is owned by the DOM API and will be freed immediately after the
* event handler has returned.
*/
value: WasmStringPtr;
/**
* Length of the value string
*
* @remarks
* Zig type: `u32`
*/
len: number;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
fromEvent(e: globalThis.InputEvent): MemorySlice;
}
export const $InputEvent: WasmTypeConstructor<InputEvent> = (mem) => ({
get align() {
return 4;
},
get size() {
return 12;
},
instanceArray(base, num) {
const items: InputEvent[] = [];
for (; num --> 0; base += 12) items.push(this.instance(base));
return items;
},
instance: (base) => {
let $value: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 12);
},
get value(): WasmStringPtr {
return $value || ($value = new WasmStringPtr(mem, base, true));
},
get len(): number {
return mem.u32[(base + 4) >>> 2];
},
set len(x: number) {
mem.u32[(base + 4) >>> 2] = x;
},
get modifiers(): number {
return mem.u8[(base + 8)];
},
set modifiers(x: number) {
mem.u8[(base + 8)] = x;
},
fromEvent(e: globalThis.InputEvent) {
const el = <HTMLInputElement>e.target;
const value = el.type === "checkbox" ? el.checked ? "on" : "off" : el.value;
const slice = this.value.setAlloc(value);
this.len = slice[1] - 1;
return slice;
}
};
}
});
export interface KeyEvent extends WasmTypeBase {
/**
* Value/name of the key pressed
*
* @remarks
* Zig type: `[15:0]u8`
*/
key: Uint8Array;
/**
* Number of characters of the `key` string
*
* @remarks
* Zig type: `u8`
*/
len: number;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
/**
* Non-zero value indicates key is being held down such that it's automatically
* repeating
*
* @remarks
* Zig type: `u8`
*/
repeat: number;
fromEvent(e: globalThis.KeyboardEvent): void;
}
export const $KeyEvent: WasmTypeConstructor<KeyEvent> = (mem) => ({
get align() {
return 1;
},
get size() {
return 19;
},
instanceArray(base, num) {
const items: KeyEvent[] = [];
for (; num --> 0; base += 19) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 19);
},
get key(): Uint8Array {
const addr = base;
return mem.u8.subarray(addr, addr + 15);
},
get len(): number {
return mem.u8[(base + 16)];
},
set len(x: number) {
mem.u8[(base + 16)] = x;
},
get modifiers(): number {
return mem.u8[(base + 17)];
},
set modifiers(x: number) {
mem.u8[(base + 17)] = x;
},
get repeat(): number {
return mem.u8[(base + 18)];
},
set repeat(x: number) {
mem.u8[(base + 18)] = x;
},
fromEvent(e: globalThis.KeyboardEvent) {
this.len = mem.setString(e.key, this.key.byteOffset, 16, true);
}
};
}
});
export interface MouseEvent extends WasmTypeBase {
/**
* Mouse X position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientX: number;
/**
* Mouse Y position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientY: number;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
/**
* Encoded bitmask of all currently pressed mouse buttons, see `MouseButton`
* enum
*
* @remarks
* Zig type: `u8`
*/
buttons: number;
/**
* Event related mouse button ID (if any)
*/
button: MouseButton;
fromEvent(e: globalThis.MouseEvent): void;
}
export const $MouseEvent: WasmTypeConstructor<MouseEvent> = (mem) => ({
get align() {
return 2;
},
get size() {
return 8;
},
instanceArray(base, num) {
const items: MouseEvent[] = [];
for (; num --> 0; base += 8) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 8);
},
get clientX(): number {
return mem.i16[base >>> 1];
},
set clientX(x: number) {
mem.i16[base >>> 1] = x;
},
get clientY(): number {
return mem.i16[(base + 2) >>> 1];
},
set clientY(x: number) {
mem.i16[(base + 2) >>> 1] = x;
},
get modifiers(): number {
return mem.u8[(base + 4)];
},
set modifiers(x: number) {
mem.u8[(base + 4)] = x;
},
get buttons(): number {
return mem.u8[(base + 5)];
},
set buttons(x: number) {
mem.u8[(base + 5)] = x;
},
get button(): MouseButton {
return mem.u8[(base + 6)];
},
set button(x: MouseButton) {
mem.u8[(base + 6)] = x;
},
fromEvent(e: globalThis.MouseEvent) {
const bounds = (<Element>(e.target)).getBoundingClientRect();
this.clientX = e.clientX - bounds.left;
this.clientY = e.clientY - bounds.top;
this.buttons = e.buttons;
this.button = e.button;
}
};
}
});
export interface PointerEvent extends WasmTypeBase {
/**
* Mouse X position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientX: number;
/**
* Mouse Y position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientY: number;
/**
* Unique pointer ID
*
* @remarks
* Zig type: `u32`
*/
id: number;
/**
* Normalized pressure value 0..1
*
* @remarks
* Zig type: `f32`
*/
pressure: number;
/**
* The plane angle (in degrees, in the range of -90 to 90) between the Y-Z plane
* and the plane containing both the pointer (e.g. pen stylus) axis and the Y
* axis.
*
* @remarks
* Zig type: `i8`
*/
tiltX: number;
/**
* The plane angle (in degrees, in the range of -90 to 90) between the X-Z plane
* and the plane containing both the pointer (e.g. pen stylus) axis and the X
* axis.
*
* @remarks
* Zig type: `i8`
*/
tiltY: number;
/**
* The clockwise rotation of the pointer (e.g. pen stylus) around its major axis
* in degrees, with a value in the range 0 to 359.
*
* @remarks
* Zig type: `u16`
*/
twist: number;
pointerType: PointerType;
/**
* Non-zero if event's pointer is the primary pointer (in a multitouch scenario)
*
* @remarks
* Zig type: `u8`
*/
isPrimary: number;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
/**
* Encoded bitmask of all currently pressed mouse buttons, see `MouseButton`
* enum
*
* @remarks
* Zig type: `u8`
*/
buttons: number;
/**
* Event related mouse button ID (if any)
*/
button: MouseButton;
fromEvent(e: globalThis.PointerEvent): void;
}
export const $PointerEvent: WasmTypeConstructor<PointerEvent> = (mem) => ({
get align() {
return 4;
},
get size() {
return 24;
},
instanceArray(base, num) {
const items: PointerEvent[] = [];
for (; num --> 0; base += 24) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 24);
},
get clientX(): number {
return mem.i16[base >>> 1];
},
set clientX(x: number) {
mem.i16[base >>> 1] = x;
},
get clientY(): number {
return mem.i16[(base + 2) >>> 1];
},
set clientY(x: number) {
mem.i16[(base + 2) >>> 1] = x;
},
get id(): number {
return mem.u32[(base + 4) >>> 2];
},
set id(x: number) {
mem.u32[(base + 4) >>> 2] = x;
},
get pressure(): number {
return mem.f32[(base + 8) >>> 2];
},
set pressure(x: number) {
mem.f32[(base + 8) >>> 2] = x;
},
get tiltX(): number {
return mem.i8[(base + 12)];
},
set tiltX(x: number) {
mem.i8[(base + 12)] = x;
},
get tiltY(): number {
return mem.i8[(base + 13)];
},
set tiltY(x: number) {
mem.i8[(base + 13)] = x;
},
get twist(): number {
return mem.u16[(base + 14) >>> 1];
},
set twist(x: number) {
mem.u16[(base + 14) >>> 1] = x;
},
get pointerType(): PointerType {
return mem.u8[(base + 16)];
},
set pointerType(x: PointerType) {
mem.u8[(base + 16)] = x;
},
get isPrimary(): number {
return mem.u8[(base + 17)];
},
set isPrimary(x: number) {
mem.u8[(base + 17)] = x;
},
get modifiers(): number {
return mem.u8[(base + 18)];
},
set modifiers(x: number) {
mem.u8[(base + 18)] = x;
},
get buttons(): number {
return mem.u8[(base + 19)];
},
set buttons(x: number) {
mem.u8[(base + 19)] = x;
},
get button(): MouseButton {
return mem.u8[(base + 20)];
},
set button(x: MouseButton) {
mem.u8[(base + 20)] = x;
},
fromEvent(e: globalThis.PointerEvent) {
const bounds = (<Element>(e.target)).getBoundingClientRect();
this.clientX = e.clientX - bounds.left;
this.clientY = e.clientY - bounds.top;
this.tiltX = e.tiltX;
this.tiltY = e.tiltY;
this.twist = e.twist;
this.isPrimary = ~~e.isPrimary;
this.pointerType = PointerType[<"PEN">e.pointerType.toUpperCase()];
this.buttons = e.buttons;
this.button = e.button;
}
};
}
});
export interface ScrollEvent extends WasmTypeBase {
/**
* Horizontal scroll offset in fractional CSS pixels.
*
* @remarks
* Zig type: `f32`
*/
scrollX: number;
/**
* Vertical scroll offset in fractional CSS pixels.
*
* @remarks
* Zig type: `f32`
*/
scrollY: number;
fromEvent(e: globalThis.Event): void;
}
export const $ScrollEvent: WasmTypeConstructor<ScrollEvent> = (mem) => ({
get align() {
return 4;
},
get size() {
return 8;
},
instanceArray(base, num) {
const items: ScrollEvent[] = [];
for (; num --> 0; base += 8) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 8);
},
get scrollX(): number {
return mem.f32[base >>> 2];
},
set scrollX(x: number) {
mem.f32[base >>> 2] = x;
},
get scrollY(): number {
return mem.f32[(base + 4) >>> 2];
},
set scrollY(x: number) {
mem.f32[(base + 4) >>> 2] = x;
},
fromEvent(e: globalThis.Event) {
const target = <HTMLElement>((<any>e.target).scrollTop != null ? e.target : document.scrollingElement);
this.scrollX = target.scrollLeft || 0;
this.scrollY = target.scrollTop || 0;
}
};
}
});
export interface TouchEvent extends WasmTypeBase {
/**
* Touch X position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientX: number;
/**
* Touch Y position in the local space of the element's bounding rect
*
* @remarks
* Zig type: `i16`
*/
clientY: number;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
fromEvent(e: globalThis.TouchEvent): void;
}
export const $TouchEvent: WasmTypeConstructor<TouchEvent> = (mem) => ({
get align() {
return 2;
},
get size() {
return 6;
},
instanceArray(base, num) {
const items: TouchEvent[] = [];
for (; num --> 0; base += 6) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 6);
},
get clientX(): number {
return mem.i16[base >>> 1];
},
set clientX(x: number) {
mem.i16[base >>> 1] = x;
},
get clientY(): number {
return mem.i16[(base + 2) >>> 1];
},
set clientY(x: number) {
mem.i16[(base + 2) >>> 1] = x;
},
get modifiers(): number {
return mem.u8[(base + 4)];
},
set modifiers(x: number) {
mem.u8[(base + 4)] = x;
},
fromEvent(e: globalThis.TouchEvent) {
const bounds = (<Element>(e.target)).getBoundingClientRect();
this.clientX = e.touches[0].clientX - bounds.left;
this.clientY = e.touches[0].clientY - bounds.top;
}
};
}
});
export interface WheelEvent extends WasmTypeBase {
/**
* Scroll X delta
*
* @remarks
* Zig type: `i16`
*/
deltaX: number;
/**
* Scroll Y delta
*
* @remarks
* Zig type: `i16`
*/
deltaY: number;
/**
* Scroll Z delta
*
* @remarks
* Zig type: `i16`
*/
deltaZ: number;
/**
* Delta mode
*/
mode: WheelDeltaMode;
/**
* Encoded bitmask of currently pressed modifier keys, see `KeyModifier` enum
*
* @remarks
* Zig type: `u8`
*/
modifiers: number;
/**
* Encoded bitmask of currently pressed mouse buttons, see `MouseButton` enum
*
* @remarks
* Zig type: `u8`
*/
buttons: number;
fromEvent(e: globalThis.WheelEvent): void;
}
export const $WheelEvent: WasmTypeConstructor<WheelEvent> = (mem) => ({
get align() {
return 2;
},
get size() {
return 10;
},
instanceArray(base, num) {
const items: WheelEvent[] = [];
for (; num --> 0; base += 10) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 10);
},
get deltaX(): number {
return mem.i16[base >>> 1];
},
set deltaX(x: number) {
mem.i16[base >>> 1] = x;
},
get deltaY(): number {
return mem.i16[(base + 2) >>> 1];
},
set deltaY(x: number) {
mem.i16[(base + 2) >>> 1] = x;
},
get deltaZ(): number {
return mem.i16[(base + 4) >>> 1];
},
set deltaZ(x: number) {
mem.i16[(base + 4) >>> 1] = x;
},
get mode(): WheelDeltaMode {
return mem.u8[(base + 6)];
},
set mode(x: WheelDeltaMode) {
mem.u8[(base + 6)] = x;
},
get modifiers(): number {
return mem.u8[(base + 7)];
},
set modifiers(x: number) {
mem.u8[(base + 7)] = x;
},
get buttons(): number {
return mem.u8[(base + 8)];
},
set buttons(x: number) {
mem.u8[(base + 8)] = x;
},
fromEvent(e: globalThis.WheelEvent) {
this.deltaX = e.deltaX;
this.deltaY = e.deltaY;
this.deltaZ = e.deltaZ;
this.mode = e.deltaMode;
this.buttons = e.buttons;
}
};
}
});
export interface EventBody extends WasmTypeBase {
drag: DragEvent;
input: InputEvent;
key: KeyEvent;
mouse: MouseEvent;
pointer: PointerEvent;
scroll: ScrollEvent;
touch: TouchEvent;
wheel: WheelEvent;
}
export const $EventBody: WasmTypeConstructor<EventBody> = (mem) => ({
get align() {
return 4;
},
get size() {
return 24;
},
instanceArray(base, num) {
const items: EventBody[] = [];
for (; num --> 0; base += 24) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 24);
},
get drag(): DragEvent {
return $DragEvent(mem).instance(base);
},
set drag(x: DragEvent) {
mem.u8.set(x.__bytes, base);
},
get input(): InputEvent {
return $InputEvent(mem).instance(base);
},
set input(x: InputEvent) {
mem.u8.set(x.__bytes, base);
},
get key(): KeyEvent {
return $KeyEvent(mem).instance(base);
},
set key(x: KeyEvent) {
mem.u8.set(x.__bytes, base);
},
get mouse(): MouseEvent {
return $MouseEvent(mem).instance(base);
},
set mouse(x: MouseEvent) {
mem.u8.set(x.__bytes, base);
},
get pointer(): PointerEvent {
return $PointerEvent(mem).instance(base);
},
set pointer(x: PointerEvent) {
mem.u8.set(x.__bytes, base);
},
get scroll(): ScrollEvent {
return $ScrollEvent(mem).instance(base);
},
set scroll(x: ScrollEvent) {
mem.u8.set(x.__bytes, base);
},
get touch(): TouchEvent {
return $TouchEvent(mem).instance(base);
},
set touch(x: TouchEvent) {
mem.u8.set(x.__bytes, base);
},
get wheel(): WheelEvent {
return $WheelEvent(mem).instance(base);
},
set wheel(x: WheelEvent) {
mem.u8.set(x.__bytes, base);
},
};
}
});
export interface Event extends WasmTypeBase {
id: EventType;
/**
* Target element ID, > 1 if a known (WASM created) element, otherwise:
*
* - -2: = unknown
* - -1: window
* - 0: document.head
* - 1: document.body
*
* @remarks
* Zig type: `i32`
*/
target: number;
/**
* Event details / payload. Currently, only the following event types have a
* defined body:
*
* - drag
* - input
* - key
* - mouse
* - pointer
* - scroll
* - touch
* - wheel
*/
body: EventBody;
}
export const $Event: WasmTypeConstructor<Event> = (mem) => ({
get align() {
return 4;
},
get size() {
return 32;
},
instanceArray(base, num) {
const items: Event[] = [];
for (; num --> 0; base += 32) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 32);
},
get id(): EventType {
return mem.i32[base >>> 2];
},
set id(x: EventType) {
mem.i32[base >>> 2] = x;
},
get target(): number {
return mem.i32[(base + 4) >>> 2];
},
set target(x: number) {
mem.i32[(base + 4) >>> 2] = x;
},
get body(): EventBody {
return $EventBody(mem).instance((base + 8));
},
set body(x: EventBody) {
mem.u8.set(x.__bytes, (base + 8));
},
};
}
});
/**
* DOM event listener
*/
export interface EventListener extends WasmTypeBase {
/**
* Event listener function. Takes an event and optional pointer to user supplied
* arbitrary context data provided when registering the handler via
* `addListener()`
*
* @remarks
* Zig type: `u32`
*/
callback: number;
/**
* Optional type erased pointer to arbitrary user context. This pointer can be
* cast back into the desired type using this form:
* `@ptrCast(?*Foo, @alignCast(@alignOf(Foo), raw))`
* Also see: `wasmapi.ptrCast()`
*
* @remarks
* Zig type: `?u32`
*/
ctx: number;
}
export const $EventListener: WasmTypeConstructor<EventListener> = (mem) => ({
get align() {
return 4;
},
get size() {
return 8;
},
instanceArray(base, num) {
const items: EventListener[] = [];
for (; num --> 0; base += 8) items.push(this.instance(base));
return items;
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 8);
},
get callback(): number {
return mem.u32[base >>> 2];
},
set callback(x: number) {
mem.u32[base >>> 2] = x;
},
get ctx(): number {
return mem.u32[(base + 4) >>> 2];
},
set ctx(x: number) {
mem.u32[(base + 4) >>> 2] = x;
},
};
}
});
/**
* Data structure used for declarative creation of DOM elements / trees (passed
* to `createElement()`)
* Also see `CreateCanvasOpts` for canvas specific use cases
*/
export interface CreateElementOpts extends WasmTypeBase {
/**
* DOM element name
*/
tag: WasmStringPtr;
/**
* Namespace URI or wellknown registered alias (e.g. svg, xlink, xmlns)
*/
ns: WasmStringPtr;
/**
* ID attrib
*/
id: WasmStringPtr;
/**
* Element class attrib
*/
class: WasmStringPtr;
/**
* Element inner text body
*/
text: WasmStringPtr;
/**
* Element inner HTML body
*/
html: WasmStringPtr;
/**
* Parent element ID. If >=0 the new element will be attached to that parent
* element. Set to -1 to leave new element unattached (default unless nested)
*
* @remarks
* Zig type: `i32`
*/
parent: number;
/**
* Insertion index for new element or -1 to append (default)
*
* @remarks
* Zig type: `i32`
*/
index: number;
/**
* Optional slice of child element specs, which will be automatically attached
* as children to this element (their `parent` ID will be ignored)
*/
children: CreateElementOpts[];
/**
* Optional slice of attribute definitions for this element. Also see provided
* `Attrib` factory functions for convenience.
*/
attribs: Attrib[];
}
export const $CreateElementOpts: WasmTypeConstructor<CreateElementOpts> = (mem) => ({
get align() {
return 4;
},
get size() {
return 48;
},
instanceArray(base, num) {
const items: CreateElementOpts[] = [];
for (; num --> 0; base += 48) items.push(this.instance(base));
return items;
},
instance: (base) => {
let $tag: WasmStringPtr | null = null;
let $ns: WasmStringPtr | null = null;
let $id: WasmStringPtr | null = null;
let $class: WasmStringPtr | null = null;
let $text: WasmStringPtr | null = null;
let $html: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 48);
},
get tag(): WasmStringPtr {
return $tag || ($tag = new WasmStringPtr(mem, base, true));
},
get ns(): WasmStringPtr {
return $ns || ($ns = new WasmStringPtr(mem, (base + 4), true));
},
get id(): WasmStringPtr {
return $id || ($id = new WasmStringPtr(mem, (base + 8), true));
},
get class(): WasmStringPtr {
return $class || ($class = new WasmStringPtr(mem, (base + 12), true));
},
get text(): WasmStringPtr {
return $text || ($text = new WasmStringPtr(mem, (base + 16), true));
},
get html(): WasmStringPtr {
return $html || ($html = new WasmStringPtr(mem, (base + 20), true));
},
get parent(): number {
return mem.i32[(base + 24) >>> 2];
},
set parent(x: number) {
mem.i32[(base + 24) >>> 2] = x;
},
get index(): number {
return mem.i32[(base + 28) >>> 2];
},
set index(x: number) {
mem.i32[(base + 28) >>> 2] = x;
},
get children(): CreateElementOpts[] {
const addr = mem.u32[(base + 32) >>> 2];
const len = mem.u32[(base + 36) >>> 2];
const inst = $CreateElementOpts(mem);
const buf: CreateElementOpts[] = [];
for(let i = 0; i < len; i++) buf.push(inst.instance(addr + i * 48));
return buf;
},
get attribs(): Attrib[] {
const addr = mem.u32[(base + 40) >>> 2];
const len = mem.u32[(base + 44) >>> 2];
const inst = $Attrib(mem);
const buf: Attrib[] = [];
for(let i = 0; i < len; i++) buf.push(inst.instance(addr + i * 24));
return buf;
},
};
}
});
/**
* Data structure used for declarative creation of canvas elements (passed to
* `createCanvas()`)
*/
export interface CreateCanvasOpts extends WasmTypeBase {
/**
* Canvas width (in CSS pixels)
*
* @remarks
* Zig type: `u16`
*/
width: number;
/**
* Canvas height (in CSS pixels)
*
* @remarks
* Zig type: `u16`
*/
height: number;
/**
* Element ID attrib
*/
id: WasmStringPtr;
/**
* Element class attrib
*/
class: WasmStringPtr;
/**
* Same as CreateElementOpts.parent
*
* @remarks
* Zig type: `i32`
*/
parent: number;
/**
* Same as CreateElementOpts.index
*
* @remarks
* Zig type: `i32`
*/
index: number;
/**
* Device pixel ratio for computing physical pixel dimensions, see
* `getWindowInfo()`
*
* @remarks
* Zig type: `u8`
*/
dpr: number;
/**
* Optional slice of attribute definitions for this element. Also see provided
* `Attrib` factory functions for convenience.
*/
attribs: Attrib[];
}
export const $CreateCanvasOpts: WasmTypeConstructor<CreateCanvasOpts> = (mem) => ({
get align() {
return 4;
},
get size() {
return 32;
},
instanceArray(base, num) {
const items: CreateCanvasOpts[] = [];
for (; num --> 0; base += 32) items.push(this.instance(base));
return items;
},
instance: (base) => {
let $id: WasmStringPtr | null = null;
let $class: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 32);
},
get width(): number {
return mem.u16[base >>> 1];
},
set width(x: number) {
mem.u16[base >>> 1] = x;
},
get height(): number {
return mem.u16[(base + 2) >>> 1];
},
set height(x: number) {
mem.u16[(base + 2) >>> 1] = x;
},
get id(): WasmStringPtr {
return $id || ($id = new WasmStringPtr(mem, (base + 4), true));
},
get class(): WasmStringPtr {
return $class || ($class = new WasmStringPtr(mem, (base + 8), true));
},
get parent(): number {
return mem.i32[(base + 12) >>> 2];
},
set parent(x: number) {
mem.i32[(base + 12) >>> 2] = x;
},
get index(): number {
return mem.i32[(base + 16) >>> 2];
},
set index(x: number) {
mem.i32[(base + 16) >>> 2] = x;
},
get dpr(): number {
return mem.u8[(base + 20)];
},
set dpr(x: number) {
mem.u8[(base + 20)] = x;
},
get attribs(): Attrib[] {
const addr = mem.u32[(base + 24) >>> 2];
const len = mem.u32[(base + 28) >>> 2];
const inst = $Attrib(mem);
const buf: Attrib[] = [];
for(let i = 0; i < len; i++) buf.push(inst.instance(addr + i * 24));
return buf;
},
};
}
});
/**
* DOM element attribute definition given as part of `CreateElementOpts`
*/
export interface Attrib extends WasmTypeBase {
name: WasmStringPtr;
value: AttribValue;
kind: AttribType;
}
export const $Attrib: WasmTypeConstructor<Attrib> = (mem) => ({
get align() {
return 8;
},
get size() {
return 24;
},
instanceArray(base, num) {
const items: Attrib[] = [];
for (; num --> 0; base += 24) items.push(this.instance(base));
return items;
},
instance: (base) => {
let $name: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 24);
},
get name(): WasmStringPtr {
return $name || ($name = new WasmStringPtr(mem, base, true));
},
get value(): AttribValue {
return $AttribValue(mem).instance((base + 8));
},
set value(x: AttribValue) {
mem.u8.set(x.__bytes, (base + 8));
},
get kind(): AttribType {
return mem.u8[(base + 16)];
},
set kind(x: AttribType) {
mem.u8[(base + 16)] = x;
},
};
}
});
export interface AttribValue extends WasmTypeBase {
event: EventListener;
/**
* Zig type: `u8`
*/
flag: number;
/**
* Zig type: `f64`
*/
num: number;
str: WasmStringPtr;
}
export const $AttribValue: WasmTypeConstructor<AttribValue> = (mem) => ({
get align() {
return 8;
},
get size() {
return 8;
},
instanceArray(base, num) {
const items: AttribValue[] = [];
for (; num --> 0; base += 8) items.push(this.instance(base));
return items;
},
instance: (base) => {
let $str: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 8);
},
get event(): EventListener {
return $EventListener(mem).instance(base);
},
set event(x: EventListener) {
mem.u8.set(x.__bytes, base);
},
get flag(): number {
return mem.u8[base];
},
set flag(x: number) {
mem.u8[base] = x;
},
get num(): number {
return mem.f64[base >>> 3];
},
set num(x: number) {
mem.f64[base >>> 3] = x;
},
get str(): WasmStringPtr {
return $str || ($str = new WasmStringPtr(mem, base, true));
},
};
}
});
export enum AttribType {
EVENT,
FLAG,
NUM,
STR,
}