@next-buildr/editor 0.0.0-stage → 2.0.0

package/dist/shortcuts/keys.js

@@ -0,0 +1,100 @@
+export function detectPlatform(navigatorLike = typeof navigator === 'undefined' ? undefined : navigator) {
+    const text = `${navigatorLike?.platform ?? ''} ${navigatorLike?.userAgent ?? ''}`;
+    return /mac|iphone|ipad/i.test(text) ? 'mac' : 'other';
+}
+const KEY_ALIASES = {
+    ' ': 'space',
+    esc: 'escape',
+    del: 'delete',
+    up: 'arrowup',
+    down: 'arrowdown',
+    left: 'arrowleft',
+    right: 'arrowright',
+};
+const MODIFIER_ORDER = ['mod', 'ctrl', 'meta', 'alt', 'shift'];
+/**
+ * The canonical text of a combination: modifiers in a fixed order (`mod` is Cmd on a Mac and Ctrl
+ * elsewhere), then the key, all lower case — `mod+shift+z`, `alt+arrowup`, `delete`. Two spellings
+ * of one combination give the same text, so a lookup is a plain string comparison.
+ */
+export function normalizeCombo(spec) {
+    const parts = spec
+        .toLowerCase()
+        .split('+')
+        .map((part) => part.trim())
+        .filter((part) => part !== '');
+    // "shift++" style specs are not supported; a "+" key is written "plus".
+    const key = parts.pop() ?? '';
+    const mods = MODIFIER_ORDER.filter((mod) => parts.includes(mod));
+    return [...mods, KEY_ALIASES[key] ?? key].join('+');
+}
+/** The canonical combination of a key press on `platform`. */
+export function comboOf(input, platform) {
+    const primary = platform === 'mac' ? input.mods.meta : input.mods.ctrl;
+    const other = platform === 'mac' ? input.mods.ctrl : input.mods.meta;
+    const parts = [];
+    if (primary)
+        parts.push('mod');
+    if (other)
+        parts.push(platform === 'mac' ? 'ctrl' : 'meta');
+    if (input.mods.alt)
+        parts.push('alt');
+    if (input.mods.shift)
+        parts.push('shift');
+    const key = input.key.toLowerCase();
+    parts.push(KEY_ALIASES[key] ?? key);
+    return parts.join('+');
+}
+const SYMBOLS_MAC = {
+    mod: '⌘',
+    ctrl: '⌃',
+    alt: '⌥',
+    shift: '⇧',
+    meta: '⌘',
+    arrowup: '↑',
+    arrowdown: '↓',
+    arrowleft: '←',
+    arrowright: '→',
+    delete: '⌫',
+    backspace: '⌫',
+    escape: 'Esc',
+};
+const WORDS = {
+    mod: 'Ctrl',
+    ctrl: 'Ctrl',
+    meta: 'Meta',
+    alt: 'Alt',
+    shift: 'Shift',
+    arrowup: '↑',
+    arrowdown: '↓',
+    arrowleft: '←',
+    arrowright: '→',
+    delete: 'Del',
+    backspace: 'Backspace',
+    escape: 'Esc',
+};
+const capital = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+/** How a combination is shown to the author on `platform` (`⌘⇧Z`, `Ctrl+Shift+Z`). */
+export function displayCombo(combo, platform) {
+    const parts = combo.split('+');
+    if (platform === 'mac') {
+        return parts.map((part) => SYMBOLS_MAC[part] ?? part.toUpperCase()).join('');
+    }
+    return parts.map((part) => WORDS[part] ?? capital(part)).join('+');
+}
+/** The keyboard belongs to text here: a field, a select or an editable region. */
+export function isTypingTarget(target) {
+    const element = target;
+    if (element === null || typeof element.tagName !== 'string')
+        return false;
+    const tag = element.tagName.toLowerCase();
+    if (tag === 'input') {
+        const type = element.type ?? 'text';
+        return !['checkbox', 'radio', 'button', 'submit', 'reset', 'range', 'color'].includes(type);
+    }
+    if (tag === 'textarea' || tag === 'select')
+        return true;
+    if (element.isContentEditable === true)
+        return true;
+    return element.closest?.('[contenteditable="true"], [role="textbox"]') != null;
+}

package/dist/shortcuts/map.d.ts

@@ -0,0 +1,17 @@
+import type { MessageKey } from '../messages/index.tsx';
+export interface ShortcutDef {
+    readonly action: string;
+    readonly label: MessageKey;
+    readonly group: 'edit' | 'selection' | 'file' | 'help';
+    /** Canonical combinations (`mod+z`); the first is the one the help dialog shows first. */
+    readonly keys: readonly string[];
+}
+/** The shortcuts of the MVP (docs/editor.md#keyboard-shortcuts-pb-084). */
+export declare const DEFAULT_SHORTCUTS: readonly ShortcutDef[];
+/**
+ * The map with the host's overrides applied (`config.shortcuts`, by action id): an override
+ * replaces the action's combinations with that one; an empty string turns the action's shortcut
+ * off. Overrides for unknown actions are ignored.
+ */
+export declare function applyOverrides(defaults: readonly ShortcutDef[], overrides: Readonly<Record<string, string>>): ShortcutDef[];
+//# sourceMappingURL=map.d.ts.map

package/dist/shortcuts/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/shortcuts/map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGxD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;IACvD,0FAA0F;IAC1F,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AASD,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,EAAE,SAAS,WAAW,EAcnD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC1C,WAAW,EAAE,CAMf"}

package/dist/shortcuts/map.js

@@ -0,0 +1,31 @@
+import { normalizeCombo } from './keys.js';
+const def = (action, label, group, ...keys) => ({ action, label, group, keys: keys.map(normalizeCombo) });
+/** The shortcuts of the MVP (docs/editor.md#keyboard-shortcuts-pb-084). */
+export const DEFAULT_SHORTCUTS = [
+    def('edit.undo', 'shortcut.undo', 'edit', 'mod+z'),
+    def('edit.redo', 'shortcut.redo', 'edit', 'mod+shift+z', 'mod+y'),
+    def('edit.copy', 'shortcut.copy', 'edit', 'mod+c'),
+    def('edit.cut', 'shortcut.cut', 'edit', 'mod+x'),
+    def('edit.paste', 'shortcut.paste', 'edit', 'mod+v'),
+    def('edit.duplicate', 'shortcut.duplicate', 'edit', 'mod+d'),
+    def('edit.delete', 'shortcut.delete', 'edit', 'delete', 'backspace'),
+    def('node.moveUp', 'shortcut.moveUp', 'edit', 'alt+arrowup'),
+    def('node.moveDown', 'shortcut.moveDown', 'edit', 'alt+arrowdown'),
+    def('selection.all', 'shortcut.selectAll', 'selection', 'mod+a'),
+    def('selection.clear', 'shortcut.clearSelection', 'selection', 'escape'),
+    def('file.save', 'shortcut.save', 'file', 'mod+s'),
+    def('help.shortcuts', 'shortcut.help', 'help', 'shift+?'),
+];
+/**
+ * The map with the host's overrides applied (`config.shortcuts`, by action id): an override
+ * replaces the action's combinations with that one; an empty string turns the action's shortcut
+ * off. Overrides for unknown actions are ignored.
+ */
+export function applyOverrides(defaults, overrides) {
+    return defaults.map((shortcut) => {
+        if (!Object.hasOwn(overrides, shortcut.action))
+            return shortcut;
+        const combo = normalizeCombo(overrides[shortcut.action] ?? '');
+        return { ...shortcut, keys: combo === '' ? [] : [combo] };
+    });
+}

package/dist/shortcuts/registry.d.ts

@@ -0,0 +1,32 @@
+import { type KeyInput, type Platform } from './keys.ts';
+import { type ShortcutDef } from './map.ts';
+/** A handler returns `false` when it did nothing, so the key keeps its default behaviour. */
+export type ShortcutHandler = () => boolean | undefined;
+export interface ShortcutRegistryOptions {
+    readonly platform: Platform;
+    readonly shortcuts?: readonly ShortcutDef[];
+    readonly overrides?: Readonly<Record<string, string>>;
+}
+export interface ShortcutRegistry {
+    readonly platform: Platform;
+    readonly shortcuts: readonly ShortcutDef[];
+    /**
+     * Attaches `handler` to an action in `scope` (`'editor'` unless said otherwise). Returns the
+     * function that removes it.
+     */
+    bind(action: string, handler: ShortcutHandler, scope?: string): () => void;
+    /** The scopes whose bindings fire; `['editor']` at first. A modal dialog narrows it to its own. */
+    setScopes(scopes: readonly string[]): void;
+    /**
+     * Runs the handler of the shortcut `input` is, and says whether one ran. Nothing runs while
+     * `typing` (the focus is in a text field): there the keys belong to the text.
+     */
+    handle(input: KeyInput, options: {
+        readonly typing: boolean;
+    }): boolean;
+    /** The combinations of an action, canonical (`mod+z`). */
+    keysFor(action: string): readonly string[];
+}
+/** A shortcut registry of its own — nothing here is shared between editors (no global state). */
+export declare function createShortcutRegistry(options: ShortcutRegistryOptions): ShortcutRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/shortcuts/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/shortcuts/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAqC,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/E,6FAA6F;AAC7F,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,GAAG,SAAS,CAAC;AAExD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC5C,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,CAAC;IAC3C;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IAC3E,mGAAmG;IACnG,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC3C;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;IACxE,0DAA0D;IAC1D,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;CAC5C;AAED,iGAAiG;AACjG,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,CA6CzF"}

package/dist/shortcuts/registry.js

@@ -0,0 +1,53 @@
+import { comboOf } from './keys.js';
+import { applyOverrides, DEFAULT_SHORTCUTS } from './map.js';
+/** A shortcut registry of its own — nothing here is shared between editors (no global state). */
+export function createShortcutRegistry(options) {
+    const shortcuts = applyOverrides(options.shortcuts ?? DEFAULT_SHORTCUTS, options.overrides ?? {});
+    const actionOf = new Map();
+    for (const shortcut of shortcuts) {
+        // A combination belongs to the first action that claims it.
+        for (const combo of shortcut.keys)
+            if (!actionOf.has(combo))
+                actionOf.set(combo, shortcut.action);
+    }
+    const bindings = new Map();
+    let scopes = ['editor'];
+    return {
+        platform: options.platform,
+        shortcuts,
+        bind(action, handler, scope = 'editor') {
+            const entry = { handler, scope };
+            const list = bindings.get(action) ?? [];
+            list.push(entry);
+            bindings.set(action, list);
+            return () => {
+                const current = bindings.get(action) ?? [];
+                const at = current.indexOf(entry);
+                if (at !== -1)
+                    current.splice(at, 1);
+            };
+        },
+        setScopes(next) {
+            scopes = [...next];
+        },
+        handle(input, { typing }) {
+            if (typing)
+                return false;
+            const action = actionOf.get(comboOf(input, options.platform));
+            if (action === undefined)
+                return false;
+            // The most recent binding in an active scope wins, as a dialog's handler should over the editor's.
+            const list = bindings.get(action) ?? [];
+            for (let at = list.length - 1; at >= 0; at--) {
+                const entry = list[at];
+                if (entry === undefined || !scopes.includes(entry.scope))
+                    continue;
+                return entry.handler() !== false;
+            }
+            return false;
+        },
+        keysFor(action) {
+            return shortcuts.find((shortcut) => shortcut.action === action)?.keys ?? [];
+        },
+    };
+}

package/dist/shortcuts/shortcuts.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from 'react';
+import { type ExternalActions } from './actions.ts';
+import { type KeyInput, type Platform } from './keys.ts';
+import { type ShortcutRegistry } from './registry.ts';
+/** The registry of the enclosing `<ShortcutProvider>`, or `undefined` outside one (a toolbar shown without shortcuts). */
+export declare function useOptionalShortcutRegistry(): ShortcutRegistry | undefined;
+/** The registry of the enclosing `<ShortcutProvider>`, for modules that bind actions of their own. */
+export declare function useShortcutRegistry(): ShortcutRegistry;
+/**
+ * What the canvas host's `onKeyDown` should call with a forwarded `key:down`. The canvas already
+ * keeps text fields and inline edits to itself, so a forwarded key is never "typing". Returns
+ * whether a shortcut took it.
+ */
+export declare function useForwardedKeys(): (input: KeyInput) => boolean;
+export interface ShortcutProviderProps {
+    /** Overrides by action id (`config.shortcuts`). */
+    readonly overrides?: Readonly<Record<string, string>>;
+    /** The actions other modules provide: clipboard (PB-085) and save (PB-087). */
+    readonly actions?: ExternalActions;
+    readonly platform?: Platform;
+    readonly children: ReactNode;
+}
+/**
+ * Keyboard shortcuts for the editor (docs/editor.md#keyboard-shortcuts-pb-084): a registry, the
+ * store's actions bound to it, a `keydown` listener on the document, and the help dialog (`?`).
+ * A key press whose focus is in a text field is never handled, and a handled one gets
+ * `preventDefault`, so the browser does not also act on it.
+ */
+export declare function ShortcutProvider({ overrides, actions, platform, children, }: ShortcutProviderProps): import("react").JSX.Element;
+/** How the first key of `action` is written on this platform (`Ctrl+Z`), for tooltips; `undefined` when it has none. */
+export declare function useShortcutHint(action: string): string | undefined;
+//# sourceMappingURL=shortcuts.d.ts.map

package/dist/shortcuts/shortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcuts.d.ts","sourceRoot":"","sources":["../../src/shortcuts/shortcuts.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,OAAO,CAAC;AAIf,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,WAAW,CAAC;AACnB,OAAO,EAA0B,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAI9E,0HAA0H;AAC1H,wBAAgB,2BAA2B,IAAI,gBAAgB,GAAG,SAAS,CAE1E;AAED,sGAAsG;AACtG,wBAAgB,mBAAmB,IAAI,gBAAgB,CAMtD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAG/D;AAED,MAAM,WAAW,qBAAqB;IACpC,mDAAmD;IACnD,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAOD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,SAAS,EACT,OAAO,EACP,QAAQ,EACR,QAAQ,GACT,EAAE,qBAAqB,+BAkFvB;AAED,wHAAwH;AACxH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMlE"}

package/dist/shortcuts/shortcuts.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { useT } from '../messages/index.js';
+import { useEditor } from '../store/index.js';
+import { Dialog } from '../ui/index.js';
+import { bindEditorActions } from './actions.js';
+import { detectPlatform, displayCombo, isTypingTarget, } from './keys.js';
+import { createShortcutRegistry } from './registry.js';
+const RegistryContext = createContext(undefined);
+/** The registry of the enclosing `<ShortcutProvider>`, or `undefined` outside one (a toolbar shown without shortcuts). */
+export function useOptionalShortcutRegistry() {
+    return useContext(RegistryContext);
+}
+/** The registry of the enclosing `<ShortcutProvider>`, for modules that bind actions of their own. */
+export function useShortcutRegistry() {
+    const registry = useContext(RegistryContext);
+    if (registry === undefined) {
+        throw new Error('useShortcutRegistry must be used inside <ShortcutProvider>');
+    }
+    return registry;
+}
+/**
+ * What the canvas host's `onKeyDown` should call with a forwarded `key:down`. The canvas already
+ * keeps text fields and inline edits to itself, so a forwarded key is never "typing". Returns
+ * whether a shortcut took it.
+ */
+export function useForwardedKeys() {
+    const registry = useShortcutRegistry();
+    return (input) => registry.handle(input, { typing: false });
+}
+const toInput = (event) => ({
+    key: event.key,
+    mods: { shift: event.shiftKey, alt: event.altKey, ctrl: event.ctrlKey, meta: event.metaKey },
+});
+/**
+ * Keyboard shortcuts for the editor (docs/editor.md#keyboard-shortcuts-pb-084): a registry, the
+ * store's actions bound to it, a `keydown` listener on the document, and the help dialog (`?`).
+ * A key press whose focus is in a text field is never handled, and a handled one gets
+ * `preventDefault`, so the browser does not also act on it.
+ */
+export function ShortcutProvider({ overrides, actions, platform, children, }) {
+    const store = useEditor();
+    const t = useT();
+    const [helpOpen, setHelpOpen] = useState(false);
+    const detected = useMemo(() => platform ?? detectPlatform(), [platform]);
+    const registry = useMemo(() => createShortcutRegistry({ platform: detected, overrides: overrides ?? {} }), [detected, overrides]);
+    // The handlers read the latest actions without rebinding on every render.
+    const external = useRef({});
+    external.current = actions ?? {};
+    useEffect(() => {
+        const unbind = bindEditorActions(registry, store, {
+            copy: () => external.current.copy?.() ?? false,
+            cut: () => external.current.cut?.() ?? false,
+            paste: () => external.current.paste?.() ?? false,
+            save: () => external.current.save?.() ?? false,
+        });
+        const unbindHelp = registry.bind('help.shortcuts', () => {
+            setHelpOpen(true);
+            return true;
+        });
+        return () => {
+            unbind();
+            unbindHelp();
+        };
+    }, [registry, store]);
+    useEffect(() => {
+        registry.setScopes(helpOpen ? ['dialog'] : ['editor']);
+    }, [registry, helpOpen]);
+    useEffect(() => {
+        const onKeyDown = (event) => {
+            if (event.defaultPrevented || event.isComposing)
+                return;
+            const handled = registry.handle(toInput(event), { typing: isTypingTarget(event.target) });
+            if (handled)
+                event.preventDefault();
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => document.removeEventListener('keydown', onKeyDown);
+    }, [registry]);
+    const groups = ['edit', 'selection', 'file', 'help'].map((group) => ({
+        group,
+        items: registry.shortcuts.filter((shortcut) => shortcut.group === group && shortcut.keys.length > 0),
+    }));
+    return (_jsxs(RegistryContext.Provider, { value: registry, children: [children, _jsx(Dialog, { open: helpOpen, onOpenChange: setHelpOpen, title: t('shortcut.title'), children: _jsx("div", { className: "bd-shortcut-help", children: groups
+                        .filter(({ items }) => items.length > 0)
+                        .map(({ group, items }) => (_jsxs("section", { children: [_jsx("h4", { children: t(`shortcut.group.${group}`) }), _jsx("dl", { children: items.map((shortcut) => (_jsxs("div", { className: "bd-shortcut-row", children: [_jsx("dt", { children: t(shortcut.label) }), _jsx("dd", { children: shortcut.keys.map((combo, index) => (_jsxs("span", { children: [index > 0 ? ' / ' : '', _jsx("kbd", { children: displayCombo(combo, detected) })] }, combo))) })] }, shortcut.action))) })] }, group))) }) })] }));
+}
+/** How the first key of `action` is written on this platform (`Ctrl+Z`), for tooltips; `undefined` when it has none. */
+export function useShortcutHint(action) {
+    const registry = useOptionalShortcutRegistry();
+    const combo = registry?.keysFor(action)[0];
+    return registry === undefined || combo === undefined
+        ? undefined
+        : displayCombo(combo, registry.platform);
+}

package/dist/shortcuts/shortcuts.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shortcuts.test.d.ts.map

package/dist/shortcuts/shortcuts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcuts.test.d.ts","sourceRoot":"","sources":["../../src/shortcuts/shortcuts.test.tsx"],"names":[],"mappings":""}

package/dist/shortcuts/shortcuts.test.js

@@ -0,0 +1,263 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @vitest-environment jsdom
+import { createRegistryMeta, createSeededIdGenerator, } from '@next-buildr/core';
+import { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { MessagesProvider } from '../messages/index.js';
+import { createEditorStore, EditorStoreProvider } from '../store/index.js';
+import { comboOf, displayCombo, isTypingTarget, normalizeCombo } from './keys.js';
+import { DEFAULT_SHORTCUTS } from './map.js';
+import { createShortcutRegistry } from './registry.js';
+import { ShortcutProvider, useForwardedKeys } from './shortcuts.js';
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+const none = { shift: false, alt: false, ctrl: false, meta: false };
+const press = (key, mods = {}) => ({
+    key,
+    mods: { ...none, ...mods },
+});
+describe('combinations', () => {
+    it('normalizes spellings of one combination to the same text', () => {
+        expect(normalizeCombo('Shift+Mod+Z')).toBe('mod+shift+z');
+        expect(normalizeCombo('Del')).toBe('delete');
+        expect(normalizeCombo('alt+Up')).toBe('alt+arrowup');
+    });
+    it('reads Cmd as the primary key on a Mac and Ctrl elsewhere', () => {
+        expect(comboOf(press('z', { meta: true }), 'mac')).toBe('mod+z');
+        expect(comboOf(press('z', { ctrl: true }), 'mac')).toBe('ctrl+z');
+        expect(comboOf(press('z', { ctrl: true }), 'other')).toBe('mod+z');
+        expect(comboOf(press('Z', { ctrl: true, shift: true }), 'other')).toBe('mod+shift+z');
+    });
+    it('shows them the way the platform writes them', () => {
+        expect(displayCombo('mod+shift+z', 'mac')).toBe('⌘⇧Z');
+        expect(displayCombo('mod+shift+z', 'other')).toBe('Ctrl+Shift+Z');
+    });
+    it('knows where the keyboard belongs to text', () => {
+        const input = document.createElement('input');
+        const box = document.createElement('input');
+        box.type = 'checkbox';
+        const editable = document.createElement('div');
+        editable.setAttribute('role', 'textbox');
+        const inner = document.createElement('span');
+        editable.append(inner);
+        expect(isTypingTarget(input)).toBe(true);
+        expect(isTypingTarget(document.createElement('textarea'))).toBe(true);
+        expect(isTypingTarget(inner)).toBe(true);
+        expect(isTypingTarget(box)).toBe(false);
+        expect(isTypingTarget(document.createElement('button'))).toBe(false);
+        expect(isTypingTarget(null)).toBe(false);
+    });
+});
+describe('registry', () => {
+    it('runs the handler of a shortcut and reports it', () => {
+        const registry = createShortcutRegistry({ platform: 'other' });
+        const undo = vi.fn();
+        registry.bind('edit.undo', undo);
+        expect(registry.handle(press('z', { ctrl: true }), { typing: false })).toBe(true);
+        expect(undo).toHaveBeenCalledOnce();
+    });
+    it('does nothing while typing', () => {
+        const registry = createShortcutRegistry({ platform: 'other' });
+        const undo = vi.fn();
+        registry.bind('edit.undo', undo);
+        expect(registry.handle(press('z', { ctrl: true }), { typing: true })).toBe(false);
+        expect(undo).not.toHaveBeenCalled();
+    });
+    it('leaves the key alone when the handler declines', () => {
+        const registry = createShortcutRegistry({ platform: 'other' });
+        registry.bind('edit.delete', () => false);
+        expect(registry.handle(press('Delete'), { typing: false })).toBe(false);
+    });
+    it('only fires bindings of an active scope, the latest first', () => {
+        const registry = createShortcutRegistry({ platform: 'other' });
+        const editor = vi.fn();
+        const dialog = vi.fn();
+        registry.bind('selection.clear', editor);
+        registry.bind('selection.clear', dialog, 'dialog');
+        registry.handle(press('Escape'), { typing: false });
+        expect(dialog).not.toHaveBeenCalled();
+        expect(editor).toHaveBeenCalledOnce();
+        registry.setScopes(['dialog']);
+        registry.handle(press('Escape'), { typing: false });
+        expect(dialog).toHaveBeenCalledOnce();
+        expect(editor).toHaveBeenCalledOnce();
+    });
+    it('applies overrides, and an empty override turns a shortcut off', () => {
+        const registry = createShortcutRegistry({
+            platform: 'other',
+            overrides: { 'edit.duplicate': 'mod+j', 'edit.copy': '' },
+        });
+        const duplicate = vi.fn();
+        registry.bind('edit.duplicate', duplicate);
+        expect(registry.handle(press('d', { ctrl: true }), { typing: false })).toBe(false);
+        expect(registry.handle(press('j', { ctrl: true }), { typing: false })).toBe(true);
+        expect(registry.keysFor('edit.copy')).toEqual([]);
+    });
+    it('gives every shortcut in the map its own combinations', () => {
+        const seen = new Set();
+        for (const shortcut of DEFAULT_SHORTCUTS) {
+            for (const combo of shortcut.keys) {
+                expect(seen.has(combo)).toBe(false);
+                seen.add(combo);
+            }
+        }
+    });
+});
+const item = {
+    type: 'buildr/item',
+    version: 1,
+    label: 'Item',
+    category: 'content',
+    props: {},
+    contentCategories: ['flow'],
+    styles: { groups: [] },
+    runtime: 'shared',
+    slots: { default: {} },
+};
+const page = {
+    ...item,
+    type: 'buildr/page',
+    label: 'Page',
+    capabilities: { root: true },
+};
+const registryMeta = createRegistryMeta({ components: [page, item] });
+const fixture = () => ({
+    schemaVersion: 1,
+    root: 'root',
+    nodes: {
+        root: {
+            id: 'root',
+            type: 'buildr/page',
+            slots: { default: ['itemAAAAA1', 'itemBBBBB1', 'itemCCCCC1'] },
+        },
+        itemAAAAA1: { id: 'itemAAAAA1', type: 'buildr/item' },
+        itemBBBBB1: { id: 'itemBBBBB1', type: 'buildr/item' },
+        itemCCCCC1: { id: 'itemCCCCC1', type: 'buildr/item' },
+    },
+    components: {},
+});
+describe('ShortcutProvider', () => {
+    let container;
+    let root;
+    let forwarded;
+    const actions = {
+        copy: vi.fn(() => true),
+        cut: vi.fn(() => true),
+        paste: vi.fn(() => true),
+        save: vi.fn(() => true),
+    };
+    function Probe() {
+        forwarded = useForwardedKeys();
+        return _jsx("input", { "aria-label": "field" });
+    }
+    async function mount() {
+        const store = createEditorStore({
+            doc: fixture(),
+            registry: registryMeta,
+            generateId: createSeededIdGenerator(5),
+            validationDelayMs: null,
+        });
+        await act(async () => root.render(_jsx(MessagesProvider, { locale: "en", children: _jsx(EditorStoreProvider, { store: store, children: _jsx(ShortcutProvider, { platform: "other", actions: actions, children: _jsx(Probe, {}) }) }) })));
+        return store;
+    }
+    const key = (target, init) => act(async () => {
+        target.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, cancelable: true, ...init }));
+    });
+    const order = (store) => store.getState().doc.nodes['root']?.slots?.['default'];
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.append(container);
+        root = createRoot(container);
+        for (const fn of Object.values(actions))
+            fn.mockClear();
+    });
+    afterEach(() => {
+        act(() => root.unmount());
+        document.body.innerHTML = '';
+    });
+    it('deletes, undoes and redoes the selection', async () => {
+        const store = await mount();
+        act(() => store.select('itemBBBBB1'));
+        await key(document.body, { key: 'Delete' });
+        expect(order(store)).toEqual(['itemAAAAA1', 'itemCCCCC1']);
+        await key(document.body, { key: 'z', ctrlKey: true });
+        expect(order(store)).toEqual(['itemAAAAA1', 'itemBBBBB1', 'itemCCCCC1']);
+        await key(document.body, { key: 'Z', ctrlKey: true, shiftKey: true });
+        expect(order(store)).toEqual(['itemAAAAA1', 'itemCCCCC1']);
+    });
+    it('duplicates, moves and clears', async () => {
+        const store = await mount();
+        act(() => store.select('itemBBBBB1'));
+        await key(document.body, { key: 'ArrowUp', altKey: true });
+        expect(order(store)).toEqual(['itemBBBBB1', 'itemAAAAA1', 'itemCCCCC1']);
+        await key(document.body, { key: 'ArrowDown', altKey: true });
+        expect(order(store)).toEqual(['itemAAAAA1', 'itemBBBBB1', 'itemCCCCC1']);
+        await key(document.body, { key: 'd', ctrlKey: true });
+        expect(order(store)?.length).toBe(4);
+        await key(document.body, { key: 'Escape' });
+        expect(store.getState().selectedIds).toEqual([]);
+    });
+    it('selects the siblings of the anchor', async () => {
+        const store = await mount();
+        act(() => store.select('itemAAAAA1'));
+        await key(document.body, { key: 'a', ctrlKey: true });
+        expect(store.getState().selectedIds).toEqual(['itemAAAAA1', 'itemBBBBB1', 'itemCCCCC1']);
+    });
+    it('calls the actions of other modules and prevents the browser default', async () => {
+        await mount();
+        const event = new KeyboardEvent('keydown', {
+            key: 's',
+            ctrlKey: true,
+            bubbles: true,
+            cancelable: true,
+        });
+        await act(async () => {
+            document.body.dispatchEvent(event);
+        });
+        expect(actions.save).toHaveBeenCalledOnce();
+        expect(event.defaultPrevented).toBe(true);
+        for (const [name, k] of [
+            ['copy', 'c'],
+            ['cut', 'x'],
+            ['paste', 'v'],
+        ]) {
+            await key(document.body, { key: k, ctrlKey: true });
+            expect(actions[name]).toHaveBeenCalledOnce();
+        }
+    });
+    it('does not fire while a text field has focus', async () => {
+        const store = await mount();
+        act(() => store.select('itemBBBBB1'));
+        const field = container.querySelector('input');
+        await key(field, { key: 'Delete' });
+        await key(field, { key: 'z', ctrlKey: true });
+        await key(field, { key: 's', ctrlKey: true });
+        expect(order(store)).toEqual(['itemAAAAA1', 'itemBBBBB1', 'itemCCCCC1']);
+        expect(actions.save).not.toHaveBeenCalled();
+    });
+    it('does not swallow a key it cannot act on', async () => {
+        await mount();
+        const event = new KeyboardEvent('keydown', { key: 'Delete', bubbles: true, cancelable: true });
+        await act(async () => {
+            document.body.dispatchEvent(event);
+        });
+        expect(event.defaultPrevented).toBe(false);
+    });
+    it('handles keys forwarded from the canvas', async () => {
+        const store = await mount();
+        act(() => store.select('itemAAAAA1'));
+        let handled = false;
+        await act(async () => {
+            handled = forwarded(press('Delete'));
+        });
+        expect(handled).toBe(true);
+        expect(order(store)).toEqual(['itemBBBBB1', 'itemCCCCC1']);
+    });
+    it('opens a help dialog listing the shortcuts with ?', async () => {
+        await mount();
+        await key(document.body, { key: '?', shiftKey: true });
+        const dialog = document.querySelector('[role=dialog]');
+        expect(dialog?.textContent).toContain('Keyboard shortcuts');
+        expect(dialog?.textContent).toContain('Ctrl+Shift+Z');
+    });
+});