# Conflicts: # craft/src/styles/editor.css
This commit is contained in:
commit
ae871c9cdc
11 files changed
+1004
No files matched your search
@@ -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);
|
||||
});
|
||||
});
|
||||
@@ -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
|
||||
}
|
||||
Reference in new issue
Block a user