Merge W0-commands (Refs #39 #49 #34)

# Conflicts:
#	craft/src/styles/editor.css
This commit is contained in:
shadowdao committed 2026-10-07 11:20:25 -07:00
commit ae871c9cdc
11 files changed
+1004

No files matched your search

+200
View File
@@ -0,0 +1,200 @@
import { describe, test, expect, vi, afterEach, beforeEach } from 'vitest';
import React from 'react';
import { renderEditorHarness, EditorHarness } from '../test-utils/editorHarness';
import { buildNodeTree } from '../utils/craft-tree';
import {
registerCommand,
registerCommands,
getCommands,
getCommand,
subscribeCommands,
useCommandContext,
useCommandShortcuts,
useRunCommand,
useRegisterCommands,
__resetCommandsForTests,
type CommandContext,
type Command,
} from './commands';
let h: EditorHarness;
let ctxRef: { current: CommandContext | null };
let runRef: { current: ((id: string) => Promise<boolean>) | null };
const Probe: React.FC = () => {
useCommandShortcuts();
ctxRef.current = useCommandContext();
runRef.current = useRunCommand();
return null;
};
function key(init: KeyboardEventInit, target: EventTarget = document.body) {
const e = new KeyboardEvent('keydown', { bubbles: true, cancelable: true, ...init });
h.act(() => {
target.dispatchEvent(e);
});
return e;
}
const cmd = (over: Partial<Command> & { id: string }): Command => ({
title: over.id,
group: 'edit',
run: () => {},
...over,
});
beforeEach(() => {
__resetCommandsForTests();
ctxRef = { current: null };
runRef = { current: null };
h = renderEditorHarness();
h.mountChild(<Probe />);
});
afterEach(() => {
h.unmount();
__resetCommandsForTests();
document.body.innerHTML = '';
});
describe('registry', () => {
test('order, replace by id, unregister, subscribe', () => {
const cb = vi.fn();
const off = subscribeCommands(cb);
const offA = registerCommand(cmd({ id: 'a' }));
registerCommands([cmd({ id: 'b' }), cmd({ id: 'c' })]);
expect(getCommands().map((c) => c.id)).toEqual(['a', 'b', 'c']);
expect(getCommands()).toBe(getCommands()); // stable snapshot
const a2 = cmd({ id: 'a', title: 'A2' });
registerCommand(a2);
expect(getCommand('a')).toBe(a2);
expect(getCommands().map((c) => c.id)).toEqual(['a', 'b', 'c']);
offA(); // stale unregister must not remove the replacement
expect(getCommand('a')).toBe(a2);
expect(cb).toHaveBeenCalled();
off();
});
test('useRegisterCommands registers on mount and unregisters on unmount', () => {
const Feature: React.FC = () => {
useRegisterCommands([cmd({ id: 'feat' })], []);
return null;
};
h.mountChild(<><Probe /><Feature /></>);
expect(getCommand('feat')).toBeDefined();
h.mountChild(<Probe />);
expect(getCommand('feat')).toBeUndefined();
});
});
describe('useCommandShortcuts', () => {
test('mod+d runs the matching command once, preventDefault called', () => {
const dup = vi.fn();
const other = vi.fn();
registerCommands([
cmd({ id: 'edit.other', shortcut: 'mod+e', run: other }),
cmd({ id: 'edit.duplicate', shortcut: 'mod+d', run: dup }),
]);
const e = key({ key: 'd', ctrlKey: true });
expect(dup).toHaveBeenCalledTimes(1);
expect(other).not.toHaveBeenCalled();
expect(e.defaultPrevented).toBe(true);
expect(dup.mock.calls[0][0].query).toBeDefined();
});
test('not run when a focused input is the target', () => {
const run = vi.fn();
registerCommand(cmd({ id: 'x', shortcut: 'mod+d', run }));
const input = document.createElement('input');
document.body.appendChild(input);
input.focus();
const e = key({ key: 'd', ctrlKey: true }, input);
expect(run).not.toHaveBeenCalled();
expect(e.defaultPrevented).toBe(false);
});
test('allowWhileTyping commands still fire in an input', () => {
const run = vi.fn();
registerCommand(cmd({ id: 'x', shortcut: 'mod+k', allowWhileTyping: true, run }));
const input = document.createElement('input');
document.body.appendChild(input);
input.focus();
key({ key: 'k', ctrlKey: true }, input);
expect(run).toHaveBeenCalledTimes(1);
});
test('when() false: not run, event not prevented, next match may run', () => {
const blocked = vi.fn();
const fallback = vi.fn();
registerCommands([
cmd({ id: 'blocked', shortcut: 'mod+d', when: () => false, run: blocked }),
cmd({ id: 'fallback', shortcut: 'mod+d', run: fallback }),
]);
const e = key({ key: 'd', ctrlKey: true });
expect(blocked).not.toHaveBeenCalled();
expect(fallback).toHaveBeenCalledTimes(1);
expect(e.defaultPrevented).toBe(true);
__resetCommandsForTests();
registerCommand(cmd({ id: 'only', shortcut: 'mod+d', when: () => false, run: blocked }));
const e2 = key({ key: 'd', ctrlKey: true });
expect(blocked).not.toHaveBeenCalled();
expect(e2.defaultPrevented).toBe(false);
});
test('unregister stops it', () => {
const run = vi.fn();
const off = registerCommand(cmd({ id: 'x', shortcut: 'mod+d', run }));
key({ key: 'd', ctrlKey: true });
expect(run).toHaveBeenCalledTimes(1);
off();
const e = key({ key: 'd', ctrlKey: true });
expect(run).toHaveBeenCalledTimes(1);
expect(e.defaultPrevented).toBe(false);
});
test('run sees the LIVE selection even before the collector re-renders', () => {
const tree = buildNodeTree(h.query, { type: { resolvedName: 'Container' }, props: { node_id: 'n1' }, nodes: [] } as any);
h.act(() => h.actions.addNodeTree(tree, 'ROOT'));
let seen: string[] = [];
registerCommand(cmd({ id: 'x', shortcut: 'mod+d', run: (c) => { seen = c.selectedIds; } }));
// Same act() batch: React has not re-rendered, so only a live read can see it.
h.act(() => {
h.actions.selectNode('n1');
document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'd', ctrlKey: true, bubbles: true, cancelable: true }));
});
expect(seen).toEqual(['n1']);
});
});
describe('useCommandContext / useRunCommand', () => {
test('selectedIds reflects actions.selectNode', () => {
const tree = buildNodeTree(h.query, { type: { resolvedName: 'Container' }, props: { node_id: 'n1' }, nodes: [] } as any);
h.act(() => h.actions.addNodeTree(tree, 'ROOT'));
expect(ctxRef.current!.selectedIds).toEqual([]);
h.act(() => h.actions.selectNode('n1'));
expect(ctxRef.current!.selectedIds).toEqual(['n1']);
h.act(() => h.actions.clearEvents());
expect(ctxRef.current!.selectedIds).toEqual([]);
});
test('exposes the composed contexts', () => {
const c = ctxRef.current!;
expect(c.device).toBe('desktop');
for (const fn of ['setDevice', 'notify', 'openSitesmith', 'openTemplates', 'openHeadCode'] as const) {
expect(typeof c[fn]).toBe('function');
}
expect(c.pages).toBeDefined();
});
test('useRunCommand: runs by id; false when missing or when() fails', async () => {
const run = vi.fn();
registerCommands([
cmd({ id: 'ok', run }),
cmd({ id: 'off', when: () => false, run }),
]);
expect(await runRef.current!('ok')).toBe(true);
expect(await runRef.current!('off')).toBe(false);
expect(await runRef.current!('missing')).toBe(false);
expect(run).toHaveBeenCalledTimes(1);
});
});
+197
View File
@@ -0,0 +1,197 @@
import { useCallback, useEffect, useMemo, useRef } from 'react';
import { useEditor } from '@craftjs/core';
import type { DeviceMode } from '../types';
import { useDevice } from '../state/DeviceContext';
import { usePages } from '../state/PageContext';
import { useSitesmithModal } from '../state/SitesmithContext';
import { useNotices } from '../state/NoticeContext';
import { useMobileChrome } from '../state/MobileChromeContext';
import { isTypingTarget, matchShortcut } from '../utils/shortcuts';
/**
* Command registry: one place where features register what they can do, shared
* by the keyboard layer, the Cmd+K palette, the top-bar "More" menu and the
* breadcrumb. Module-level (like hooks/clipboard.ts); features register from an
* effect via `useRegisterCommands` and never edit TopBar / useKeyboardShortcuts.
*/
export type CommandGroup = 'edit' | 'select' | 'view' | 'insert' | 'page' | 'site' | 'help';
export interface CommandContext {
query: any;
actions: any;
selectedIds: string[];
device: DeviceMode;
setDevice(d: DeviceMode): void;
pages: ReturnType<typeof usePages>;
notify: ReturnType<typeof useNotices>['notify'];
openSitesmith(target?: any): void;
openTemplates(): void;
openHeadCode(): void;
}
export interface Command {
id: string;
title: string;
group: CommandGroup;
keywords?: string[];
/** Shortcut spec string, see utils/shortcuts.ts ('mod+d', 'alt+arrowup'). */
shortcut?: string;
when?(ctx: CommandContext): boolean;
run(ctx: CommandContext): void | Promise<void>;
/** Not shown in the palette / menu (still runnable by shortcut and id). */
hidden?: boolean;
/** Fire the shortcut even while an input / contentEditable is focused. */
allowWhileTyping?: boolean;
}
const registry = new Map<string, Command>();
const listeners = new Set<() => void>();
let snapshot: Command[] | null = null;
function changed() {
snapshot = null;
listeners.forEach((cb) => cb());
}
export function registerCommand(cmd: Command): () => void {
registry.set(cmd.id, cmd);
changed();
return () => {
// Only remove our own registration; a later re-register of the same id wins.
if (registry.get(cmd.id) === cmd) {
registry.delete(cmd.id);
changed();
}
};
}
export function registerCommands(cmds: Command[]): () => void {
const offs = cmds.map(registerCommand);
return () => offs.forEach((off) => off());
}
/** Stable registration order; the same array instance until the registry changes. */
export function getCommands(): Command[] {
if (!snapshot) snapshot = Array.from(registry.values());
return snapshot;
}
export function getCommand(id: string): Command | undefined {
return registry.get(id);
}
export function subscribeCommands(cb: () => void): () => void {
listeners.add(cb);
return () => {
listeners.delete(cb);
};
}
export function __resetCommandsForTests(): void {
registry.clear();
listeners.clear();
snapshot = null;
}
export function useCommandContext(): CommandContext {
// Collect a string key (not an array) so the hook only re-renders when the
// selection actually changes.
const { actions, query, selKey } = useEditor((state) => ({
selKey: Array.from(state.events.selected || []).join('\n'),
}));
const { device, setDevice } = useDevice();
const pages = usePages();
const { notify } = useNotices();
const { open: openSitesmith } = useSitesmithModal();
const { setTemplateModalOpen, setHeadCodeModalOpen } = useMobileChrome();
return useMemo<CommandContext>(
() => ({
query,
actions,
selectedIds: selKey ? selKey.split('\n') : [],
device,
setDevice,
pages,
notify,
openSitesmith,
openTemplates: () => setTemplateModalOpen(true),
openHeadCode: () => setHeadCodeModalOpen(true),
}),
[query, actions, selKey, device, setDevice, pages, notify, openSitesmith, setTemplateModalOpen, setHeadCodeModalOpen],
);
}
/** Live selection read; collectors are snapshots and can lag a keydown. */
function liveContext(ctx: CommandContext): CommandContext {
try {
return { ...ctx, selectedIds: ctx.query.getEvent('selected').all() };
} catch {
return ctx;
}
}
function isEnabled(cmd: Command, ctx: CommandContext): boolean {
try {
return cmd.when ? !!cmd.when(ctx) : true;
} catch {
return false;
}
}
export function useRunCommand(): (id: string) => Promise<boolean> {
const ctx = useCommandContext();
const ref = useRef(ctx);
ref.current = ctx;
return useCallback(async (id: string) => {
const cmd = getCommand(id);
if (!cmd) return false;
const c = liveContext(ref.current);
if (!isEnabled(cmd, c)) return false;
try {
await cmd.run(c);
return true;
} catch (err) {
console.error(`Command ${id} failed:`, err);
return false;
}
}, []);
}
/**
* Document-level keydown dispatcher: first registered command whose shortcut
* matches and whose `when()` passes runs, with preventDefault. NOT mounted by
* W0-commands -- issue #39 mounts it (and retires useKeyboardShortcuts) so two
* listeners never double-fire.
*/
export function useCommandShortcuts(): void {
const ctx = useCommandContext();
const ref = useRef(ctx);
ref.current = ctx;
useEffect(() => {
const onKeyDown = (e: KeyboardEvent) => {
const typing = isTypingTarget(document.activeElement);
const c = liveContext(ref.current);
for (const cmd of getCommands()) {
if (!cmd.shortcut || !matchShortcut(e, cmd.shortcut)) continue;
if (typing && !cmd.allowWhileTyping) continue;
if (!isEnabled(cmd, c)) continue;
e.preventDefault();
try {
Promise.resolve(cmd.run(c)).catch((err) => console.error(`Command ${cmd.id} failed:`, err));
} catch (err) {
console.error(`Command ${cmd.id} failed:`, err);
}
return;
}
};
document.addEventListener('keydown', onKeyDown);
return () => document.removeEventListener('keydown', onKeyDown);
}, []);
}
/** Register commands for the lifetime of a component; re-registers when `deps` change. */
export function useRegisterCommands(cmds: Command[], deps: unknown[]): void {
useEffect(() => registerCommands(cmds), deps); // eslint-disable-line react-hooks/exhaustive-deps
}