@pzerelles/headlessui-svelte 2.0.0-next.1 → 2.1.2-next.2

package/dist/test-utils/fake-pointer.d.ts

@@ -0,0 +1,24 @@
+export declare class FakePointer {
+    private width;
+    private height;
+    private x;
+    private y;
+    constructor(width: number, height: number);
+    get options(): {
+        screenX: number;
+        screenY: number;
+    };
+    randomize(): void;
+    advance(amount?: number): void;
+    /**
+     * JSDOM does not support pointer events.
+     * Because of this when we try to set the pointer position it returns undefined so our checks fail.
+     *
+     * This runs the callback with the TEST_IGNORE_TRACKED_POINTER environment variable set to 1 so we bypass the checks.
+     */
+    bypassingTrackingChecks(callback: () => void): void;
+}
+/**
+ * A global pointer for use in pointer and mouse event checks
+ */
+export declare let pointer: FakePointer;

package/dist/test-utils/fake-pointer.js

@@ -0,0 +1,48 @@
+export class FakePointer {
+    width;
+    height;
+    x = 0;
+    y = 0;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.width = width;
+        this.height = height;
+    }
+    get options() {
+        return {
+            screenX: this.x,
+            screenY: this.y,
+        };
+    }
+    randomize() {
+        this.x = Math.floor(Math.random() * this.width);
+        this.y = Math.floor(Math.random() * this.height);
+    }
+    advance(amount = 1) {
+        this.x += amount;
+        if (this.x >= this.width) {
+            this.x %= this.width;
+            this.y++;
+        }
+        if (this.y >= this.height) {
+            this.y %= this.height;
+        }
+    }
+    /**
+     * JSDOM does not support pointer events.
+     * Because of this when we try to set the pointer position it returns undefined so our checks fail.
+     *
+     * This runs the callback with the TEST_IGNORE_TRACKED_POINTER environment variable set to 1 so we bypass the checks.
+     */
+    bypassingTrackingChecks(callback) {
+        let original = process.env.TEST_BYPASS_TRACKED_POINTER;
+        process.env.TEST_BYPASS_TRACKED_POINTER = "1";
+        callback();
+        process.env.TEST_BYPASS_TRACKED_POINTER = original;
+    }
+}
+/**
+ * A global pointer for use in pointer and mouse event checks
+ */
+export let pointer = new FakePointer(1920, 1080);

package/dist/test-utils/interactions.d.ts

@@ -0,0 +1,61 @@
+export declare let Keys: Record<string, Partial<KeyboardEvent>>;
+export declare function shift(event: Partial<KeyboardEvent>): {
+    shiftKey: boolean;
+    altKey?: boolean | undefined;
+    charCode?: number | undefined;
+    code?: string | undefined;
+    ctrlKey?: boolean | undefined;
+    isComposing?: boolean | undefined;
+    key?: string | undefined;
+    keyCode?: number | undefined;
+    location?: number | undefined;
+    metaKey?: boolean | undefined;
+    repeat?: boolean | undefined;
+    getModifierState?: ((keyArg: string) => boolean) | undefined;
+    initKeyboardEvent?: ((typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, keyArg?: string, locationArg?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean, metaKey?: boolean) => void) | undefined;
+    DOM_KEY_LOCATION_STANDARD?: 0 | undefined;
+    DOM_KEY_LOCATION_LEFT?: 1 | undefined;
+    DOM_KEY_LOCATION_RIGHT?: 2 | undefined;
+    DOM_KEY_LOCATION_NUMPAD?: 3 | undefined;
+    detail?: number | undefined;
+    view?: Window | null | undefined;
+    which?: number | undefined;
+    initUIEvent?: ((typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, viewArg?: Window | null, detailArg?: number) => void) | undefined;
+    bubbles?: boolean | undefined;
+    cancelBubble?: boolean | undefined;
+    cancelable?: boolean | undefined;
+    composed?: boolean | undefined;
+    currentTarget?: EventTarget | null | undefined;
+    defaultPrevented?: boolean | undefined;
+    eventPhase?: number | undefined;
+    isTrusted?: boolean | undefined;
+    returnValue?: boolean | undefined;
+    srcElement?: EventTarget | null | undefined;
+    target?: EventTarget | null | undefined;
+    timeStamp?: number | undefined;
+    type?: string | undefined;
+    composedPath?: (() => EventTarget[]) | undefined;
+    initEvent?: ((type: string, bubbles?: boolean, cancelable?: boolean) => void) | undefined;
+    preventDefault?: (() => void) | undefined;
+    stopImmediatePropagation?: (() => void) | undefined;
+    stopPropagation?: (() => void) | undefined;
+    NONE?: 0 | undefined;
+    CAPTURING_PHASE?: 1 | undefined;
+    AT_TARGET?: 2 | undefined;
+    BUBBLING_PHASE?: 3 | undefined;
+};
+export declare function word(input: string): Partial<KeyboardEvent>[];
+export declare function type(events: Partial<KeyboardEvent>[], element?: Element | null): Promise<void>;
+export declare function press(event: Partial<KeyboardEvent>, element?: Element | null): Promise<void>;
+export declare enum MouseButton {
+    Left = 0,
+    Right = 2
+}
+export declare function click(element: Document | Element | Window | Node | null, button?: MouseButton): Promise<void>;
+export declare function rawClick(element: Document | Element | Window | Node | null, button?: MouseButton): Promise<void>;
+export declare function focus(element: Document | Element | Window | Node | null): Promise<void>;
+export declare function blur(element: Document | Element | Window | Node | null): Promise<void>;
+export declare function mouseEnter(element: Document | Element | Window | null): Promise<void>;
+export declare function mouseMove(element: Document | Element | Window | null): Promise<void>;
+export declare function mouseLeave(element: Document | Element | Window | null): Promise<void>;
+export declare function mouseDrag(startingElement: Document | Element | Window | Node | null, endingElement: Document | Element | Window | Node | null): Promise<void>;

package/dist/test-utils/interactions.js

@@ -0,0 +1,453 @@
+import { act, fireEvent } from "@testing-library/svelte";
+import { pointer } from "./fake-pointer.js";
+function nextFrame(cb) {
+    setImmediate(() => {
+        setImmediate(() => {
+            setImmediate(() => {
+                cb();
+            });
+        });
+    });
+}
+export let Keys = {
+    Space: { key: " ", keyCode: 32, charCode: 32 },
+    Enter: { key: "Enter", keyCode: 13, charCode: 13 },
+    Escape: { key: "Escape", keyCode: 27, charCode: 27 },
+    Backspace: { key: "Backspace", keyCode: 8 },
+    ArrowLeft: { key: "ArrowLeft", keyCode: 37 },
+    ArrowUp: { key: "ArrowUp", keyCode: 38 },
+    ArrowRight: { key: "ArrowRight", keyCode: 39 },
+    ArrowDown: { key: "ArrowDown", keyCode: 40 },
+    Home: { key: "Home", keyCode: 36 },
+    End: { key: "End", keyCode: 35 },
+    PageUp: { key: "PageUp", keyCode: 33 },
+    PageDown: { key: "PageDown", keyCode: 34 },
+    Tab: { key: "Tab", keyCode: 9, charCode: 9 },
+};
+export function shift(event) {
+    return { ...event, shiftKey: true };
+}
+export function word(input) {
+    let result = input.split("").map((key) => ({ key }));
+    let element = document.activeElement;
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+        fireEvent.change(element, {
+            target: Object.assign({}, element, { value: input }),
+        });
+    }
+    return result;
+}
+let Default = Symbol();
+let Ignore = Symbol();
+let cancellations = {
+    [Default]: {
+        keydown: new Set(["keypress"]),
+        keypress: new Set([]),
+        keyup: new Set([]),
+    },
+    [Keys.Enter.key]: {
+        keydown: new Set(["keypress", "click"]),
+        keypress: new Set(["click"]),
+        keyup: new Set([]),
+    },
+    [Keys.Space.key]: {
+        keydown: new Set(["keypress", "click"]),
+        keypress: new Set([]),
+        keyup: new Set(["click"]),
+    },
+    [Keys.Tab.key]: {
+        keydown: new Set(["keypress", "blur", "focus"]),
+        keypress: new Set([]),
+        keyup: new Set([]),
+    },
+};
+let order = {
+    [Default]: [
+        function keydown(element, event) {
+            return fireEvent.keyDown(element, event);
+        },
+        function keypress(element, event) {
+            return fireEvent.keyPress(element, event);
+        },
+        function input(element, event) {
+            // TODO: This should only fire when the element's value changes
+            return fireEvent.input(element, event);
+        },
+        function keyup(element, event) {
+            return fireEvent.keyUp(element, event);
+        },
+    ],
+    [Keys.Enter.key]: [
+        function keydown(element, event) {
+            return fireEvent.keyDown(element, event);
+        },
+        function keypress(element, event) {
+            return fireEvent.keyPress(element, event);
+        },
+        function click(element, event) {
+            if (element instanceof HTMLButtonElement)
+                return fireEvent.click(element, event);
+            return Ignore;
+        },
+        function keyup(element, event) {
+            return fireEvent.keyUp(element, event);
+        },
+    ],
+    [Keys.Space.key]: [
+        function keydown(element, event) {
+            return fireEvent.keyDown(element, event);
+        },
+        function keypress(element, event) {
+            return fireEvent.keyPress(element, event);
+        },
+        function keyup(element, event) {
+            return fireEvent.keyUp(element, event);
+        },
+        function click(element, event) {
+            if (element instanceof HTMLButtonElement)
+                return fireEvent.click(element, event);
+            return Ignore;
+        },
+    ],
+    [Keys.Tab.key]: [
+        function keydown(element, event) {
+            return fireEvent.keyDown(element, event);
+        },
+        function blurAndfocus(_element, event) {
+            return focusNext(event);
+        },
+        function keyup(element, event) {
+            return fireEvent.keyUp(element, event);
+        },
+    ],
+    [Keys.Escape.key]: [
+        function keydown(element, event) {
+            return fireEvent.keyDown(element, event);
+        },
+        function keypress(element, event) {
+            return fireEvent.keyPress(element, event);
+        },
+        function keyup(element, event) {
+            return fireEvent.keyUp(element, event);
+        },
+    ],
+    [Keys.Backspace.key]: [
+        function keydown(element, event) {
+            if (element instanceof HTMLInputElement) {
+                let ev = Object.assign({}, event, {
+                    target: Object.assign({}, event.target, {
+                        value: element.value.slice(0, -1),
+                    }),
+                });
+                fireEvent.keyDown(element, ev);
+                return fireEvent.input(element, ev);
+            }
+            return fireEvent.keyDown(element, event);
+        },
+        function keyup(element, event) {
+            return fireEvent.keyUp(element, event);
+        },
+    ],
+};
+export async function type(events, element = document.activeElement) {
+    vitest.useFakeTimers();
+    try {
+        if (element === null)
+            return expect(element).not.toBe(null);
+        for (let event of events) {
+            let skip = new Set();
+            let actions = order[event.key] ?? order[Default];
+            for (let action of actions) {
+                let checks = action.name.split("And");
+                if (checks.some((check) => skip.has(check)))
+                    continue;
+                let result = action(element, {
+                    type: action.name,
+                    charCode: event.key?.length === 1 ? event.key?.charCodeAt(0) : undefined,
+                    ...event,
+                });
+                if (result === Ignore)
+                    continue;
+                if (result instanceof Element) {
+                    element = result;
+                }
+                let cancelled = !result;
+                if (cancelled) {
+                    let skippablesForKey = cancellations[event.key] ?? cancellations[Default];
+                    let skippables = skippablesForKey?.[action.name] ?? new Set();
+                    for (let skippable of skippables)
+                        skip.add(skippable);
+                }
+            }
+        }
+        // We don't want to actually wait in our tests, so let's advance
+        vitest.runAllTimers();
+        await new Promise(nextFrame);
+    }
+    catch (err) {
+        if (err instanceof Error)
+            Error.captureStackTrace(err, type);
+        throw err;
+    }
+    finally {
+        vitest.useRealTimers();
+    }
+}
+export async function press(event, element = document.activeElement) {
+    return type([event], element);
+}
+export var MouseButton;
+(function (MouseButton) {
+    MouseButton[MouseButton["Left"] = 0] = "Left";
+    MouseButton[MouseButton["Right"] = 2] = "Right";
+})(MouseButton || (MouseButton = {}));
+export async function click(element, button = MouseButton.Left) {
+    return act(() => rawClick(element, button));
+}
+export async function rawClick(element, button = MouseButton.Left) {
+    try {
+        if (element === null)
+            return expect(element).not.toBe(null);
+        if (element instanceof HTMLButtonElement && element.disabled)
+            return;
+        let options = { button };
+        if (button === MouseButton.Left) {
+            // Cancel in pointerDown cancels mouseDown, mouseUp
+            let cancelled = !fireEvent.pointerDown(element, options);
+            if (!cancelled) {
+                cancelled = !fireEvent.mouseDown(element, options);
+            }
+            // Ensure to trigger a `focus` event if the element is focusable, or within a focusable element
+            if (!cancelled) {
+                let next = element;
+                while (next !== null) {
+                    if (next.matches(focusableSelector)) {
+                        act(() => {
+                            // act scopes are called immediately. `next` should keep its type refinements.
+                            next.focus();
+                        });
+                        break;
+                    }
+                    next = next.parentElement;
+                }
+            }
+            fireEvent.pointerUp(element, options);
+            if (!cancelled) {
+                fireEvent.mouseUp(element, options);
+            }
+            fireEvent.click(element, options);
+        }
+        else if (button === MouseButton.Right) {
+            // Cancel in pointerDown cancels mouseDown, mouseUp
+            let cancelled = !fireEvent.pointerDown(element, options);
+            if (!cancelled) {
+                fireEvent.mouseDown(element, options);
+            }
+            // Only in Firefox:
+            fireEvent.pointerUp(element, options);
+            if (!cancelled) {
+                fireEvent.mouseUp(element, options);
+            }
+        }
+        await new Promise(nextFrame);
+    }
+    catch (err) {
+        if (err instanceof Error)
+            Error.captureStackTrace(err, click);
+        throw err;
+    }
+}
+export async function focus(element) {
+    await act(async () => {
+        try {
+            if (element === null)
+                return expect(element).not.toBe(null);
+            if (element instanceof HTMLElement) {
+                element.focus();
+            }
+            else {
+                fireEvent.focus(element);
+            }
+            await new Promise(nextFrame);
+        }
+        catch (err) {
+            if (err instanceof Error)
+                Error.captureStackTrace(err, focus);
+            throw err;
+        }
+    });
+}
+export async function blur(element) {
+    await act(async () => {
+        try {
+            if (element === null)
+                return expect(element).not.toBe(null);
+            if (element instanceof HTMLElement) {
+                element.blur();
+            }
+            else {
+                fireEvent.blur(element);
+            }
+            await new Promise(nextFrame);
+        }
+        catch (err) {
+            if (err instanceof Error)
+                Error.captureStackTrace(err, blur);
+            throw err;
+        }
+    });
+}
+export async function mouseEnter(element) {
+    try {
+        if (element === null)
+            return expect(element).not.toBe(null);
+        fireEvent.pointerOver(element);
+        fireEvent.pointerEnter(element);
+        fireEvent.mouseOver(element);
+        await new Promise(nextFrame);
+    }
+    catch (err) {
+        if (err instanceof Error)
+            Error.captureStackTrace(err, mouseEnter);
+        throw err;
+    }
+}
+export async function mouseMove(element) {
+    try {
+        if (element === null)
+            return expect(element).not.toBe(null);
+        pointer.advance();
+        pointer.bypassingTrackingChecks(() => {
+            fireEvent.pointerMove(element);
+        });
+        fireEvent.mouseMove(element, pointer.options);
+        await new Promise(nextFrame);
+    }
+    catch (err) {
+        if (err instanceof Error)
+            Error.captureStackTrace(err, mouseMove);
+        throw err;
+    }
+}
+export async function mouseLeave(element) {
+    try {
+        if (element === null)
+            return expect(element).not.toBe(null);
+        pointer.advance();
+        pointer.bypassingTrackingChecks(() => {
+            fireEvent.pointerOut(element);
+            fireEvent.pointerLeave(element);
+        });
+        fireEvent.mouseOut(element, pointer.options);
+        fireEvent.mouseLeave(element, pointer.options);
+        await new Promise(nextFrame);
+    }
+    catch (err) {
+        if (err instanceof Error)
+            Error.captureStackTrace(err, mouseLeave);
+        throw err;
+    }
+}
+export async function mouseDrag(startingElement, endingElement) {
+    let button = MouseButton.Left;
+    try {
+        if (startingElement === null)
+            return expect(startingElement).not.toBe(null);
+        if (endingElement === null)
+            return expect(endingElement).not.toBe(null);
+        if (startingElement instanceof HTMLButtonElement && startingElement.disabled)
+            return;
+        let options = { button };
+        // Cancel in pointerDown cancels mouseDown, mouseUp
+        let cancelled = !fireEvent.pointerDown(startingElement, options);
+        if (!cancelled) {
+            cancelled = !fireEvent.mouseDown(startingElement, options);
+        }
+        // Ensure to trigger a `focus` event if the element is focusable, or within a focusable element
+        if (!cancelled) {
+            let next = startingElement;
+            while (next !== null) {
+                if (next.matches(focusableSelector)) {
+                    act(() => {
+                        // act scopes are called immediately. `next` should keep its type refinements.
+                        next.focus();
+                    });
+                    break;
+                }
+                next = next.parentElement;
+            }
+        }
+        fireEvent.pointerMove(startingElement, options);
+        if (!cancelled) {
+            fireEvent.mouseMove(startingElement, options);
+        }
+        fireEvent.pointerOut(startingElement, options);
+        if (!cancelled) {
+            fireEvent.mouseOut(startingElement, options);
+        }
+        // crosses over to the ending element
+        fireEvent.pointerOver(endingElement, options);
+        if (!cancelled) {
+            fireEvent.mouseOver(endingElement, options);
+        }
+        fireEvent.pointerMove(endingElement, options);
+        if (!cancelled) {
+            fireEvent.mouseMove(endingElement, options);
+        }
+        fireEvent.pointerUp(endingElement, options);
+        if (!cancelled) {
+            fireEvent.mouseUp(endingElement, options);
+        }
+        fireEvent.click(endingElement, options);
+        await new Promise(nextFrame);
+    }
+    catch (err) {
+        if (err instanceof Error)
+            Error.captureStackTrace(err, click);
+        throw err;
+    }
+}
+// ---
+function focusNext(event) {
+    let direction = event.shiftKey ? -1 : +1;
+    let focusableElements = getFocusableElements();
+    let total = focusableElements.length;
+    function innerFocusNext(offset = 0) {
+        let currentIdx = focusableElements.indexOf(document.activeElement);
+        let next = focusableElements[(currentIdx + total + direction + offset) % total];
+        if (next) {
+            act(() => {
+                next?.focus({ preventScroll: true });
+            });
+        }
+        if (next !== document.activeElement)
+            return innerFocusNext(offset + direction);
+        return next;
+    }
+    return innerFocusNext();
+}
+// Credit:
+//  - https://stackoverflow.com/a/30753870
+let focusableSelector = [
+    "[contentEditable=true]",
+    "[tabindex]",
+    "a[href]",
+    "area[href]",
+    "button:not([disabled])",
+    "iframe",
+    "input:not([disabled])",
+    "select:not([disabled])",
+    "textarea:not([disabled])",
+]
+    .map(process.env.NODE_ENV === "test"
+    ? // TODO: Remove this once JSDOM fixes the issue where an element that is
+        // "hidden" can be the document.activeElement, because this is not possible
+        // in real browsers.
+        (selector) => `${selector}:not([tabindex='-1']):not([style*='display: none'])`
+    : (selector) => `${selector}:not([tabindex='-1'])`)
+    .join(",");
+function getFocusableElements(container = document.body) {
+    if (!container)
+        return [];
+    return Array.from(container.querySelectorAll(focusableSelector));
+}

package/dist/test-utils/suppress-console-logs.d.ts

@@ -0,0 +1,7 @@
+import type { MockInstance } from "vitest";
+type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T] & string;
+export declare function suppressConsoleLogs<T extends unknown[]>(cb: (...args: T) => unknown, type?: FunctionPropertyNames<typeof globalThis.console>): (...args: T) => Promise<unknown>;
+export declare function mockingConsoleLogs<T extends unknown[]>(cb: (spy: MockInstance, ...args: T) => unknown, type?: FunctionPropertyNames<typeof globalThis.console>): (...args: T) => Promise<unknown>;
+export {};

package/dist/test-utils/suppress-console-logs.js

@@ -0,0 +1,17 @@
+import { vitest } from "vitest";
+export function suppressConsoleLogs(cb, type = "error") {
+    return (...args) => {
+        let spy = vitest.spyOn(globalThis.console, type).mockImplementation(vitest.fn());
+        return new Promise((resolve, reject) => {
+            Promise.resolve(cb(...args)).then(resolve, reject);
+        }).finally(() => spy.mockRestore());
+    };
+}
+export function mockingConsoleLogs(cb, type = "error") {
+    return (...args) => {
+        let spy = vitest.spyOn(globalThis.console, type).mockImplementation(vitest.fn());
+        return new Promise((resolve, reject) => {
+            Promise.resolve(cb(spy, ...args)).then(resolve, reject);
+        }).finally(() => spy.mockRestore());
+    };
+}