@next-buildr/editor 0.0.0-stage → 2.0.1

package/dist/store/selectors.js

@@ -0,0 +1,39 @@
+import { createIndex, } from '@next-buildr/core';
+import { pathTo } from './selection.js';
+const indexes = new WeakMap();
+/**
+ * The parent/slot index of the document, built when first asked for and reused until the document
+ * changes (a new document is a new object, so the cache needs no invalidation).
+ */
+export function selectIndex(state) {
+    let index = indexes.get(state.doc);
+    if (index === undefined) {
+        index = createIndex(state.doc);
+        indexes.set(state.doc, index);
+    }
+    return index;
+}
+/** A node, or `undefined`. The same object until that node changes (structural sharing). */
+export function selectNode(state, id) {
+    return Object.hasOwn(state.doc.nodes, id) ? state.doc.nodes[id] : undefined;
+}
+const NO_CHILDREN = Object.freeze([]);
+/** The children of a node in one slot; the same array until it changes. */
+export function selectChildren(state, id, slot = 'default') {
+    const slots = selectNode(state, id)?.slots;
+    return slots !== undefined && Object.hasOwn(slots, slot)
+        ? (slots[slot] ?? NO_CHILDREN)
+        : NO_CHILDREN;
+}
+/** The anchor of the selection (the last node selected), if any. */
+export function selectSelectedNode(state) {
+    return state.anchorId === null ? undefined : selectNode(state, state.anchorId);
+}
+/** The nodes from the root down to the anchor (empty with no selection). */
+export function selectSelectionPath(state) {
+    return state.anchorId === null ? NO_CHILDREN : pathTo(state.doc, state.anchorId);
+}
+/** Whether the document differs from the saved one; undoing back to the saved state is clean again. */
+export function selectIsDirty(state) {
+    return state.cursorId !== state.savedCursorId;
+}

package/dist/store/store.test.d.ts

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

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

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

package/dist/store/store.test.js

@@ -0,0 +1,331 @@
+import { createRegistryMeta, createSeededIdGenerator, p, s, } from '@next-buildr/core';
+import { describe, expect, it } from 'vitest';
+import { createEditorStore } from './create-store.js';
+import { selectChildren, selectIndex, selectIsDirty, selectNode } from './selectors.js';
+const meta = (type, overrides = {}) => ({
+    type,
+    version: 1,
+    label: type,
+    category: 'content',
+    props: {},
+    contentCategories: ['flow'],
+    styles: { groups: [] },
+    runtime: 'shared',
+    ...overrides,
+});
+const registry = createRegistryMeta({
+    components: [
+        meta('buildr/page', { capabilities: { root: true }, slots: { default: {} } }),
+        meta('buildr/box', { slots: { default: {} } }),
+        meta('buildr/text', { props: { text: p.text({ default: '' }) } }),
+    ],
+});
+const node = (id, type, extra = {}) => ({
+    id,
+    type,
+    ...extra,
+});
+function fixture() {
+    return {
+        schemaVersion: 1,
+        root: 'root',
+        nodes: {
+            root: node('root', 'buildr/page', { slots: { default: ['boxNode001'] } }),
+            boxNode001: node('boxNode001', 'buildr/box', {
+                slots: { default: ['textNodeA1', 'textNodeB1'] },
+            }),
+            textNodeA1: node('textNodeA1', 'buildr/text', { props: { text: s('A') } }),
+            textNodeB1: node('textNodeB1', 'buildr/text', { props: { text: s('B') } }),
+        },
+        components: { 'buildr/page': 1, 'buildr/box': 1, 'buildr/text': 1 },
+    };
+}
+/** A document that throws on any write, at any depth: proof that nothing mutates it. */
+function deepFreeze(value) {
+    if (typeof value === 'object' && value !== null && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}
+const create = (overrides = {}) => createEditorStore({
+    doc: fixture(),
+    registry,
+    generateId: createSeededIdGenerator(7),
+    validationDelayMs: null,
+    ...overrides,
+});
+const setText = (id, text) => ({
+    type: 'node.setProp',
+    payload: { id, prop: 'text', value: s(text) },
+});
+const remove = (...ids) => ({ type: 'node.remove', payload: { ids } });
+const textOf = (store, id) => JSON.stringify(selectNode(store.getState(), id)?.props?.['text']);
+describe('dispatch', () => {
+    it('runs a command, swaps the document in and counts the version', () => {
+        const store = create();
+        const before = store.getState().doc;
+        const result = store.dispatch(setText('textNodeA1', 'Changed'));
+        expect(result.ok).toBe(true);
+        const state = store.getState();
+        expect(state.doc).not.toBe(before);
+        expect(textOf(store, 'textNodeA1')).toContain('Changed');
+        expect(state.docVersion).toBe(1);
+        expect(state.canUndo).toBe(true);
+        expect(state.undoLabel).toBe('node.setProp');
+        // Structural sharing: an untouched node is the very same object.
+        expect(selectNode(state, 'textNodeB1')).toBe(before.nodes['textNodeB1']);
+    });
+    it('leaves everything as it was when a command fails', () => {
+        const store = create();
+        const before = store.getState();
+        const result = store.dispatch(setText('missing', 'x'));
+        expect(result.ok).toBe(false);
+        expect(store.getState()).toBe(before);
+    });
+    it('refuses in a read-only document', () => {
+        const store = create({ readOnly: true });
+        const result = store.dispatch(setText('textNodeA1', 'x'));
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe('editor.read-only');
+        expect(store.undo().ok).toBe(false);
+        expect(store.transaction('x', () => true)).toBe(false);
+        store.setReadOnly(false);
+        expect(store.dispatch(setText('textNodeA1', 'x')).ok).toBe(true);
+    });
+    it('names the undo step, and merges typing into one', () => {
+        const store = create();
+        store.dispatch(setText('textNodeA1', 'A1'), { label: 'Edit text' });
+        store.dispatch(setText('textNodeA1', 'A12'), { label: 'Edit text' });
+        expect(store.getState().undoLabel).toBe('Edit text');
+        expect(store.history.past).toHaveLength(1);
+    });
+    it('runs a batch as one undo step, all or nothing', () => {
+        const store = create();
+        const failed = store.dispatchBatch([setText('textNodeA1', '1'), setText('missing', '2')]);
+        expect(failed.ok).toBe(false);
+        expect(textOf(store, 'textNodeA1')).toContain('A');
+        expect(store.getState().docVersion).toBe(0);
+        expect(store.dispatchBatch([setText('textNodeA1', '1'), setText('textNodeB1', '2')], {
+            label: 'Two',
+        }).ok).toBe(true);
+        expect(store.history.past).toHaveLength(1);
+        store.undo();
+        expect(textOf(store, 'textNodeA1')).toContain('A');
+        expect(textOf(store, 'textNodeB1')).toContain('B');
+    });
+});
+describe('undo and redo', () => {
+    it('go back and forth, with the version always moving forward', () => {
+        const store = create();
+        store.dispatch(setText('textNodeA1', 'One'));
+        store.dispatch(remove('textNodeB1'));
+        expect(selectNode(store.getState(), 'textNodeB1')).toBeUndefined();
+        expect(store.undo().ok).toBe(true);
+        expect(selectNode(store.getState(), 'textNodeB1')).toBeDefined();
+        expect(store.getState().canRedo).toBe(true);
+        expect(store.getState().redoLabel).toBe('node.remove');
+        expect(store.redo().ok).toBe(true);
+        expect(selectNode(store.getState(), 'textNodeB1')).toBeUndefined();
+        expect(store.getState().docVersion).toBe(4);
+        store.undo();
+        store.undo();
+        expect(JSON.stringify(store.getState().doc)).toBe(JSON.stringify(fixture()));
+        expect(store.undo().ok).toBe(false);
+        expect(store.getState().canUndo).toBe(false);
+    });
+    it('restores the selection that went with the step', () => {
+        const store = create();
+        store.setSelection(['textNodeB1']);
+        store.dispatch(remove('textNodeB1'));
+        expect(store.getState().selectedIds).not.toContain('textNodeB1');
+        store.undo();
+        expect(store.getState().selectedIds).toEqual(['textNodeB1']);
+    });
+    it('a new change drops what could be redone', () => {
+        const store = create();
+        store.dispatch(setText('textNodeA1', 'One'));
+        store.undo();
+        store.dispatch(setText('textNodeB1', 'Two'));
+        expect(store.getState().canRedo).toBe(false);
+    });
+});
+describe('transactions', () => {
+    it('make everything inside one step', () => {
+        const store = create();
+        const done = store.transaction('Rewrite', () => {
+            store.dispatch(setText('textNodeA1', '1'));
+            store.dispatch(setText('textNodeB1', '2'));
+            return true;
+        });
+        expect(done).toBe(true);
+        expect(store.getState().inTransaction).toBe(false);
+        expect(store.history.past).toHaveLength(1);
+        expect(store.getState().undoLabel).toBe('Rewrite');
+        store.undo();
+        expect(JSON.stringify(store.getState().doc)).toBe(JSON.stringify(fixture()));
+    });
+    it('roll back when told to, and when they throw', () => {
+        const store = create();
+        expect(store.transaction('No', () => {
+            store.dispatch(setText('textNodeA1', '1'));
+            return false;
+        })).toBe(false);
+        expect(JSON.stringify(store.getState().doc)).toBe(JSON.stringify(fixture()));
+        expect(store.getState().canUndo).toBe(false);
+        expect(() => store.transaction('Boom', () => {
+            store.dispatch(setText('textNodeA1', '1'));
+            throw new Error('boom');
+        })).toThrow('boom');
+        expect(JSON.stringify(store.getState().doc)).toBe(JSON.stringify(fixture()));
+        expect(store.getState().inTransaction).toBe(false);
+    });
+    it('cannot be nested', () => {
+        const store = create();
+        let inner;
+        store.transaction('Outer', () => {
+            inner = store.transaction('Inner', () => true);
+            return true;
+        });
+        expect(inner).toBe(false);
+    });
+});
+describe('what the canvas host hears', () => {
+    it('a patch per change, from and to consecutive versions, that reproduce the document', async () => {
+        const { applyDocumentPatches } = await import('@next-buildr/core/commands');
+        const store = create();
+        const seen = [];
+        store.onChange((change) => seen.push(change));
+        let replica = fixture();
+        store.dispatch(setText('textNodeA1', 'One'));
+        store.dispatch(remove('textNodeB1'));
+        store.undo();
+        store.redo();
+        expect(seen.map((c) => (c.kind === 'patch' ? [c.from, c.to] : null))).toEqual([
+            [0, 1],
+            [1, 2],
+            [2, 3],
+            [3, 4],
+        ]);
+        for (const change of seen) {
+            if (change.kind !== 'patch')
+                throw new Error('expected patches');
+            const applied = applyDocumentPatches(replica, change.patches);
+            if (!applied.ok)
+                throw new Error(applied.error.message);
+            replica = applied.value;
+        }
+        expect(JSON.stringify(replica)).toBe(JSON.stringify(store.getState().doc));
+    });
+    it('a set for a replaced document, which also forgets the history; and stops when unsubscribed', () => {
+        const store = create();
+        const seen = [];
+        const off = store.onChange((change) => seen.push(change));
+        store.dispatch(setText('textNodeA1', 'One'));
+        const other = fixture();
+        store.replaceDocument(other);
+        expect(seen.at(-1)).toEqual({ kind: 'set', doc: other, version: 2 });
+        expect(store.getState().canUndo).toBe(false);
+        expect(store.getState().docVersion).toBe(2);
+        off();
+        store.dispatch(setText('textNodeB1', 'x'));
+        expect(seen).toHaveLength(2);
+    });
+});
+describe('selection', () => {
+    it('keeps only nodes that exist', () => {
+        const store = create();
+        store.setSelection(['textNodeA1', 'ghost', 'textNodeA1', 'textNodeB1']);
+        expect(store.getState().selectedIds).toEqual(['textNodeA1', 'textNodeB1']);
+        store.dispatch(remove('textNodeA1'));
+        expect(store.getState().selectedIds).toEqual(['textNodeB1']);
+    });
+});
+describe('dirty state', () => {
+    it('is clean again after undoing back to the saved state', () => {
+        const store = create();
+        expect(selectIsDirty(store.getState())).toBe(false);
+        store.dispatch(setText('textNodeA1', 'One'));
+        expect(selectIsDirty(store.getState())).toBe(true);
+        store.markSaved();
+        expect(selectIsDirty(store.getState())).toBe(false);
+        store.dispatch(setText('textNodeB1', 'Two'));
+        expect(selectIsDirty(store.getState())).toBe(true);
+        store.undo();
+        expect(selectIsDirty(store.getState())).toBe(false);
+        store.undo();
+        expect(selectIsDirty(store.getState())).toBe(true);
+    });
+});
+describe('derived state', () => {
+    it('builds the index once per document', () => {
+        const store = create();
+        const first = selectIndex(store.getState());
+        expect(selectIndex(store.getState())).toBe(first);
+        store.dispatch(setText('textNodeA1', 'One'));
+        expect(selectIndex(store.getState())).not.toBe(first);
+        expect(selectChildren(store.getState(), 'boxNode001')).toEqual(['textNodeA1', 'textNodeB1']);
+        expect(selectChildren(store.getState(), 'boxNode001', 'nope')).toEqual([]);
+    });
+    it('validates a moment after the last change, not on each one', () => {
+        const scheduled = [];
+        const cleared = [];
+        const store = create({
+            validationDelayMs: 300,
+            timers: {
+                setTimeout: (callback, ms) => {
+                    scheduled.push({ callback, ms });
+                    return scheduled.length;
+                },
+                clearTimeout: (h) => cleared.push(h),
+            },
+        });
+        store.dispatch(setText('textNodeA1', 'One'));
+        store.dispatch(setText('textNodeB1', 'Two'));
+        expect(store.getState().validation).toBeUndefined();
+        expect(scheduled.map((t) => t.ms)).toEqual([300, 300]);
+        expect(cleared).toContain(1);
+        scheduled.at(-1)?.callback();
+        const validation = store.getState().validation;
+        expect(validation?.docVersion).toBe(2);
+        expect(validation?.issues).toEqual([]);
+        expect(Array.isArray(validation?.a11y)).toBe(true);
+    });
+    it('validates on request, and reports a problem the document has', () => {
+        const base = fixture();
+        const doc = {
+            ...base,
+            nodes: { ...base.nodes, textNodeA1: node('textNodeA1', 'acme/unknown') },
+        };
+        const store = create({ doc, validationDelayMs: null });
+        const snapshot = store.validateNow();
+        expect(snapshot.issues.length).toBeGreaterThan(0);
+        expect(store.getState().validation).toBe(snapshot);
+    });
+});
+describe('no mutation outside execute', () => {
+    it('works on a deeply frozen document through every operation', () => {
+        const store = create({ doc: deepFreeze(fixture()) });
+        expect(() => {
+            store.dispatch(setText('textNodeA1', 'One'));
+            store.dispatch(remove('textNodeB1'));
+            store.undo();
+            store.redo();
+            store.transaction('T', () => {
+                store.dispatch(setText('textNodeA1', 'Two'));
+                return true;
+            });
+            store.transaction('R', () => {
+                store.dispatch(setText('textNodeA1', 'Three'));
+                return false;
+            });
+            store.undo();
+            store.replaceDocument(deepFreeze(fixture()));
+            store.dispatch(setText('textNodeB1', 'Four'));
+            store.validateNow();
+        }).not.toThrow();
+        expect(textOf(store, 'textNodeB1')).toContain('Four');
+    });
+});

package/dist/store/types.d.ts

@@ -0,0 +1,114 @@
+import type { A11yIssue, BuilderDocument, IdGenerator, LocaleConfig, NodeId, RegistryMeta, Result, ValidationIssue } from '@next-buildr/core';
+import type { Command, CommandEnv, CommandError, CommandRegistry, CommandResult, DocumentPatch, HistoryManager, HistoryOptions } from '@next-buildr/core/commands';
+import type { StoreApi } from 'zustand/vanilla';
+import type { SelectionMove, SelectMode } from './selection.ts';
+/** Findings about the document as it is now, recomputed after it stops changing. */
+export interface ValidationSnapshot {
+    /** The version of the document they describe. */
+    readonly docVersion: number;
+    readonly issues: readonly ValidationIssue[];
+    readonly a11y: readonly A11yIssue[];
+}
+/** The editor's state (docs/state-management.md#slices). Data only: what changes it is on `EditorStore`. */
+export interface EditorState {
+    readonly doc: BuilderDocument;
+    /** Counts every change to `doc` (a command, an undo, a redo, a replacement), so the canvas can tell what it missed. */
+    readonly docVersion: number;
+    /** The document may not be changed (a component newer than this build knows, a viewer's role). */
+    readonly readOnly: boolean;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly inTransaction: boolean;
+    /** Where in the history the document is; changes with every step, returns on undo. */
+    readonly cursorId: string;
+    /** The `cursorId` that was last saved; the document is dirty when it differs. */
+    readonly savedCursorId: string;
+    readonly undoLabel: string | undefined;
+    readonly redoLabel: string | undefined;
+    /** In the order they were selected; only nodes of `doc`. */
+    readonly selectedIds: readonly NodeId[];
+    /** The node the selection is centred on: the inspector shows it, keyboard moves start from it. */
+    readonly anchorId: NodeId | null;
+    /** Which repetition of a Loop the single selected node is, as the canvas reported it. */
+    readonly selectedInstance: string | undefined;
+    readonly hoveredId: NodeId | null;
+    readonly validation: ValidationSnapshot | undefined;
+}
+/** A change to the document, as the canvas host sends it on (`doc:patch`, `doc:set`). */
+export type DocumentChange = {
+    readonly kind: 'patch';
+    readonly from: number;
+    readonly to: number;
+    readonly patches: readonly DocumentPatch[];
+} | {
+    readonly kind: 'set';
+    readonly doc: BuilderDocument;
+    readonly version: number;
+};
+export interface DispatchOptions {
+    /** Names the undo step; the command's type by default. */
+    readonly label?: string;
+}
+export interface EditorStoreOptions {
+    readonly doc: BuilderDocument;
+    readonly registry: RegistryMeta;
+    /** The command set; the core commands by default. */
+    readonly commands?: CommandRegistry;
+    readonly generateId?: IdGenerator;
+    readonly canUnlock?: CommandEnv['canUnlock'];
+    /** Run `checkInvariants` after every command (a development aid); off by default. */
+    readonly checkInvariants?: boolean;
+    readonly readOnly?: boolean;
+    /** The languages of the content; the accessibility check reports missing translations against them. */
+    readonly locales?: LocaleConfig;
+    readonly history?: HistoryOptions;
+    /** Injected so tests control the validation delay. */
+    readonly timers?: {
+        setTimeout(callback: () => void, ms: number): unknown;
+        clearTimeout(handle: unknown): void;
+    };
+    /** Validation and accessibility checks run this long after the last change; `null` turns them off. */
+    readonly validationDelayMs?: number | null;
+}
+/** The store and what changes it. Every change to the document goes through `dispatch`, `undo`, `redo` or `replaceDocument`. */
+export interface EditorStore extends StoreApi<EditorState> {
+    /** The registry the commands run against; the palette asks it what may go where. */
+    readonly registry: RegistryMeta;
+    /** Runs a command (`execute`) on the document and records it in the history. */
+    dispatch(command: Command, options?: DispatchOptions): Result<CommandResult, CommandError>;
+    /** Runs commands as one undo step, all or nothing (`executeBatch`). */
+    dispatchBatch(commands: readonly Command[], options?: DispatchOptions): Result<CommandResult, CommandError>;
+    /**
+     * Everything dispatched inside `fn` becomes one undo step. Returning `false` or throwing rolls it
+     * back (the document goes back to what it was; a throw is rethrown).
+     */
+    transaction(label: string, fn: () => boolean | undefined): boolean;
+    undo(): Result<true, CommandError>;
+    redo(): Result<true, CommandError>;
+    /** Loads another document; the history starts again. */
+    replaceDocument(doc: BuilderDocument, options?: {
+        readonly readOnly?: boolean;
+    }): void;
+    /** Says that the document as it is now (or as it was at `cursorId`, when saving took a while) is the saved one. */
+    markSaved(cursorId?: string): void;
+    /** Selects a node: replaces the selection, toggles it (Ctrl/Cmd) or adds to it (Shift). */
+    select(id: NodeId, options?: {
+        readonly mode?: SelectMode;
+        readonly instance?: string;
+    }): void;
+    /** Replaces the selection; the last id becomes the anchor. */
+    setSelection(ids: readonly NodeId[]): void;
+    clearSelection(): void;
+    /** Moves the selection one step from the anchor; returns the node now selected, or `undefined` when there was nowhere to go. */
+    moveSelection(move: SelectionMove): NodeId | undefined;
+    setHovered(id: NodeId | null): void;
+    setReadOnly(readOnly: boolean): void;
+    /** Called after every change to the document. Returns the function that stops listening. */
+    onChange(listener: (change: DocumentChange) => void): () => void;
+    /** Runs validation and the accessibility checks now, instead of after the delay. */
+    validateNow(): ValidationSnapshot;
+    readonly history: HistoryManager;
+    /** Stops the pending validation. */
+    destroy(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/store/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/store/types.ts"],"names":[],"mappings":"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"}

package/dist/store/types.js

@@ -0,0 +1 @@
+export {};

package/dist/styles/tokens.test.d.ts

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

package/dist/styles/tokens.test.d.ts.map

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