@gtkx/testing 0.20.0 → 1.0.0-rc.1

package/src/user-event/gesture.ts

@@ -0,0 +1,154 @@
+import * as GObject from "@gtkx/gi/gobject";
+import * as Gtk from "@gtkx/gi/gtk";
+import { getAllControllers } from "./controller.js";
+import { dispatchOnControllers, dispatchOnOrCreateControllers } from "./dispatch.js";
+import { wrapEvent } from "./event-wrapper.js";
+
+/** The value delivered to a drop target: a primitive (converted to a GObject.Value) or an explicit GObject.Value. */
+export type DropContent = string | number | boolean | GObject.Value;
+
+/** Options for a drop: the drop coordinates within the target. */
+export type DropOptions = {
+    x?: number;
+    y?: number;
+};
+
+/** A drag offset relative to the drag start point. */
+export type DragOffset = {
+    x: number;
+    y: number;
+};
+
+/** Options for a drag gesture: the starting point, the number of interpolated drag updates, or explicit intermediate offsets emitted before the final one. */
+export type DragOptions = {
+    startX?: number;
+    startY?: number;
+    steps?: number;
+    offsets?: DragOffset[];
+};
+
+const buildDropValue = (content: DropContent): GObject.Value => {
+    if (content instanceof GObject.Value) return content;
+    if (typeof content === "string") {
+        return GObject.buildValue(GObject.TYPE_STRING, (v) => v.setString(content));
+    }
+    if (typeof content === "boolean") {
+        return GObject.buildValue(GObject.TYPE_BOOLEAN, (v) => v.setBoolean(content));
+    }
+    return GObject.buildValue(GObject.TYPE_DOUBLE, (v) => v.setDouble(content));
+};
+
+export const hover = (widget: Gtk.Widget): Promise<void> =>
+    dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => controller.emit("enter", 0, 0));
+
+export const unhover = (widget: Gtk.Widget): Promise<void> =>
+    dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => controller.emit("leave"));
+
+export const rotate = (widget: Gtk.Widget, angle: number, deltaAngle: number = angle): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureRotate, (controller) =>
+        controller.emit("angle-changed", angle, deltaAngle),
+    );
+
+export const zoom = (widget: Gtk.Widget, scale: number): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureZoom, (controller) => controller.emit("scale-changed", scale));
+
+export const swipe = (widget: Gtk.Widget, velocityX: number, velocityY: number): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureSwipe, (controller) => controller.emit("swipe", velocityX, velocityY));
+
+export const longPress = (widget: Gtk.Widget, x: number = 0, y: number = 0): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureLongPress, (controller) => controller.emit("pressed", x, y));
+
+type DragInstancePatch = {
+    getStartPoint?: Gtk.GestureDrag["getStartPoint"] | undefined;
+    getOffset?: Gtk.GestureDrag["getOffset"] | undefined;
+};
+
+const patchDragState = (controller: Gtk.GestureDrag, start: DragOffset, offset: () => DragOffset): (() => void) => {
+    const instance: DragInstancePatch = controller;
+    const ownsStartPoint = Object.hasOwn(instance, "getStartPoint");
+    const ownsOffset = Object.hasOwn(instance, "getOffset");
+    const previousStartPoint = instance.getStartPoint;
+    const previousOffset = instance.getOffset;
+    instance.getStartPoint = () => [true, start.x, start.y];
+    instance.getOffset = () => {
+        const current = offset();
+        return [true, current.x, current.y];
+    };
+    return () => {
+        if (ownsStartPoint) instance.getStartPoint = previousStartPoint;
+        else delete instance.getStartPoint;
+        if (ownsOffset) instance.getOffset = previousOffset;
+        else delete instance.getOffset;
+    };
+};
+
+const runDragSequence = (controllers: Gtk.GestureDrag[], start: DragOffset, updates: DragOffset[]): void => {
+    let current: DragOffset = { x: 0, y: 0 };
+    const restores = controllers.map((controller) => patchDragState(controller, start, () => current));
+    try {
+        for (const controller of controllers) {
+            controller.emit("drag-begin", start.x, start.y);
+        }
+        for (const update of updates) {
+            current = update;
+            for (const controller of controllers) {
+                controller.emit("drag-update", update.x, update.y);
+            }
+        }
+        for (const controller of controllers) {
+            controller.emit("drag-end", current.x, current.y);
+        }
+    } finally {
+        for (const restore of restores) restore();
+    }
+};
+
+const resolveDragUpdates = (dx: number, dy: number, options: DragOptions): DragOffset[] => {
+    if (options.offsets) return [...options.offsets, { x: dx, y: dy }];
+    const steps = Math.max(1, Math.floor(options.steps ?? 2));
+    const updates: DragOffset[] = [];
+    for (let i = 1; i <= steps; i++) {
+        updates.push({ x: (dx * i) / steps, y: (dy * i) / steps });
+    }
+    return updates;
+};
+
+export const drag = async (widget: Gtk.Widget, dx: number, dy: number, options: DragOptions = {}): Promise<void> => {
+    if (widget instanceof Gtk.Range) {
+        throw new Error(
+            "userEvent.drag cannot drive a Gtk.Range's built-in slider (its drag reads pointer coordinates from the display); " +
+                "use userEvent.slide(range, value) or userEvent.keyboard for sliders",
+        );
+    }
+    const start = { x: options.startX ?? 0, y: options.startY ?? 0 };
+    const updates = resolveDragUpdates(dx, dy, options);
+    await wrapEvent(widget, () => {
+        runDragSequence(getAllControllers(widget, Gtk.GestureDrag), start, updates);
+    });
+};
+
+const emitDrop = (target: Gtk.Widget, content: DropContent, options: DropOptions): void => {
+    const dropTargets = getAllControllers(target, Gtk.DropTarget);
+    for (const dropTarget of dropTargets) {
+        dropTarget.emit("drop", buildDropValue(content), options.x ?? 0, options.y ?? 0);
+    }
+};
+
+export const drop = (widget: Gtk.Widget, content: DropContent, options: DropOptions = {}): Promise<void> =>
+    wrapEvent(widget, () => {
+        emitDrop(widget, content, options);
+    });
+
+export const dragAndDrop = async (
+    source: Gtk.Widget,
+    target: Gtk.Widget,
+    content: DropContent,
+    options: DropOptions = {},
+): Promise<void> => {
+    await wrapEvent(source, () => {
+        getAllControllers(source, Gtk.DragSource);
+    });
+    await wrapEvent(target, () => {
+        emitDrop(target, content, options);
+    });
+};

package/src/user-event/index.ts

@@ -0,0 +1,74 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import { scroll, slide } from "./adjustment.js";
+import { click, dblClick, tripleClick } from "./click.js";
+import { drag, dragAndDrop, drop, hover, longPress, rotate, swipe, unhover, zoom } from "./gesture.js";
+import { keyboard, tab } from "./keyboard.js";
+import { type PointerInput, pointer } from "./pointer.js";
+import { deselectOptions, selectOptions } from "./selection.js";
+import { createInitialState } from "./state.js";
+import { clear, copy, cut, paste, type } from "./text.js";
+
+export type { ScrollDelta } from "./adjustment.js";
+export type { DragOffset, DragOptions, DropContent, DropOptions } from "./gesture.js";
+export type { TabOptions } from "./keyboard.js";
+export type { PointerInput } from "./pointer.js";
+export type { TypeOptions } from "./text.js";
+export { resetClipboard } from "./text.js";
+
+/** The set of user interaction helpers exposed by {@link userEvent}, covering clicks, typing, keyboard, pointer, gestures, selection, and scrolling. */
+export type UserEvent = {
+    click: typeof click;
+    dblClick: typeof dblClick;
+    tripleClick: typeof tripleClick;
+    tab: typeof tab;
+    type: typeof type;
+    clear: typeof clear;
+    copy: typeof copy;
+    cut: typeof cut;
+    paste: typeof paste;
+    selectOptions: typeof selectOptions;
+    deselectOptions: typeof deselectOptions;
+    hover: typeof hover;
+    unhover: typeof unhover;
+    rotate: typeof rotate;
+    zoom: typeof zoom;
+    swipe: typeof swipe;
+    longPress: typeof longPress;
+    drag: typeof drag;
+    drop: typeof drop;
+    dragAndDrop: typeof dragAndDrop;
+    slide: typeof slide;
+    scroll: typeof scroll;
+    keyboard: (widget: Gtk.Widget, input: string) => Promise<void>;
+    pointer: (widget: Gtk.Widget, input: PointerInput) => Promise<void>;
+};
+
+const state = createInitialState();
+
+/** High-level helpers that drive widgets by dispatching the same events and gestures GTK4 delivers when someone clicks, types, or drags. */
+export const userEvent: UserEvent = {
+    click,
+    dblClick,
+    tripleClick,
+    tab,
+    type,
+    clear,
+    copy,
+    cut,
+    paste,
+    selectOptions,
+    deselectOptions,
+    hover,
+    unhover,
+    rotate,
+    zoom,
+    swipe,
+    longPress,
+    drag,
+    drop,
+    dragAndDrop,
+    slide,
+    scroll,
+    keyboard: (widget: Gtk.Widget, input: string): Promise<void> => keyboard(state, widget, input),
+    pointer: (widget: Gtk.Widget, input: PointerInput): Promise<void> => pointer(state, widget, input),
+};

package/src/user-event/keyboard.ts

@@ -0,0 +1,204 @@
+import * as Gdk from "@gtkx/gi/gdk";
+import * as Gtk from "@gtkx/gi/gtk";
+import { getEditableDelegate } from "../editable.js";
+import { fireEvent } from "../fire-event.js";
+import { getOrCreateControllers } from "./controller.js";
+import { wrapEvent } from "./event-wrapper.js";
+import type { UserEventState } from "./state.js";
+
+/** Options for {@link tab}: when `shift` is set, move focus backward instead of forward. */
+export type TabOptions = {
+    shift?: boolean;
+};
+
+export const tab = (widget: Gtk.Widget, options?: TabOptions): Promise<void> =>
+    wrapEvent(widget, () => {
+        const direction = options?.shift ? Gtk.DirectionType.TAB_BACKWARD : Gtk.DirectionType.TAB_FORWARD;
+        const root = widget.getRoot();
+
+        if (root) {
+            root.childFocus(direction);
+        }
+    });
+
+const KEY_MAP: Record<string, number> = {
+    Enter: Gdk.KEY_Return,
+    Tab: Gdk.KEY_Tab,
+    Escape: Gdk.KEY_Escape,
+    Backspace: Gdk.KEY_BackSpace,
+    Delete: Gdk.KEY_Delete,
+    ArrowUp: Gdk.KEY_Up,
+    ArrowDown: Gdk.KEY_Down,
+    ArrowLeft: Gdk.KEY_Left,
+    ArrowRight: Gdk.KEY_Right,
+    Home: Gdk.KEY_Home,
+    End: Gdk.KEY_End,
+    PageUp: Gdk.KEY_Page_Up,
+    PageDown: Gdk.KEY_Page_Down,
+    Space: Gdk.KEY_space,
+    Shift: Gdk.KEY_Shift_L,
+    Control: Gdk.KEY_Control_L,
+    Alt: Gdk.KEY_Alt_L,
+    Meta: Gdk.KEY_Meta_L,
+    F1: Gdk.KEY_F1,
+    F2: Gdk.KEY_F2,
+    F3: Gdk.KEY_F3,
+    F4: Gdk.KEY_F4,
+    F5: Gdk.KEY_F5,
+    F6: Gdk.KEY_F6,
+    F7: Gdk.KEY_F7,
+    F8: Gdk.KEY_F8,
+    F9: Gdk.KEY_F9,
+    F10: Gdk.KEY_F10,
+    F11: Gdk.KEY_F11,
+    F12: Gdk.KEY_F12,
+};
+
+type KeyAction = { keyval: number; press: boolean };
+
+const parseKeyToken = (token: string): { keyval: number; press: boolean; release: boolean } => {
+    let keyName = token;
+    let press = true;
+    let release = true;
+
+    if (keyName.startsWith("/")) {
+        keyName = keyName.slice(1);
+        press = false;
+    } else if (keyName.endsWith(">")) {
+        keyName = keyName.slice(0, -1);
+        release = false;
+    }
+
+    const keyval = KEY_MAP[keyName];
+    if (keyval === undefined) {
+        throw new Error(`Unknown key: {${keyName}}`);
+    }
+    return { keyval, press, release };
+};
+
+const parseKeyboardInput = (input: string): KeyAction[] => {
+    const actions: KeyAction[] = [];
+    let i = 0;
+
+    while (i < input.length) {
+        if (input[i] !== "{") {
+            const keyval = input.codePointAt(i) ?? 0;
+            actions.push({ keyval, press: true }, { keyval, press: false });
+            i++;
+            continue;
+        }
+
+        const endBrace = input.indexOf("}", i);
+        if (endBrace === -1) break;
+
+        const { keyval, press, release } = parseKeyToken(input.slice(i + 1, endBrace));
+        if (press) actions.push({ keyval, press: true });
+        if (release) actions.push({ keyval, press: false });
+
+        i = endBrace + 1;
+    }
+
+    return actions;
+};
+
+const MODIFIER_KEYVAL_TO_MASK: Record<number, number> = {
+    [Gdk.KEY_Shift_L]: Gdk.ModifierType.SHIFT_MASK,
+    [Gdk.KEY_Shift_R]: Gdk.ModifierType.SHIFT_MASK,
+    [Gdk.KEY_Control_L]: Gdk.ModifierType.CONTROL_MASK,
+    [Gdk.KEY_Control_R]: Gdk.ModifierType.CONTROL_MASK,
+    [Gdk.KEY_Alt_L]: Gdk.ModifierType.ALT_MASK,
+    [Gdk.KEY_Alt_R]: Gdk.ModifierType.ALT_MASK,
+    [Gdk.KEY_Meta_L]: Gdk.ModifierType.META_MASK,
+    [Gdk.KEY_Meta_R]: Gdk.ModifierType.META_MASK,
+};
+
+const updateModifierState = (state: UserEventState, action: KeyAction): void => {
+    const mask = MODIFIER_KEYVAL_TO_MASK[action.keyval];
+    if (!mask) return;
+    if (action.press) {
+        state.modifierState |= mask;
+    } else {
+        state.modifierState &= ~mask;
+    }
+};
+
+const matchesTrigger = (trigger: Gtk.ShortcutTrigger | null, keyval: number, modifiers: number): boolean => {
+    if (trigger instanceof Gtk.KeyvalTrigger) {
+        return trigger.getKeyval() === keyval && trigger.getModifiers() === modifiers;
+    }
+    if (trigger instanceof Gtk.AlternativeTrigger) {
+        return (
+            matchesTrigger(trigger.getFirst(), keyval, modifiers) ||
+            matchesTrigger(trigger.getSecond(), keyval, modifiers)
+        );
+    }
+    return false;
+};
+
+const activateMatchingShortcut = (
+    controller: Gtk.ShortcutController,
+    widget: Gtk.Widget,
+    keyval: number,
+    modifiers: number,
+): boolean => {
+    const count = controller.getNItems();
+    for (let j = 0; j < count; j++) {
+        const shortcut = controller.getItem(j);
+        if (!(shortcut instanceof Gtk.Shortcut)) continue;
+        if (!matchesTrigger(shortcut.getTrigger(), keyval, modifiers)) continue;
+        const action = shortcut.getAction();
+        if (action instanceof Gtk.SignalAction && action.getSignalName() === "move-focus") continue;
+        if (action?.activate(0 as Gtk.ShortcutActionFlags, widget, shortcut.getArguments())) return true;
+    }
+    return false;
+};
+
+const dispatchShortcutsOnWidget = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
+    const controllers = widget.observeControllers();
+    for (let i = 0; i < controllers.getNItems(); i++) {
+        const controller = controllers.getItem(i);
+        if (
+            controller instanceof Gtk.ShortcutController &&
+            activateMatchingShortcut(controller, widget, keyval, modifiers)
+        ) {
+            return true;
+        }
+    }
+    return false;
+};
+
+const dispatchShortcuts = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
+    const delegate = getEditableDelegate(widget);
+    if (delegate && dispatchShortcutsOnWidget(delegate, keyval, modifiers)) return true;
+    for (let current: Gtk.Widget | null = widget; current; current = current.getParent()) {
+        if (dispatchShortcutsOnWidget(current, keyval, modifiers)) return true;
+    }
+    return false;
+};
+
+const applyKeyAction = async (
+    widget: Gtk.Widget,
+    controllers: Gtk.EventControllerKey[],
+    state: UserEventState,
+    action: KeyAction,
+): Promise<void> => {
+    updateModifierState(state, action);
+    const signalName = action.press ? "key-pressed" : "key-released";
+    for (const controller of controllers) {
+        controller.emit(signalName, action.keyval, 0, state.modifierState);
+    }
+    if (action.press) {
+        const handled = dispatchShortcuts(widget, action.keyval, state.modifierState);
+        if (!handled && action.keyval === Gdk.KEY_Return && widget instanceof Gtk.Editable) {
+            await fireEvent(widget, "activate");
+        }
+    }
+};
+
+export const keyboard = (state: UserEventState, widget: Gtk.Widget, input: string): Promise<void> =>
+    wrapEvent(widget, async () => {
+        const controllers = getOrCreateControllers(widget, Gtk.EventControllerKey);
+        for (const action of parseKeyboardInput(input)) {
+            await applyKeyAction(widget, controllers, state, action);
+        }
+    });

package/src/user-event/pointer.ts

@@ -0,0 +1,34 @@
+import * as Gtk from "@gtkx/gi/gtk";
+import { emitPress, emitRelease } from "./click.js";
+import { getOrCreateControllers } from "./controller.js";
+import { wrapEvent } from "./event-wrapper.js";
+import type { UserEventState } from "./state.js";
+
+/** A pointer action token: a full click (`click`, `[MouseLeft]`), a button press (`down`, `[MouseLeft>]`), or a button release (`up`, `[/MouseLeft]`). */
+export type PointerInput = "click" | "down" | "up" | "[MouseLeft]" | "[MouseLeft>]" | "[/MouseLeft]";
+
+const PRESS_INPUTS = new Set<PointerInput>(["[MouseLeft>]", "down"]);
+const RELEASE_INPUTS = new Set<PointerInput>(["[/MouseLeft]", "up"]);
+const CLICK_INPUTS = new Set<PointerInput>(["[MouseLeft]", "click"]);
+
+const applyPointerInput = (widget: Gtk.Widget, state: UserEventState, input: PointerInput): void => {
+    const controllers = getOrCreateControllers(widget, Gtk.GestureClick);
+    if (CLICK_INPUTS.has(input)) {
+        emitPress(widget, controllers, 1);
+        emitRelease(widget, controllers, 1);
+        state.mouseLeftDown = false;
+        return;
+    }
+    if (PRESS_INPUTS.has(input) && !state.mouseLeftDown) {
+        emitPress(widget, controllers, 1);
+        state.mouseLeftDown = true;
+        return;
+    }
+    if (RELEASE_INPUTS.has(input) && state.mouseLeftDown) {
+        emitRelease(widget, controllers, 1);
+        state.mouseLeftDown = false;
+    }
+};
+
+export const pointer = (state: UserEventState, widget: Gtk.Widget, input: PointerInput): Promise<void> =>
+    wrapEvent(widget, () => applyPointerInput(widget, state, input));

package/src/user-event/selection.ts

@@ -0,0 +1,122 @@
+import * as Gtk from "@gtkx/gi/gtk";
+import { formatRoleList } from "../role-helpers.js";
+import { wrapEvent } from "./event-wrapper.js";
+
+const SELECTABLE_ROLES = new Set<Gtk.AccessibleRole>([Gtk.AccessibleRole.COMBO_BOX, Gtk.AccessibleRole.LIST]);
+
+const isSelectable = (widget: Gtk.Widget): boolean => {
+    return SELECTABLE_ROLES.has(widget.getAccessibleRole());
+};
+
+const selectListViewItems = (selectionModel: Gtk.SelectionModel, positions: number[], exclusive: boolean): void => {
+    if (positions.length === 0) {
+        selectionModel.unselectRange(0, selectionModel.getNItems());
+        return;
+    }
+
+    const [first] = positions;
+    if (exclusive && positions.length === 1 && first !== undefined) {
+        selectionModel.selectItem(first, true);
+        return;
+    }
+
+    const nItems = selectionModel.getNItems();
+    const selected = Gtk.Bitset.newEmpty();
+    const mask = Gtk.Bitset.newRange(0, nItems);
+
+    for (const pos of positions) {
+        selected.add(pos);
+    }
+
+    selectionModel.setSelection(selected, mask);
+};
+
+const isListView = (widget: Gtk.Widget): widget is Gtk.ListView | Gtk.GridView | Gtk.ColumnView => {
+    return widget instanceof Gtk.ListView || widget instanceof Gtk.GridView || widget instanceof Gtk.ColumnView;
+};
+
+const selectComboBoxOption = (widget: Gtk.Widget, valueArray: number[]): void => {
+    if (valueArray.length > 1) {
+        throw new Error("Cannot select multiple options: ComboBox only supports single selection");
+    }
+    const [selection] = valueArray;
+    if (selection === undefined) return;
+    if (widget instanceof Gtk.DropDown) {
+        widget.setSelected(selection);
+    } else if (widget instanceof Gtk.ComboBox) {
+        widget.setActive(selection);
+    }
+};
+
+const applyListBoxRows = (listBox: Gtk.ListBox, valueArray: number[], select: boolean): void => {
+    for (const value of valueArray) {
+        const row = listBox.getRowAtIndex(value);
+        if (!row) continue;
+        if (select) {
+            listBox.selectRow(row);
+            row.activate();
+        } else {
+            listBox.unselectRow(row);
+        }
+    }
+};
+
+const requireSelectionModel = (
+    widget: Gtk.ListView | Gtk.GridView | Gtk.ColumnView,
+    verb: string,
+): Gtk.SelectionModel => {
+    const selectionModel = widget.getModel();
+    if (selectionModel === null) {
+        throw new Error(`Cannot ${verb} options: list view has no selection model`);
+    }
+    return selectionModel;
+};
+
+const selectInListView = (widget: Gtk.ListView | Gtk.GridView | Gtk.ColumnView, valueArray: number[]): void => {
+    const selectionModel = requireSelectionModel(widget, "select");
+    const isMultiSelection = selectionModel instanceof Gtk.MultiSelection;
+    selectListViewItems(selectionModel, valueArray, !isMultiSelection);
+};
+
+const selectByRole = (widget: Gtk.Widget, valueArray: number[]): void => {
+    if (!isSelectable(widget)) {
+        throw new Error(`Cannot select options: expected selectable widget (${formatRoleList(SELECTABLE_ROLES)})`);
+    }
+
+    const role = widget.getAccessibleRole();
+    if (role === Gtk.AccessibleRole.COMBO_BOX) {
+        selectComboBoxOption(widget, valueArray);
+    } else if (widget instanceof Gtk.ListBox) {
+        applyListBoxRows(widget, valueArray, true);
+    }
+};
+
+export const selectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
+    wrapEvent(widget, () => {
+        const valueArray = Array.isArray(values) ? values : [values];
+        if (isListView(widget)) {
+            selectInListView(widget, valueArray);
+            return;
+        }
+        selectByRole(widget, valueArray);
+    });
+
+const deselectInListView = (widget: Gtk.ListView | Gtk.GridView | Gtk.ColumnView, valueArray: number[]): void => {
+    const selectionModel = requireSelectionModel(widget, "deselect");
+    for (const pos of valueArray) {
+        selectionModel.unselectItem(pos);
+    }
+};
+
+export const deselectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
+    wrapEvent(widget, () => {
+        const valueArray = Array.isArray(values) ? values : [values];
+        if (isListView(widget)) {
+            deselectInListView(widget, valueArray);
+            return;
+        }
+        if (!(widget instanceof Gtk.ListBox)) {
+            throw new Error("Cannot deselect options: only ListBox supports deselection");
+        }
+        applyListBoxRows(widget, valueArray, false);
+    });

package/src/user-event/state.ts

@@ -0,0 +1,6 @@
+export type UserEventState = {
+    modifierState: number;
+    mouseLeftDown: boolean;
+};
+
+export const createInitialState = (): UserEventState => ({ modifierState: 0, mouseLeftDown: false });