@next-buildr/editor 0.0.0-stage → 2.0.0

package/dist/store/create-store.d.ts

@@ -0,0 +1,13 @@
+import type { EditorStore, EditorStoreOptions } from './types.ts';
+/** How long after the last change validation and the accessibility checks run. */
+export declare const DEFAULT_VALIDATION_DELAY_MS = 300;
+/**
+ * The editor's store (docs/state-management.md, ADR-013): a vanilla Zustand store whose document
+ * changes only through `@next-buildr/core/commands`. `dispatch` runs `execute`, records the result in
+ * the history and swaps in the new document; `undo` and `redo` apply the history's patches with
+ * `applyDocumentPatches`; nothing here writes into a document. Every change bumps `docVersion` and
+ * is announced to `onChange` (the canvas host turns it into `doc:patch` / `doc:set`), and validation
+ * runs a moment after the last one.
+ */
+export declare function createEditorStore(options: EditorStoreOptions): EditorStore;
+//# sourceMappingURL=create-store.d.ts.map

package/dist/store/create-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-store.d.ts","sourceRoot":"","sources":["../../src/store/create-store.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAIV,WAAW,EACX,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AAEpB,kFAAkF;AAClF,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAmB/C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CA8O1E"}

package/dist/store/create-store.js

@@ -0,0 +1,248 @@
+import { err, generateId, ok, runA11y, validateDocument, } from '@next-buildr/core';
+import { applyDocumentPatches, commandError, commandMergeKey, coreCommandHandlers, createCommandRegistry, createHistory, execute, executeBatch, } from '@next-buildr/core/commands';
+import { createStore } from 'zustand/vanilla';
+import { EMPTY_SELECTION, normalizeSelection, relativeNode, selectIn, } from './selection.js';
+/** How long after the last change validation and the accessibility checks run. */
+export const DEFAULT_VALIDATION_DELAY_MS = 300;
+function defaultTimers() {
+    const g = globalThis;
+    return { setTimeout: (cb, ms) => g.setTimeout(cb, ms), clearTimeout: (h) => g.clearTimeout(h) };
+}
+/** The ids that are still nodes of `doc`, in order and without repeats. */
+function existing(doc, ids) {
+    const kept = [];
+    for (const id of ids) {
+        if (Object.hasOwn(doc.nodes, id) && !kept.includes(id))
+            kept.push(id);
+    }
+    return kept;
+}
+const readOnlyError = () => commandError('editor.read-only', 'the document cannot be changed');
+/**
+ * The editor's store (docs/state-management.md, ADR-013): a vanilla Zustand store whose document
+ * changes only through `@next-buildr/core/commands`. `dispatch` runs `execute`, records the result in
+ * the history and swaps in the new document; `undo` and `redo` apply the history's patches with
+ * `applyDocumentPatches`; nothing here writes into a document. Every change bumps `docVersion` and
+ * is announced to `onChange` (the canvas host turns it into `doc:patch` / `doc:set`), and validation
+ * runs a moment after the last one.
+ */
+export function createEditorStore(options) {
+    const commands = options.commands ?? createCommandRegistry(coreCommandHandlers);
+    const history = createHistory(options.history);
+    const env = {
+        registry: options.registry,
+        commands,
+        generateId: options.generateId ?? generateId,
+        canUnlock: options.canUnlock,
+        checkInvariants: options.checkInvariants ?? false,
+    };
+    const timers = options.timers ?? defaultTimers();
+    const delay = options.validationDelayMs === undefined
+        ? DEFAULT_VALIDATION_DELAY_MS
+        : options.validationDelayMs;
+    const historyState = () => ({
+        canUndo: history.canUndo,
+        canRedo: history.canRedo,
+        inTransaction: history.inTransaction,
+        cursorId: history.cursorId,
+        undoLabel: history.past[history.past.length - 1]?.label,
+        redoLabel: history.future[history.future.length - 1]?.label,
+    });
+    const api = createStore(() => ({
+        doc: options.doc,
+        docVersion: 0,
+        readOnly: options.readOnly ?? false,
+        ...historyState(),
+        savedCursorId: history.cursorId,
+        ...EMPTY_SELECTION,
+        hoveredId: null,
+        validation: undefined,
+    }));
+    const listeners = new Set();
+    let timer;
+    const validateNow = () => {
+        timers.clearTimeout(timer);
+        const { doc, docVersion } = api.getState();
+        const snapshot = {
+            docVersion,
+            issues: validateDocument(doc, { registry: options.registry }).issues,
+            a11y: runA11y(doc, options.registry, { locales: options.locales }),
+        };
+        api.setState({ validation: snapshot });
+        return snapshot;
+    };
+    const scheduleValidation = () => {
+        if (delay === null)
+            return;
+        timers.clearTimeout(timer);
+        timer = timers.setTimeout(validateNow, delay);
+    };
+    const announce = (change) => {
+        for (const listener of [...listeners])
+            listener(change);
+    };
+    /** Puts a new document in the state and tells the listeners which patches led to it. */
+    const commit = (doc, patches, selection) => {
+        const state = api.getState();
+        const from = state.docVersion;
+        api.setState({
+            doc,
+            docVersion: from + 1,
+            ...normalizeSelection(doc, {
+                selectedIds: selection,
+                anchorId: state.anchorId,
+                selectedInstance: state.selectedInstance,
+            }),
+            hoveredId: state.hoveredId !== null && Object.hasOwn(doc.nodes, state.hoveredId)
+                ? state.hoveredId
+                : null,
+            ...historyState(),
+        });
+        scheduleValidation();
+        announce({ kind: 'patch', from, to: from + 1, patches });
+    };
+    const applyPatches = (patches, selection) => {
+        const applied = applyDocumentPatches(api.getState().doc, patches);
+        if (!applied.ok)
+            return err(applied.error);
+        commit(applied.value, patches, selection);
+        return ok(true);
+    };
+    const run = (commandList, options_) => {
+        const state = api.getState();
+        if (state.readOnly)
+            return err(readOnlyError());
+        const only = commandList.length === 1 ? commandList[0] : undefined;
+        const result = only !== undefined
+            ? execute(state.doc, only, env)
+            : executeBatch(state.doc, commandList, env);
+        if (!result.ok)
+            return result;
+        const { value } = result;
+        const before = state.selectedIds;
+        const after = value.select ?? before;
+        history.record({
+            label: options_?.label ?? commandList[0]?.type ?? 'batch',
+            commands: commandList,
+            patches: value.patches,
+            inverse: value.inverse,
+            selectionBefore: before,
+            selectionAfter: existing(value.doc, after),
+            mergeKey: commandMergeKey(commands, commandList),
+        });
+        if (value.patches.length > 0)
+            commit(value.doc, value.patches, after);
+        else
+            api.setState(historyState());
+        return result;
+    };
+    const store = {
+        ...api,
+        registry: options.registry,
+        history,
+        dispatch: (command, options_) => run([command], options_),
+        dispatchBatch: (commandList, options_) => run(commandList, options_),
+        transaction(label, fn) {
+            if (api.getState().readOnly)
+                return false;
+            const began = history.begin(label);
+            if (!began.ok)
+                return false;
+            api.setState(historyState());
+            const rollBack = () => {
+                const inverse = history.rollback();
+                if (inverse.ok && inverse.value.length > 0) {
+                    applyPatches(inverse.value, api.getState().selectedIds);
+                }
+                else
+                    api.setState(historyState());
+            };
+            let keep;
+            try {
+                keep = fn() !== false;
+            }
+            catch (error) {
+                rollBack();
+                throw error;
+            }
+            if (!keep) {
+                rollBack();
+                return false;
+            }
+            history.commit();
+            api.setState(historyState());
+            return true;
+        },
+        undo() {
+            if (api.getState().readOnly)
+                return err(readOnlyError());
+            const step = history.undo();
+            if (step === undefined)
+                return err(commandError('editor.nothing-to-undo', 'nothing to undo'));
+            return applyPatches(step.patches, step.selection);
+        },
+        redo() {
+            if (api.getState().readOnly)
+                return err(readOnlyError());
+            const step = history.redo();
+            if (step === undefined)
+                return err(commandError('editor.nothing-to-redo', 'nothing to redo'));
+            return applyPatches(step.patches, step.selection);
+        },
+        replaceDocument(doc, replaceOptions) {
+            history.clear();
+            const state = api.getState();
+            const version = state.docVersion + 1;
+            api.setState({
+                doc,
+                docVersion: version,
+                readOnly: replaceOptions?.readOnly ?? state.readOnly,
+                ...historyState(),
+                savedCursorId: history.cursorId,
+                ...normalizeSelection(doc, {
+                    selectedIds: state.selectedIds,
+                    anchorId: state.anchorId,
+                    selectedInstance: state.selectedInstance,
+                }),
+                hoveredId: null,
+                validation: undefined,
+            });
+            scheduleValidation();
+            announce({ kind: 'set', doc, version });
+        },
+        markSaved: (cursorId) => api.setState({ savedCursorId: cursorId ?? history.cursorId }),
+        select: (id, selectOptions) => api.setState((state) => Object.hasOwn(state.doc.nodes, id)
+            ? selectIn(state, id, selectOptions?.mode, selectOptions?.instance)
+            : state),
+        setSelection: (ids) => api.setState((state) => {
+            const next = {
+                selectedIds: ids,
+                anchorId: null,
+                selectedInstance: undefined,
+            };
+            return normalizeSelection(state.doc, next);
+        }),
+        clearSelection: () => api.setState(EMPTY_SELECTION),
+        moveSelection(move) {
+            const { doc, anchorId } = api.getState();
+            if (anchorId === null)
+                return undefined;
+            const target = relativeNode(doc, anchorId, move);
+            if (target === undefined)
+                return undefined;
+            api.setState(selectIn(EMPTY_SELECTION, target));
+            return target;
+        },
+        setHovered: (id) => api.setState({ hoveredId: id }),
+        setReadOnly: (readOnly) => api.setState({ readOnly }),
+        onChange(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        validateNow,
+        destroy: () => timers.clearTimeout(timer),
+    };
+    return store;
+}

package/dist/store/index.d.ts

@@ -0,0 +1,9 @@
+export { createEditorStore, DEFAULT_VALIDATION_DELAY_MS } from './create-store.ts';
+export type { LocaleState, LocaleStore } from './locale.ts';
+export { createLocaleStore, LocaleProvider, useLocaleState, useOptionalLocaleStore, } from './locale.ts';
+export { EditorStoreProvider, useEditor, useEditorState, useIsDirty, useNode, useNodeChildren, useSelectedNode, } from './react.tsx';
+export type { SelectionMove, SelectMode } from './selection.ts';
+export { pathTo, relativeNode } from './selection.ts';
+export { selectChildren, selectIndex, selectIsDirty, selectNode, selectSelectedNode, selectSelectionPath, } from './selectors.ts';
+export type { DispatchOptions, DocumentChange, EditorState, EditorStore, EditorStoreOptions, ValidationSnapshot, } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AACnF,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,cAAc,EACd,UAAU,EACV,OAAO,EACP,eAAe,EACf,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EACL,cAAc,EACd,WAAW,EACX,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,eAAe,EACf,cAAc,EACd,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/store/index.js

@@ -0,0 +1,5 @@
+export { createEditorStore, DEFAULT_VALIDATION_DELAY_MS } from './create-store.js';
+export { createLocaleStore, LocaleProvider, useLocaleState, useOptionalLocaleStore, } from './locale.js';
+export { EditorStoreProvider, useEditor, useEditorState, useIsDirty, useNode, useNodeChildren, useSelectedNode, } from './react.js';
+export { pathTo, relativeNode } from './selection.js';
+export { selectChildren, selectIndex, selectIsDirty, selectNode, selectSelectedNode, selectSelectionPath, } from './selectors.js';

package/dist/store/locale.d.ts

@@ -0,0 +1,23 @@
+import type { LocaleConfig } from '@next-buildr/core';
+import { type ReactNode } from 'react';
+import { type StoreApi } from 'zustand/vanilla';
+/** The language of the content being edited (docs/i18n.md#model-shared-structure-localized-content). */
+export interface LocaleState {
+    readonly config: LocaleConfig;
+    /** The language edits go to; always one of `config.locales`. */
+    readonly locale: string;
+    /** Changes the language. An unknown code is ignored. */
+    setLocale(locale: string): void;
+}
+export type LocaleStore = StoreApi<LocaleState>;
+/** The state for a language configuration, starting on `initial` (the default language unless it is unknown). */
+export declare function createLocaleStore(config: LocaleConfig, initial?: string): LocaleStore;
+export declare function LocaleProvider(props: {
+    readonly store: LocaleStore;
+    readonly children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<LocaleStore | undefined>>;
+/** The locale store, or `undefined` outside a `LocaleProvider` (the panels then edit the default language). */
+export declare const useOptionalLocaleStore: () => LocaleStore | undefined;
+/** The current language state; the single-language default outside a provider. */
+export declare function useLocaleState<T>(select: (state: LocaleState) => T): T;
+//# sourceMappingURL=locale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/store/locale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAgC,KAAK,SAAS,EAAc,MAAM,OAAO,CAAC;AAEjF,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE7D,wGAAwG;AACxG,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;AAEhD,iHAAiH;AACjH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,WAAW,CASrF;AAID,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B,oGAEA;AAED,+GAA+G;AAC/G,eAAO,MAAM,sBAAsB,QAAO,WAAW,GAAG,SAAsC,CAAC;AAS/F,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,CAAC,GAAG,CAAC,CAEtE"}

package/dist/store/locale.js

@@ -0,0 +1,31 @@
+import { createContext, createElement, useContext } from 'react';
+import { useStore } from 'zustand';
+import { createStore } from 'zustand/vanilla';
+/** The state for a language configuration, starting on `initial` (the default language unless it is unknown). */
+export function createLocaleStore(config, initial) {
+    return createStore((set, get) => ({
+        config,
+        locale: initial !== undefined && config.locales.includes(initial) ? initial : config.default,
+        setLocale(locale) {
+            if (locale === get().locale || !config.locales.includes(locale))
+                return;
+            set({ locale });
+        },
+    }));
+}
+const LocaleContext = createContext(undefined);
+export function LocaleProvider(props) {
+    return createElement(LocaleContext.Provider, { value: props.store }, props.children);
+}
+/** The locale store, or `undefined` outside a `LocaleProvider` (the panels then edit the default language). */
+export const useOptionalLocaleStore = () => useContext(LocaleContext);
+const FALLBACK = {
+    config: { locales: ['en'], default: 'en', fallback: true, intl: { en: 'English' } },
+    locale: 'en',
+    setLocale: () => undefined,
+};
+const FALLBACK_STORE = createStore(() => FALLBACK);
+/** The current language state; the single-language default outside a provider. */
+export function useLocaleState(select) {
+    return useStore(useOptionalLocaleStore() ?? FALLBACK_STORE, select);
+}

package/dist/store/react.d.ts

@@ -0,0 +1,17 @@
+import type { NodeId, PageNode, SlotName } from '@next-buildr/core';
+import { type ReactNode } from 'react';
+import type { EditorState, EditorStore } from './types.ts';
+export declare function EditorStoreProvider(props: {
+    readonly store: EditorStore;
+    readonly children: ReactNode;
+}): import("react").JSX.Element;
+/** The store itself, for reading it outside a render or calling its actions. */
+export declare function useEditor(): EditorStore;
+/** Subscribes to a part of the state; the component renders again only when that part changes. */
+export declare function useEditorState<T>(selector: (state: EditorState) => T): T;
+/** One node; the component renders again only when that node does. */
+export declare function useNode(id: NodeId): PageNode | undefined;
+export declare function useSelectedNode(): PageNode | undefined;
+export declare function useNodeChildren(id: NodeId, slot?: SlotName): readonly NodeId[];
+export declare function useIsDirty(): boolean;
+//# sourceMappingURL=react.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/store/react.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAiB,KAAK,SAAS,EAAc,MAAM,OAAO,CAAC;AAGlE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI3D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B,+BAEA;AAED,gFAAgF;AAChF,wBAAgB,SAAS,IAAI,WAAW,CAIvC;AAED,kGAAkG;AAClG,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,CAAC,GAAG,CAAC,CAExE;AAED,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAExD;AAED,wBAAgB,eAAe,IAAI,QAAQ,GAAG,SAAS,CAEtD;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,GAAE,QAAoB,GAAG,SAAS,MAAM,EAAE,CAEzF;AAED,wBAAgB,UAAU,IAAI,OAAO,CAEpC"}

package/dist/store/react.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { useStore } from 'zustand';
+import { selectChildren, selectIsDirty, selectNode, selectSelectedNode } from './selectors.js';
+const StoreContext = createContext(undefined);
+export function EditorStoreProvider(props) {
+    return _jsx(StoreContext.Provider, { value: props.store, children: props.children });
+}
+/** The store itself, for reading it outside a render or calling its actions. */
+export function useEditor() {
+    const store = useContext(StoreContext);
+    if (store === undefined)
+        throw new Error('useEditor must be used inside <EditorStoreProvider>');
+    return store;
+}
+/** Subscribes to a part of the state; the component renders again only when that part changes. */
+export function useEditorState(selector) {
+    return useStore(useEditor(), selector);
+}
+/** One node; the component renders again only when that node does. */
+export function useNode(id) {
+    return useEditorState((state) => selectNode(state, id));
+}
+export function useSelectedNode() {
+    return useEditorState(selectSelectedNode);
+}
+export function useNodeChildren(id, slot = 'default') {
+    return useEditorState((state) => selectChildren(state, id, slot));
+}
+export function useIsDirty() {
+    return useEditorState(selectIsDirty);
+}

package/dist/store/selection.d.ts

@@ -0,0 +1,32 @@
+import { type BuilderDocument, type NodeId } from '@next-buildr/core';
+/** Where the keyboard moves the selection from the node it is on. */
+export type SelectionMove = 'parent' | 'child' | 'next' | 'previous';
+export type SelectMode = 
+/** The node becomes the whole selection. */
+'replace'
+/** Ctrl/Cmd-click: in if it was out, out if it was in. */
+ | 'toggle'
+/** Shift-click: in, whatever it was. */
+ | 'add';
+export interface SelectionState {
+    /** In the order they were selected. */
+    readonly selectedIds: readonly NodeId[];
+    /** The node the selection is centred on: the inspector shows it, moves start from it, ranges will extend from it. */
+    readonly anchorId: NodeId | null;
+    /** Which repetition of a Loop the (single) selected node is: what the canvas reported on click. */
+    readonly selectedInstance: string | undefined;
+}
+export declare const EMPTY_SELECTION: SelectionState;
+/** The selection with every node the document no longer has taken out, and its anchor and instance kept consistent. */
+export declare function normalizeSelection(doc: BuilderDocument, selection: SelectionState): SelectionState;
+/** What selecting `id` does to a selection. */
+export declare function selectIn(current: SelectionState, id: NodeId, mode?: SelectMode, instance?: string): SelectionState;
+/** The nodes from the root down to `id`, or `[]` when `id` is not in the document. */
+export declare function pathTo(doc: BuilderDocument, id: NodeId): NodeId[];
+/**
+ * The node one step from `id`: its parent, its first child, or the next or previous sibling (among
+ * the parent's children across all slots). `undefined` when there is no such node: the root has no
+ * parent or sibling, a leaf has no child, and the ends do not wrap.
+ */
+export declare function relativeNode(doc: BuilderDocument, id: NodeId, move: SelectionMove): NodeId | undefined;
+//# sourceMappingURL=selection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/store/selection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAe,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEnF,qEAAqE;AACrE,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC;AAErE,MAAM,MAAM,UAAU;AACpB,4CAA4C;AAC1C,SAAS;AACX,0DAA0D;GACxD,QAAQ;AACV,wCAAwC;GACtC,KAAK,CAAC;AAEV,MAAM,WAAW,cAAc;IAC7B,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,qHAAqH;IACrH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,mGAAmG;IACnG,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,eAAO,MAAM,eAAe,EAAE,cAI7B,CAAC;AAIF,uHAAuH;AACvH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,cAAc,GACxB,cAAc,CAchB;AAED,+CAA+C;AAC/C,wBAAgB,QAAQ,CACtB,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,GAAE,UAAsB,EAC5B,QAAQ,CAAC,EAAE,MAAM,GAChB,cAAc,CAkBhB;AAED,sFAAsF;AACtF,wBAAgB,MAAM,CAAC,GAAG,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAWjE;AAUD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,eAAe,EACpB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,aAAa,GAClB,MAAM,GAAG,SAAS,CAUpB"}

package/dist/store/selection.js

@@ -0,0 +1,84 @@
+import { createIndex } from '@next-buildr/core';
+export const EMPTY_SELECTION = {
+    selectedIds: [],
+    anchorId: null,
+    selectedInstance: undefined,
+};
+const has = (doc, id) => Object.hasOwn(doc.nodes, id);
+/** The selection with every node the document no longer has taken out, and its anchor and instance kept consistent. */
+export function normalizeSelection(doc, selection) {
+    const ids = [];
+    for (const id of selection.selectedIds)
+        if (has(doc, id) && !ids.includes(id))
+            ids.push(id);
+    const anchor = selection.anchorId !== null && ids.includes(selection.anchorId)
+        ? selection.anchorId
+        : (ids[ids.length - 1] ?? null);
+    const instance = ids.length === 1 && ids[0] === anchor ? selection.selectedInstance : undefined;
+    const same = ids.length === selection.selectedIds.length &&
+        ids.every((id, i) => id === selection.selectedIds[i]) &&
+        anchor === selection.anchorId &&
+        instance === selection.selectedInstance;
+    return same ? selection : { selectedIds: ids, anchorId: anchor, selectedInstance: instance };
+}
+/** What selecting `id` does to a selection. */
+export function selectIn(current, id, mode = 'replace', instance) {
+    if (mode === 'replace') {
+        return { selectedIds: [id], anchorId: id, selectedInstance: instance };
+    }
+    const present = current.selectedIds.includes(id);
+    if (mode === 'toggle' && present) {
+        const rest = current.selectedIds.filter((other) => other !== id);
+        return {
+            selectedIds: rest,
+            anchorId: current.anchorId === id ? (rest[rest.length - 1] ?? null) : current.anchorId,
+            selectedInstance: undefined,
+        };
+    }
+    return {
+        selectedIds: present ? current.selectedIds : [...current.selectedIds, id],
+        anchorId: id,
+        selectedInstance: undefined,
+    };
+}
+/** The nodes from the root down to `id`, or `[]` when `id` is not in the document. */
+export function pathTo(doc, id) {
+    const index = createIndex(doc);
+    if (!has(doc, id) || (id !== doc.root && index.parentOf[id] === undefined))
+        return [];
+    const path = [id];
+    let at = id;
+    while (index.parentOf[at] !== undefined && path.length <= index.order.length) {
+        const parent = index.parentOf[at];
+        path.unshift(parent);
+        at = parent;
+    }
+    return path;
+}
+/** The children of a node, across all of its slots in order. */
+function childrenOf(doc, id) {
+    const slots = doc.nodes[id]?.slots ?? {};
+    return Object.values(slots)
+        .flat()
+        .filter((child) => has(doc, child));
+}
+/**
+ * The node one step from `id`: its parent, its first child, or the next or previous sibling (among
+ * the parent's children across all slots). `undefined` when there is no such node: the root has no
+ * parent or sibling, a leaf has no child, and the ends do not wrap.
+ */
+export function relativeNode(doc, id, move) {
+    if (!has(doc, id))
+        return undefined;
+    const index = createIndex(doc);
+    if (move === 'child')
+        return childrenOf(doc, id)[0];
+    const parent = index.parentOf[id];
+    if (parent === undefined)
+        return undefined;
+    if (move === 'parent')
+        return parent;
+    const siblings = childrenOf(doc, parent);
+    const at = siblings.indexOf(id);
+    return siblings[move === 'next' ? at + 1 : at - 1];
+}

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

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

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

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

package/dist/store/selection.test.js

@@ -0,0 +1,95 @@
+import { createRegistryMeta, createSeededIdGenerator, } from '@next-buildr/core';
+import { describe, expect, it } from 'vitest';
+import { createEditorStore } from './create-store.js';
+import { pathTo, relativeNode } from './selection.js';
+import { selectSelectedNode, selectSelectionPath } from './selectors.js';
+const node = (id, type, extra = {}) => ({
+    id,
+    type,
+    ...extra,
+});
+const doc = {
+    schemaVersion: 1,
+    root: 'root',
+    nodes: {
+        root: node('root', 'buildr/page', { slots: { default: ['boxNode001', 'boxNode002'] } }),
+        boxNode001: node('boxNode001', 'buildr/box', {
+            slots: { default: ['textNodeA1', 'textNodeB1'] },
+        }),
+        boxNode002: node('boxNode002', 'buildr/box'),
+        textNodeA1: node('textNodeA1', 'buildr/text'),
+        textNodeB1: node('textNodeB1', 'buildr/text'),
+    },
+    components: {},
+};
+const create = () => createEditorStore({
+    doc,
+    registry: createRegistryMeta({ components: [] }),
+    generateId: createSeededIdGenerator(3),
+    validationDelayMs: null,
+});
+describe('selection', () => {
+    it('replaces, toggles and adds; the anchor is the last node selected', () => {
+        const store = create();
+        store.select('textNodeA1', { instance: 'loop:2' });
+        expect(store.getState().selectedIds).toEqual(['textNodeA1']);
+        expect(store.getState().selectedInstance).toBe('loop:2');
+        store.select('textNodeB1', { mode: 'add' });
+        expect(store.getState().selectedIds).toEqual(['textNodeA1', 'textNodeB1']);
+        expect(store.getState().anchorId).toBe('textNodeB1');
+        expect(store.getState().selectedInstance).toBeUndefined();
+        store.select('textNodeB1', { mode: 'toggle' });
+        expect(store.getState().selectedIds).toEqual(['textNodeA1']);
+        expect(store.getState().anchorId).toBe('textNodeA1');
+        store.select('boxNode002');
+        expect(store.getState().selectedIds).toEqual(['boxNode002']);
+        store.clearSelection();
+        expect(store.getState().selectedIds).toEqual([]);
+        expect(store.getState().anchorId).toBeNull();
+    });
+    it('ignores a node the document does not have', () => {
+        const store = create();
+        store.select('ghost');
+        expect(store.getState().selectedIds).toEqual([]);
+    });
+    it('drops a removed node from the selection and moves the anchor', () => {
+        const store = create();
+        store.select('textNodeA1');
+        store.select('textNodeB1', { mode: 'add' });
+        store.dispatch({ type: 'node.remove', payload: { ids: ['textNodeB1'] } });
+        expect(store.getState().selectedIds).toEqual(['textNodeA1']);
+        expect(store.getState().anchorId).toBe('textNodeA1');
+        expect(selectSelectedNode(store.getState())?.id).toBe('textNodeA1');
+    });
+    it('moves to the parent, first child and siblings, and stops at the ends', () => {
+        const store = create();
+        store.select('boxNode001');
+        expect(store.moveSelection('child')).toBe('textNodeA1');
+        expect(store.moveSelection('next')).toBe('textNodeB1');
+        expect(store.moveSelection('next')).toBeUndefined();
+        expect(store.getState().anchorId).toBe('textNodeB1');
+        expect(store.moveSelection('previous')).toBe('textNodeA1');
+        expect(store.moveSelection('parent')).toBe('boxNode001');
+        expect(store.moveSelection('parent')).toBe('root');
+        expect(store.moveSelection('parent')).toBeUndefined();
+        expect(store.moveSelection('child')).toBe('boxNode001');
+    });
+    it('does nothing without a selection', () => {
+        expect(create().moveSelection('child')).toBeUndefined();
+    });
+    it('knows the path from the root', () => {
+        expect(pathTo(doc, 'textNodeB1')).toEqual(['root', 'boxNode001', 'textNodeB1']);
+        expect(pathTo(doc, 'root')).toEqual(['root']);
+        expect(pathTo(doc, 'ghost')).toEqual([]);
+        expect(relativeNode(doc, 'textNodeA1', 'previous')).toBeUndefined();
+        const store = create();
+        store.select('textNodeA1');
+        expect(selectSelectionPath(store.getState())).toEqual(['root', 'boxNode001', 'textNodeA1']);
+    });
+    it('clears a hover on a node that is gone', () => {
+        const store = create();
+        store.setHovered('textNodeB1');
+        store.dispatch({ type: 'node.remove', payload: { ids: ['textNodeB1'] } });
+        expect(store.getState().hoveredId).toBeNull();
+    });
+});

package/dist/store/selectors.d.ts

@@ -0,0 +1,18 @@
+import { type DocumentIndex, type NodeId, type PageNode, type SlotName } from '@next-buildr/core';
+import type { EditorState } from './types.ts';
+/**
+ * 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 declare function selectIndex(state: Pick<EditorState, 'doc'>): DocumentIndex;
+/** A node, or `undefined`. The same object until that node changes (structural sharing). */
+export declare function selectNode(state: Pick<EditorState, 'doc'>, id: NodeId): PageNode | undefined;
+/** The children of a node in one slot; the same array until it changes. */
+export declare function selectChildren(state: Pick<EditorState, 'doc'>, id: NodeId, slot?: SlotName): readonly NodeId[];
+/** The anchor of the selection (the last node selected), if any. */
+export declare function selectSelectedNode(state: Pick<EditorState, 'doc' | 'anchorId'>): PageNode | undefined;
+/** The nodes from the root down to the anchor (empty with no selection). */
+export declare function selectSelectionPath(state: Pick<EditorState, 'doc' | 'anchorId'>): readonly NodeId[];
+/** Whether the document differs from the saved one; undoing back to the saved state is clean again. */
+export declare function selectIsDirty(state: Pick<EditorState, 'cursorId' | 'savedCursorId'>): boolean;
+//# sourceMappingURL=selectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/store/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,aAAa,CAO1E;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAE5F;AAID,2EAA2E;AAC3E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,EAC/B,EAAE,EAAE,MAAM,EACV,IAAI,GAAE,QAAoB,GACzB,SAAS,MAAM,EAAE,CAKnB;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,UAAU,CAAC,GAC3C,QAAQ,GAAG,SAAS,CAEtB;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,UAAU,CAAC,GAC3C,SAAS,MAAM,EAAE,CAEnB;AAED,uGAAuG;AACvG,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,eAAe,CAAC,GAAG,OAAO,CAE7F"}