@gtkx/testing 1.0.0-rc.1 → 1.0.0-rc.2

package/src/user-event/keyboard.ts

@@ -1,25 +1,18 @@
 import * as Gdk from "@gtkx/gi/gdk";
 import * as Gtk from "@gtkx/gi/gtk";
+import type { UserEventState } from "./state.js";
 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 = {
+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);
-        }
-    });
+type KeyAction = { keyval: number; press: boolean };
+type ParseStep = { actions: KeyAction[]; next: number };
 
 const KEY_MAP: Record<string, number> = {
     Enter: Gdk.KEY_Return,
@@ -54,67 +47,110 @@ const KEY_MAP: Record<string, number> = {
     F12: Gdk.KEY_F12,
 };
 
-type KeyAction = { keyval: number; press: boolean };
+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 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 parseKeyToken = (token: string): { keyval: number; press: boolean; release: boolean } => {
     let keyName = token;
-    let press = true;
-    let release = true;
+    let isPress = true;
+    let isRelease = true;
 
     if (keyName.startsWith("/")) {
         keyName = keyName.slice(1);
-        press = false;
+        isPress = false;
     } else if (keyName.endsWith(">")) {
         keyName = keyName.slice(0, -1);
-        release = false;
+        isRelease = false;
     }
 
     const keyval = KEY_MAP[keyName];
+
     if (keyval === undefined) {
         throw new Error(`Unknown key: {${keyName}}`);
     }
-    return { keyval, press, release };
+
+    return { keyval, press: isPress, release: isRelease };
+};
+
+const parseCharAt = (input: string, i: number): ParseStep => {
+    const keyval = input.codePointAt(i) ?? 0;
+
+    return {
+        actions: [
+            { keyval, press: true },
+            { keyval, press: false },
+        ],
+        next: i + 1,
+    };
+};
+
+const parseBraceAt = (input: string, i: number): ParseStep | null => {
+    const endBrace = input.indexOf("}", i);
+
+    if (endBrace === -1) {
+        return null;
+    }
+
+    const { keyval, press, release } = parseKeyToken(input.slice(i + 1, endBrace));
+    const actions: KeyAction[] = [];
+
+    if (press) {
+        actions.push({ keyval, press: true });
+    }
+
+    if (release) {
+        actions.push({ keyval, press: false });
+    }
+
+    return { actions, next: endBrace + 1 };
 };
 
+const parseStepAt = (input: string, i: number): ParseStep | null =>
+    input[i] === "{" ? parseBraceAt(input, i) : parseCharAt(input, i);
+
 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 step = parseStepAt(input, i);
 
-        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 });
+        if (step === null) {
+            break;
+        }
 
-        i = endBrace + 1;
+        actions.push(...step.actions);
+        i = step.next;
     }
 
     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 (!mask) {
+        return;
+    }
+
     if (action.press) {
         state.modifierState |= mask;
     } else {
@@ -122,60 +158,108 @@ const updateModifierState = (state: UserEventState, action: KeyAction): void =>
     }
 };
 
-const matchesTrigger = (trigger: Gtk.ShortcutTrigger | null, keyval: number, modifiers: number): boolean => {
+const isTriggerMatch = (
+    trigger: Gtk.ShortcutTrigger | null,
+    keyval: number,
+    modifiers: Gdk.ModifierType,
+): 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)
+            isTriggerMatch(trigger.getFirst(), keyval, modifiers) ||
+            isTriggerMatch(trigger.getSecond(), keyval, modifiers)
         );
     }
+
     return false;
 };
 
-const activateMatchingShortcut = (
+const didActivateShortcut = (
+    shortcut: Gtk.Shortcut,
+    widget: Gtk.Widget,
+    keyval: number,
+    modifiers: Gdk.ModifierType,
+): boolean => {
+    if (!isTriggerMatch(shortcut.getTrigger(), keyval, modifiers)) {
+        return false;
+    }
+
+    const action = shortcut.getAction();
+
+    if (action instanceof Gtk.SignalAction && action.getSignalName() === "move-focus") {
+        return false;
+    }
+
+    return action?.activate(0 as Gtk.ShortcutActionFlags, widget, shortcut.getArguments()) ?? false;
+};
+
+const didActivateMatchingShortcut = (
     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;
+
+        if (!(shortcut instanceof Gtk.Shortcut)) {
+            continue;
+        }
+
+        if (didActivateShortcut(shortcut, widget, keyval, modifiers)) {
+            return true;
+        }
     }
+
     return false;
 };
 
-const dispatchShortcutsOnWidget = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
+const didDispatchShortcutsOnWidget = (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)
+            didActivateMatchingShortcut(controller, widget, keyval, modifiers)
         ) {
             return true;
         }
     }
+
     return false;
 };
 
-const dispatchShortcuts = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
+const didDispatchShortcuts = (widget: Gtk.Widget, keyval: number, modifiers: number): boolean => {
     const delegate = getEditableDelegate(widget);
-    if (delegate && dispatchShortcutsOnWidget(delegate, keyval, modifiers)) return true;
+
+    if (delegate && didDispatchShortcutsOnWidget(delegate, keyval, modifiers)) {
+        return true;
+    }
+
     for (let current: Gtk.Widget | null = widget; current; current = current.getParent()) {
-        if (dispatchShortcutsOnWidget(current, keyval, modifiers)) return true;
+        if (didDispatchShortcutsOnWidget(current, keyval, modifiers)) {
+            return true;
+        }
     }
+
     return false;
 };
 
+const handleKeyPress = async (widget: Gtk.Widget, keyval: number, modifiers: number): Promise<void> => {
+    const isHandled = didDispatchShortcuts(widget, keyval, modifiers);
+
+    if (!isHandled && keyval === Gdk.KEY_Return && widget instanceof Gtk.Editable) {
+        await fireEvent(widget, "activate");
+    }
+};
+
 const applyKeyAction = async (
     widget: Gtk.Widget,
     controllers: Gtk.EventControllerKey[],
@@ -184,21 +268,23 @@ const applyKeyAction = async (
 ): 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");
-        }
+        await handleKeyPress(widget, action.keyval, state.modifierState);
     }
 };
 
-export const keyboard = (state: UserEventState, widget: Gtk.Widget, input: string): Promise<void> =>
+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);
         }
     });
+
+export { tab, keyboard, type TabOptions };

package/src/user-event/pointer.ts

@@ -1,34 +1,46 @@
 import * as Gtk from "@gtkx/gi/gtk";
+import type { UserEventState } from "./state.js";
 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]";
+/**
+ * A pointer action token: a full click (`click`, `[MouseLeft]`), a button press (`down`,
+ * `[MouseLeft>]`), or a button release (`up`, `[/MouseLeft]`).
+ */
+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 PRESS_INPUTS: Set<PointerInput> = new Set(["[MouseLeft>]", "down"]);
+const RELEASE_INPUTS: Set<PointerInput> = new Set(["[/MouseLeft]", "up"]);
+const CLICK_INPUTS: Set<PointerInput> = new Set(["[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));
+const pointer = (state: UserEventState, widget: Gtk.Widget, input: PointerInput): Promise<void> =>
+    wrapEvent(widget, () => {
+        applyPointerInput(widget, state, input);
+    });
+
+export { pointer, type PointerInput };

package/src/user-event/selection.ts

@@ -2,21 +2,31 @@ 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]);
+type CollectionWidget = Gtk.ListView | Gtk.GridView | Gtk.ColumnView;
+type ListBoxRowAction = (listBox: Gtk.ListBox, row: Gtk.ListBoxRow) => void;
+
+const SELECTABLE_ROLES: Set<Gtk.AccessibleRole> = new Set([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 => {
+const selectListViewItems = (
+    selectionModel: Gtk.SelectionModel,
+    positions: number[],
+    isExclusive: boolean,
+): void => {
     if (positions.length === 0) {
         selectionModel.unselectRange(0, selectionModel.getNItems());
+
         return;
     }
 
     const [first] = positions;
-    if (exclusive && positions.length === 1 && first !== undefined) {
+
+    if (isExclusive && first !== undefined && positions.length === 1) {
         selectionModel.selectItem(first, true);
+
         return;
     }
 
@@ -31,16 +41,20 @@ const selectListViewItems = (selectionModel: Gtk.SelectionModel, positions: numb
     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 isListView = (widget: Gtk.Widget): widget is CollectionWidget =>
+    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 (selection === undefined) {
+        return;
+    }
+
     if (widget instanceof Gtk.DropDown) {
         widget.setSelected(selection);
     } else if (widget instanceof Gtk.ComboBox) {
@@ -48,31 +62,41 @@ const selectComboBoxOption = (widget: Gtk.Widget, valueArray: number[]): void =>
     }
 };
 
-const applyListBoxRows = (listBox: Gtk.ListBox, valueArray: number[], select: boolean): void => {
+const selectListBoxRow = (listBox: Gtk.ListBox, row: Gtk.ListBoxRow): void => {
+    listBox.selectRow(row);
+    row.activate();
+};
+
+const unselectListBoxRow = (listBox: Gtk.ListBox, row: Gtk.ListBoxRow): void => {
+    listBox.unselectRow(row);
+};
+
+const applyListBoxRows = (listBox: Gtk.ListBox, valueArray: number[], apply: ListBoxRowAction): 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);
+
+        if (!row) {
+            continue;
         }
+
+        apply(listBox, row);
     }
 };
 
 const requireSelectionModel = (
-    widget: Gtk.ListView | Gtk.GridView | Gtk.ColumnView,
+    widget: CollectionWidget,
     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 selectInListView = (widget: CollectionWidget, valueArray: number[]): void => {
     const selectionModel = requireSelectionModel(widget, "select");
     const isMultiSelection = selectionModel instanceof Gtk.MultiSelection;
     selectListViewItems(selectionModel, valueArray, !isMultiSelection);
@@ -84,39 +108,52 @@ const selectByRole = (widget: Gtk.Widget, valueArray: number[]): void => {
     }
 
     const role = widget.getAccessibleRole();
+
     if (role === Gtk.AccessibleRole.COMBO_BOX) {
         selectComboBoxOption(widget, valueArray);
     } else if (widget instanceof Gtk.ListBox) {
-        applyListBoxRows(widget, valueArray, true);
+        applyListBoxRows(widget, valueArray, selectListBoxRow);
     }
 };
 
-export const selectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
+const runSelectionEvent = (
+    widget: Gtk.Widget,
+    values: number | number[],
+    inListView: (view: Gtk.ListView | Gtk.GridView | Gtk.ColumnView, valueArray: number[]) => void,
+    byRole: (widget: Gtk.Widget, valueArray: number[]) => void,
+): Promise<void> =>
     wrapEvent(widget, () => {
         const valueArray = Array.isArray(values) ? values : [values];
+
         if (isListView(widget)) {
-            selectInListView(widget, valueArray);
+            inListView(widget, valueArray);
+
             return;
         }
-        selectByRole(widget, valueArray);
+
+        byRole(widget, valueArray);
     });
 
+const selectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
+    runSelectionEvent(widget, values, selectInListView, selectByRole);
+
 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);
-    });
+const deselectByRole = (widget: Gtk.Widget, valueArray: number[]): void => {
+    if (!(widget instanceof Gtk.ListBox)) {
+        throw new TypeError("Cannot deselect options: only ListBox supports deselection");
+    }
+
+    applyListBoxRows(widget, valueArray, unselectListBoxRow);
+};
+
+const deselectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
+    runSelectionEvent(widget, values, deselectInListView, deselectByRole);
+
+export { selectOptions, deselectOptions };

package/src/user-event/state.ts

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