photon-grid-core 0.0.1

package/engines/tree/tree-node.js

@@ -0,0 +1,199 @@
+/**
+ * Pure hierarchy-construction functions for Tree Data. No class, no store
+ * access, no side effects — `TreeDataService` is the only caller, and it
+ * owns everything stateful (expansion, filtering, sorting). Kept separate so
+ * the O(n) construction algorithms are trivially unit-testable in isolation.
+ *
+ * All four {@link TreeDataConfig.mode} values reduce to two algorithms:
+ *
+ * 1. **Flat array + a per-record `(id, parentId)` resolver** — `'parentId'`,
+ *    `'dataPath'`, and `'custom'` are all this, differing only in how the
+ *    pair is derived (see {@link resolveEdges}).
+ * 2. **Nested `children` arrays** — `'childrenField'` alone, since the input
+ *    isn't flat; {@link flattenNestedChildren} walks it once into the same
+ *    `TreeEdge[]` shape algorithm 1 produces, so {@link buildTree} never
+ *    needs to know which mode produced its input.
+ */
+/** Default field names, mirroring every other Photon config's "sensible default, fully overridable" convention. */
+const DEFAULT_ID_FIELD = 'id';
+const DEFAULT_PARENT_ID_FIELD = 'parentId';
+const DEFAULT_CHILDREN_FIELD = 'children';
+/**
+ * Resolves raw row data into `{id, parentId, record}` edges, ready for
+ * {@link buildTree}. Dispatches on `config.mode` — this is the only place
+ * that branches on hierarchy source; everything downstream is source-agnostic.
+ */
+export function resolveEdges(config, rawRecords) {
+    switch (config.mode) {
+        case 'parentId':
+            return resolveParentIdEdges(rawRecords, config.idField ?? DEFAULT_ID_FIELD, config.parentIdField ?? DEFAULT_PARENT_ID_FIELD);
+        case 'dataPath':
+            return resolveDataPathEdges(rawRecords, config.getDataPath);
+        case 'custom':
+            return resolveCustomEdges(rawRecords, config.hierarchyProvider);
+        case 'childrenField':
+            return flattenNestedChildren(rawRecords, config.childrenField ?? DEFAULT_CHILDREN_FIELD, config.idField ?? DEFAULT_ID_FIELD);
+        default:
+            return [];
+    }
+}
+function resolveParentIdEdges(records, idField, parentIdField) {
+    const edges = new Array(records.length);
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        const rawId = record[idField];
+        const rawParentId = record[parentIdField];
+        edges[i] = {
+            id: rawId != null ? String(rawId) : `pos_${i}`,
+            parentId: rawParentId != null ? String(rawParentId) : null,
+            record,
+        };
+    }
+    return edges;
+}
+/**
+ * `getDataPath` mode: each record's full ancestor path (e.g.
+ * `['Electronics', 'Phones', 'iPhone 15']`) implies both its own id (the
+ * full path, joined) and its parent's id (the path minus its last segment).
+ * Path prefixes with no record of their own (`'Electronics'`,
+ * `'Electronics/Phones'` above, if only the leaf was ever supplied) are
+ * synthesized as filler edges — the same idea as `GroupingEngine`'s
+ * synthetic group-header rows, just keyed by path instead of column value.
+ */
+function resolveDataPathEdges(records, getDataPath) {
+    const edges = new Map();
+    for (const record of records) {
+        const path = getDataPath(record);
+        for (let depth = 0; depth < path.length; depth++) {
+            const id = path.slice(0, depth + 1).join('/');
+            const isLeaf = depth === path.length - 1;
+            if (isLeaf) {
+                // A real record always wins over/replaces a same-path filler that an
+                // earlier record's ancestor path may have already synthesized.
+                edges.set(id, { id, parentId: depth > 0 ? path.slice(0, depth).join('/') : null, record });
+            }
+            else if (!edges.has(id)) {
+                edges.set(id, {
+                    id,
+                    parentId: depth > 0 ? path.slice(0, depth).join('/') : null,
+                    record: { [path[depth]]: path[depth] },
+                    isFiller: true,
+                });
+            }
+        }
+    }
+    return Array.from(edges.values());
+}
+function resolveCustomEdges(records, provider) {
+    return records.map((record) => ({
+        id: provider.getId(record),
+        parentId: provider.getParentKey(record) ?? null,
+        record,
+    }));
+}
+/**
+ * `childrenField` mode: input is already nested (`data[i][childrenField]` is
+ * an array of raw child records, not `RowNode`s), so it needs one O(n) DFS
+ * walk before it can be treated like every other mode's flat edge list.
+ *
+ * Ids fall back to a positional path (`"0"`, `"0.1"`, `"0.1.2"`, ...) when a
+ * record has no `idField` value — stable across rebuilds as long as the
+ * caller's array order/shape doesn't change between pipeline runs, which is
+ * what keeps `expandedTreeNodeIds` (keyed by these ids) from losing state on
+ * every `refresh()`.
+ */
+export function flattenNestedChildren(rootsRaw, childrenField, idField) {
+    const edges = [];
+    function walk(records, parentId, positionalPrefix) {
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            const positionalId = positionalPrefix ? `${positionalPrefix}.${i}` : String(i);
+            const rawId = record[idField];
+            const id = rawId != null ? String(rawId) : positionalId;
+            edges.push({ id, parentId, record });
+            const rawChildren = record[childrenField];
+            if (Array.isArray(rawChildren) && rawChildren.length > 0) {
+                walk(rawChildren, id, positionalId);
+            }
+        }
+    }
+    walk(rootsRaw, null, '');
+    return edges;
+}
+/**
+ * Builds the `RowNode` tree from resolved edges — classic two-pass O(n)
+ * construction (no O(n²) parent scanning): pass 1 creates every node keyed
+ * by id, pass 2 wires `children`/`parent`/`level` by looking up each edge's
+ * `parentId`. An edge whose `parentId` doesn't resolve to a known id (a
+ * dangling reference, or a genuine root) becomes a root.
+ *
+ * `expanded` is intentionally left `false` here — it's set per-node by
+ * {@link flattenTree} at flatten time, since expansion state is external,
+ * mutable, and this function is called fresh on every pipeline run.
+ */
+export function buildTree(edges, defaultRowHeight = 50) {
+    const nodesById = new Map();
+    for (const edge of edges) {
+        nodesById.set(edge.id, {
+            nodeId: edge.id,
+            rowIndex: -1,
+            data: edge.record,
+            type: 'data',
+            selected: false,
+            expanded: false,
+            editable: !edge.isFiller,
+            level: 0,
+            parent: null,
+            children: [],
+            hasChildren: false,
+            isTreeFiller: edge.isFiller,
+            height: defaultRowHeight,
+            top: 0,
+        });
+    }
+    const roots = [];
+    for (const edge of edges) {
+        const node = nodesById.get(edge.id);
+        const parent = edge.parentId != null ? nodesById.get(edge.parentId) : undefined;
+        if (parent) {
+            parent.children.push(node);
+            parent.hasChildren = true;
+            node.parent = parent;
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    // Levels can only be assigned once every parent link exists (a record can
+    // reference a parent that appears later in `edges`), so this is a
+    // deliberate third O(n) pass rather than folded into the wiring pass above.
+    const assignLevels = (nodes, level) => {
+        for (const node of nodes) {
+            node.level = level;
+            if (node.children.length > 0)
+                assignLevels(node.children, level + 1);
+        }
+    };
+    assignLevels(roots, 0);
+    return roots;
+}
+/**
+ * Flattens an expanded subset of the tree into the flat `RowNode[]` every
+ * downstream consumer (pagination, Master/Detail injection, virtualization)
+ * already expects — mirrors `flattenGroupTree` (`group-node.ts`) exactly:
+ * push a node, recurse into its children only if it's expanded.
+ */
+export function flattenTree(roots, expandedIds) {
+    const result = [];
+    const visit = (nodes) => {
+        for (const node of nodes) {
+            node.expanded = expandedIds.has(node.nodeId);
+            result.push(node);
+            if (node.expanded && node.children.length > 0)
+                visit(node.children);
+        }
+    };
+    visit(roots);
+    return result;
+}
+//# sourceMappingURL=tree-node.js.map

package/engines/tree/tree-node.js.map

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

package/engines/tree/tree-selection-service.d.ts

@@ -0,0 +1,35 @@
+import type { RowNode } from '../../types/row.types';
+import type { RowSelectionEngine } from '../selection/row-selection-engine';
+import type { TreeDataService } from './tree-data-service';
+/** Tri-state result for a node whose selection depends on its descendants. */
+export type CascadeSelectionState = 'all' | 'some' | 'none';
+/**
+ * Adds tree-specific cascade selection semantics — selecting a node selects
+ * every descendant, and a node with only some descendants selected reports
+ * as `'some'` (the checkbox-indeterminate state) — on top of the grid's
+ * existing row selection. It never re-implements selection storage: every
+ * mutation goes through `RowSelectionEngine`'s own `selectRows`/`deselectRow`,
+ * so `selectedRowIds`, the `ROW_SELECTED`/`ROW_DESELECTED` events, and
+ * `RowNode.selected` all stay the single source of truth they already are.
+ */
+export declare class TreeSelectionService {
+    private rowSelectionEngine;
+    private treeDataService;
+    constructor(rowSelectionEngine: RowSelectionEngine, treeDataService: TreeDataService);
+    /** Selects `node` and every descendant in its (unfiltered) subtree. */
+    selectWithDescendants(node: RowNode, visibleRows: RowNode[]): void;
+    /** Deselects `node` and every descendant in its (unfiltered) subtree. */
+    deselectWithDescendants(node: RowNode, visibleRows: RowNode[]): void;
+    toggleWithDescendants(node: RowNode, visibleRows: RowNode[]): void;
+    /**
+     * Reports whether every, some, or none of `node`'s descendants are
+     * selected — the input a checkbox renderer needs to show a filled,
+     * indeterminate (`-`), or empty box for a parent row. Walks the *full*
+     * unfiltered subtree (via `TreeDataService.getNode`), not just currently
+     * visible/expanded rows, so collapsing a partially-selected group never
+     * silently changes its reported state.
+     */
+    getDescendantSelectionState(node: RowNode): CascadeSelectionState;
+    private collectDescendantIds;
+}
+//# sourceMappingURL=tree-selection-service.d.ts.map

package/engines/tree/tree-selection-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-selection-service.d.ts","sourceRoot":"","sources":["../../../src/engines/tree/tree-selection-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,8EAA8E;AAC9E,MAAM,MAAM,qBAAqB,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAE5D;;;;;;;;GAQG;AACH,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,eAAe;gBADf,kBAAkB,EAAE,kBAAkB,EACtC,eAAe,EAAE,eAAe;IAG1C,uEAAuE;IACvE,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,IAAI;IAKlE,yEAAyE;IACzE,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,IAAI;IAOpE,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,IAAI;IAQlE;;;;;;;OAOG;IACH,2BAA2B,CAAC,IAAI,EAAE,OAAO,GAAG,qBAAqB;IAYjE,OAAO,CAAC,oBAAoB;CAe7B"}

package/engines/tree/tree-selection-service.js

@@ -0,0 +1,72 @@
+/**
+ * Adds tree-specific cascade selection semantics — selecting a node selects
+ * every descendant, and a node with only some descendants selected reports
+ * as `'some'` (the checkbox-indeterminate state) — on top of the grid's
+ * existing row selection. It never re-implements selection storage: every
+ * mutation goes through `RowSelectionEngine`'s own `selectRows`/`deselectRow`,
+ * so `selectedRowIds`, the `ROW_SELECTED`/`ROW_DESELECTED` events, and
+ * `RowNode.selected` all stay the single source of truth they already are.
+ */
+export class TreeSelectionService {
+    constructor(rowSelectionEngine, treeDataService) {
+        this.rowSelectionEngine = rowSelectionEngine;
+        this.treeDataService = treeDataService;
+    }
+    /** Selects `node` and every descendant in its (unfiltered) subtree. */
+    selectWithDescendants(node, visibleRows) {
+        const ids = [node.nodeId, ...this.collectDescendantIds(node)];
+        this.rowSelectionEngine.selectRows(ids, visibleRows);
+    }
+    /** Deselects `node` and every descendant in its (unfiltered) subtree. */
+    deselectWithDescendants(node, visibleRows) {
+        this.rowSelectionEngine.deselectRow(node.nodeId, visibleRows);
+        for (const id of this.collectDescendantIds(node)) {
+            this.rowSelectionEngine.deselectRow(id, visibleRows);
+        }
+    }
+    toggleWithDescendants(node, visibleRows) {
+        if (this.rowSelectionEngine.isRowSelected(node.nodeId)) {
+            this.deselectWithDescendants(node, visibleRows);
+        }
+        else {
+            this.selectWithDescendants(node, visibleRows);
+        }
+    }
+    /**
+     * Reports whether every, some, or none of `node`'s descendants are
+     * selected — the input a checkbox renderer needs to show a filled,
+     * indeterminate (`-`), or empty box for a parent row. Walks the *full*
+     * unfiltered subtree (via `TreeDataService.getNode`), not just currently
+     * visible/expanded rows, so collapsing a partially-selected group never
+     * silently changes its reported state.
+     */
+    getDescendantSelectionState(node) {
+        const descendantIds = this.collectDescendantIds(node);
+        if (descendantIds.length === 0)
+            return this.rowSelectionEngine.isRowSelected(node.nodeId) ? 'all' : 'none';
+        let selectedCount = 0;
+        for (const id of descendantIds) {
+            if (this.rowSelectionEngine.isRowSelected(id))
+                selectedCount++;
+        }
+        if (selectedCount === 0)
+            return 'none';
+        return selectedCount === descendantIds.length ? 'all' : 'some';
+    }
+    collectDescendantIds(node) {
+        // Prefer the live tree (has every descendant, including currently
+        // collapsed/lazy-unloaded ones already fetched) over `node.children`,
+        // which may be a filtered copy if called mid-filter.
+        const liveNode = this.treeDataService.getNode(node.nodeId) ?? node;
+        const ids = [];
+        const collect = (n) => {
+            for (const child of n.children) {
+                ids.push(child.nodeId);
+                collect(child);
+            }
+        };
+        collect(liveNode);
+        return ids;
+    }
+}
+//# sourceMappingURL=tree-selection-service.js.map

package/engines/tree/tree-selection-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-selection-service.js","sourceRoot":"","sources":["../../../src/engines/tree/tree-selection-service.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,MAAM,OAAO,oBAAoB;IAC/B,YACU,kBAAsC,EACtC,eAAgC;QADhC,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,oBAAe,GAAf,eAAe,CAAiB;IACvC,CAAC;IAEJ,uEAAuE;IACvE,qBAAqB,CAAC,IAAa,EAAE,WAAsB;QACzD,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9D,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACvD,CAAC;IAED,yEAAyE;IACzE,uBAAuB,CAAC,IAAa,EAAE,WAAsB;QAC3D,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QAC9D,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;YACjD,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED,qBAAqB,CAAC,IAAa,EAAE,WAAsB;QACzD,IAAI,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACvD,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAClD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,2BAA2B,CAAC,IAAa;QACvC,MAAM,aAAa,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACtD,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAE3G,IAAI,aAAa,GAAG,CAAC,CAAC;QACtB,KAAK,MAAM,EAAE,IAAI,aAAa,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,EAAE,CAAC;gBAAE,aAAa,EAAE,CAAC;QACjE,CAAC;QACD,IAAI,aAAa,KAAK,CAAC;YAAE,OAAO,MAAM,CAAC;QACvC,OAAO,aAAa,KAAK,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;IACjE,CAAC;IAEO,oBAAoB,CAAC,IAAa;QACxC,kEAAkE;QAClE,sEAAsE;QACtE,qDAAqD;QACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;QACnE,MAAM,GAAG,GAAa,EAAE,CAAC;QACzB,MAAM,OAAO,GAAG,CAAC,CAAU,EAAQ,EAAE;YACnC,KAAK,MAAM,KAAK,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC/B,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBACvB,OAAO,CAAC,KAAK,CAAC,CAAC;YACjB,CAAC;QACH,CAAC,CAAC;QACF,OAAO,CAAC,QAAQ,CAAC,CAAC;QAClB,OAAO,GAAG,CAAC;IACb,CAAC;CACF"}

package/engines/undo-redo/undo-redo-engine.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @file undo-redo-engine.ts
+ * Standalone undo/redo history manager for cell data mutations.
+ *
+ * Design goals
+ * ────────────
+ * • Zero dependencies — no GridStore, EventBus, or DOM access.
+ * • Deduplication — no-op changes (oldValue === newValue) and exact stack
+ *   duplicates are silently dropped so repeated Ctrl+X on an already-null cell
+ *   costs nothing.
+ * • Edit squashing — consecutive edits to the same cell are merged into one
+ *   entry (keeps the original `oldValue`, updates `newValue`) so a single
+ *   Ctrl+Z undoes the whole editing session rather than stepping through every
+ *   intermediate commit.
+ * • Capped stacks — both undo and redo stacks are bounded by `maxStackSize`
+ *   (default 200) to prevent unbounded memory growth on long sessions.
+ * • Redo invalidation — recording a new action clears the redo stack, matching
+ *   the standard branching-history model.
+ */
+/**
+ * A before-and-after snapshot of a single cell value mutation.
+ * `nodeId` + `field` uniquely identify the cell across renders.
+ */
+export interface CellChange {
+    /** Stable row identity — survives sort/filter/group operations. */
+    nodeId: string;
+    /** Dot-notation field path in the row's `data` object. */
+    field: string;
+    /** Value before the mutation (restored on undo). */
+    oldValue: unknown;
+    /** Value after the mutation (re-applied on redo). */
+    newValue: unknown;
+}
+/** Discriminated label for what kind of operation produced the action. */
+export type UndoRedoActionType = 'edit' | 'cut' | 'paste';
+/**
+ * One reversible step on the history stack.
+ * Contains every cell that changed as part of a single user gesture.
+ */
+export interface UndoRedoAction {
+    /** What triggered this history entry. */
+    type: UndoRedoActionType;
+    /**
+     * Ordered list of mutations.  Only meaningful changes are stored
+     * (i.e. `oldValue !== newValue` for every entry).
+     */
+    changes: CellChange[];
+}
+export declare class UndoRedoEngine {
+    private undoStack;
+    private redoStack;
+    private readonly maxStackSize;
+    /**
+     * @param maxStackSize - Upper bound for each stack (default: 200).
+     */
+    constructor(maxStackSize?: number);
+    /** `true` when there is at least one action that can be undone. */
+    get canUndo(): boolean;
+    /** `true` when there is at least one action that can be redone. */
+    get canRedo(): boolean;
+    /**
+     * Records a new action onto the undo stack.
+     *
+     * ### Deduplication rules (applied in order)
+     * 1. **No-op filter** — individual changes where `oldValue === newValue`
+     *    (via `Object.is`) are stripped.  If all changes are no-ops, the entire
+     *    action is silently discarded (e.g. cutting an already-null cell).
+     * 2. **Exact duplicate** — if the incoming action is byte-for-byte identical
+     *    to the current stack top it is discarded, preventing repeated identical
+     *    operations from inflating the stack.
+     * 3. **Edit squash** — when the new action is `'edit'` AND the stack top is
+     *    also `'edit'` on the **same single cell** (`nodeId` + `field` match),
+     *    the top entry's `newValue` is updated in-place.  This collapses a rapid
+     *    sequence of edits into one undo step while preserving the original
+     *    `oldValue`, so Ctrl+Z always jumps back to the value before the first
+     *    edit in the session.
+     *
+     * Recording always clears the redo stack (branching-history model).
+     *
+     * @param action - The action to record.
+     */
+    record(action: UndoRedoAction): void;
+    /**
+     * Pops the most recent action off the undo stack and returns the **inverse**
+     * changes that the caller must apply to restore the previous state.
+     *
+     * The popped action is pushed onto the redo stack so it can be re-applied.
+     *
+     * @returns Inverse `CellChange[]` to apply, or `null` if the stack is empty.
+     */
+    undo(): CellChange[] | null;
+    /**
+     * Pops the most recently undone action off the redo stack and returns its
+     * **forward** changes so the caller can re-apply them.
+     *
+     * The action is pushed back onto the undo stack.
+     *
+     * @returns Forward `CellChange[]` to apply, or `null` if the stack is empty.
+     */
+    redo(): CellChange[] | null;
+    /**
+     * Empties both the undo and redo stacks.
+     * Call when the underlying dataset is completely replaced (e.g. `api.setData`)
+     * so stale history cannot corrupt the new data.
+     */
+    clear(): void;
+    /**
+     * Returns `true` when two actions are structurally identical:
+     * same `type`, same number of changes, and every change has the same
+     * `nodeId`, `field`, `oldValue`, and `newValue` (compared via `Object.is`).
+     */
+    private actionsIdentical;
+}
+//# sourceMappingURL=undo-redo-engine.d.ts.map

package/engines/undo-redo/undo-redo-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo-redo-engine.d.ts","sourceRoot":"","sources":["../../../src/engines/undo-redo/undo-redo-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,0EAA0E;AAC1E,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,IAAI,EAAE,kBAAkB,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAOD,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC;;OAEG;gBACS,YAAY,SAAyB;IAMjD,mEAAmE;IACnE,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,mEAAmE;IACnE,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAuCpC;;;;;;;OAOG;IACH,IAAI,IAAI,UAAU,EAAE,GAAG,IAAI;IAiB3B;;;;;;;OAOG;IACH,IAAI,IAAI,UAAU,EAAE,GAAG,IAAI;IAU3B;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAOb;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAgBzB"}

package/engines/undo-redo/undo-redo-engine.js

@@ -0,0 +1,165 @@
+/**
+ * @file undo-redo-engine.ts
+ * Standalone undo/redo history manager for cell data mutations.
+ *
+ * Design goals
+ * ────────────
+ * • Zero dependencies — no GridStore, EventBus, or DOM access.
+ * • Deduplication — no-op changes (oldValue === newValue) and exact stack
+ *   duplicates are silently dropped so repeated Ctrl+X on an already-null cell
+ *   costs nothing.
+ * • Edit squashing — consecutive edits to the same cell are merged into one
+ *   entry (keeps the original `oldValue`, updates `newValue`) so a single
+ *   Ctrl+Z undoes the whole editing session rather than stepping through every
+ *   intermediate commit.
+ * • Capped stacks — both undo and redo stacks are bounded by `maxStackSize`
+ *   (default 200) to prevent unbounded memory growth on long sessions.
+ * • Redo invalidation — recording a new action clears the redo stack, matching
+ *   the standard branching-history model.
+ */
+// ── Engine ────────────────────────────────────────────────────────────────────
+/** Maximum number of entries stored in each stack. */
+const DEFAULT_MAX_STACK_SIZE = 200;
+export class UndoRedoEngine {
+    /**
+     * @param maxStackSize - Upper bound for each stack (default: 200).
+     */
+    constructor(maxStackSize = DEFAULT_MAX_STACK_SIZE) {
+        this.undoStack = [];
+        this.redoStack = [];
+        this.maxStackSize = maxStackSize;
+    }
+    // ── Public API ─────────────────────────────────────────────────────────────
+    /** `true` when there is at least one action that can be undone. */
+    get canUndo() {
+        return this.undoStack.length > 0;
+    }
+    /** `true` when there is at least one action that can be redone. */
+    get canRedo() {
+        return this.redoStack.length > 0;
+    }
+    /**
+     * Records a new action onto the undo stack.
+     *
+     * ### Deduplication rules (applied in order)
+     * 1. **No-op filter** — individual changes where `oldValue === newValue`
+     *    (via `Object.is`) are stripped.  If all changes are no-ops, the entire
+     *    action is silently discarded (e.g. cutting an already-null cell).
+     * 2. **Exact duplicate** — if the incoming action is byte-for-byte identical
+     *    to the current stack top it is discarded, preventing repeated identical
+     *    operations from inflating the stack.
+     * 3. **Edit squash** — when the new action is `'edit'` AND the stack top is
+     *    also `'edit'` on the **same single cell** (`nodeId` + `field` match),
+     *    the top entry's `newValue` is updated in-place.  This collapses a rapid
+     *    sequence of edits into one undo step while preserving the original
+     *    `oldValue`, so Ctrl+Z always jumps back to the value before the first
+     *    edit in the session.
+     *
+     * Recording always clears the redo stack (branching-history model).
+     *
+     * @param action - The action to record.
+     */
+    record(action) {
+        // ── 1. Strip no-op individual changes ──────────────────────────────────
+        const meaningful = action.changes.filter((c) => !Object.is(c.oldValue, c.newValue));
+        if (meaningful.length === 0)
+            return;
+        const normalised = { type: action.type, changes: meaningful };
+        const top = this.undoStack.length > 0
+            ? this.undoStack[this.undoStack.length - 1]
+            : null;
+        // ── 2. Exact duplicate check ───────────────────────────────────────────
+        if (top && this.actionsIdentical(top, normalised))
+            return;
+        // ── 3. Edit squash (same cell, consecutive edits) ──────────────────────
+        if (action.type === 'edit' &&
+            top?.type === 'edit' &&
+            meaningful.length === 1 &&
+            top.changes.length === 1 &&
+            top.changes[0].nodeId === meaningful[0].nodeId &&
+            top.changes[0].field === meaningful[0].field) {
+            // Mutate the existing top entry: keep its oldValue, update its newValue.
+            top.changes[0].newValue = meaningful[0].newValue;
+            this.redoStack = [];
+            return;
+        }
+        // ── Push to stack ──────────────────────────────────────────────────────
+        if (this.undoStack.length >= this.maxStackSize) {
+            this.undoStack.shift(); // evict oldest to stay within cap
+        }
+        this.undoStack.push(normalised);
+        this.redoStack = []; // invalidate redo branch on any new action
+    }
+    /**
+     * Pops the most recent action off the undo stack and returns the **inverse**
+     * changes that the caller must apply to restore the previous state.
+     *
+     * The popped action is pushed onto the redo stack so it can be re-applied.
+     *
+     * @returns Inverse `CellChange[]` to apply, or `null` if the stack is empty.
+     */
+    undo() {
+        const action = this.undoStack.pop();
+        if (!action)
+            return null;
+        if (this.redoStack.length >= this.maxStackSize)
+            this.redoStack.shift();
+        this.redoStack.push(action);
+        // Inverse: swap oldValue ↔ newValue so applying `newValue` restores the
+        // original cell state.
+        return action.changes.map((c) => ({
+            nodeId: c.nodeId,
+            field: c.field,
+            oldValue: c.newValue, // not used by the caller — kept for symmetry
+            newValue: c.oldValue, // caller writes this into row.data[field]
+        }));
+    }
+    /**
+     * Pops the most recently undone action off the redo stack and returns its
+     * **forward** changes so the caller can re-apply them.
+     *
+     * The action is pushed back onto the undo stack.
+     *
+     * @returns Forward `CellChange[]` to apply, or `null` if the stack is empty.
+     */
+    redo() {
+        const action = this.redoStack.pop();
+        if (!action)
+            return null;
+        if (this.undoStack.length >= this.maxStackSize)
+            this.undoStack.shift();
+        this.undoStack.push(action);
+        return action.changes; // caller writes newValue into row.data[field]
+    }
+    /**
+     * Empties both the undo and redo stacks.
+     * Call when the underlying dataset is completely replaced (e.g. `api.setData`)
+     * so stale history cannot corrupt the new data.
+     */
+    clear() {
+        this.undoStack = [];
+        this.redoStack = [];
+    }
+    // ── Private helpers ────────────────────────────────────────────────────────
+    /**
+     * Returns `true` when two actions are structurally identical:
+     * same `type`, same number of changes, and every change has the same
+     * `nodeId`, `field`, `oldValue`, and `newValue` (compared via `Object.is`).
+     */
+    actionsIdentical(a, b) {
+        if (a.type !== b.type || a.changes.length !== b.changes.length)
+            return false;
+        for (let i = 0; i < a.changes.length; i++) {
+            const ca = a.changes[i];
+            const cb = b.changes[i];
+            if (ca.nodeId !== cb.nodeId ||
+                ca.field !== cb.field ||
+                !Object.is(ca.oldValue, cb.oldValue) ||
+                !Object.is(ca.newValue, cb.newValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=undo-redo-engine.js.map

package/engines/undo-redo/undo-redo-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo-redo-engine.js","sourceRoot":"","sources":["../../../src/engines/undo-redo/undo-redo-engine.ts"],"names":[],"mappings":"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"}

package/event-bus/event-bus.d.ts

@@ -0,0 +1,21 @@
+import type { GridEventType } from '../types/event.types';
+export type EventHandler<T = unknown> = (payload: T) => void;
+export declare class EventBus {
+    private subscriptions;
+    private nextId;
+    private paused;
+    private pendingQueue;
+    on<T>(type: GridEventType, handler: EventHandler<T>, priority?: number): () => void;
+    once<T>(type: GridEventType, handler: EventHandler<T>): () => void;
+    off(type: GridEventType, handler: EventHandler): void;
+    emit<T>(type: GridEventType, payload: T): void;
+    emitAsync<T>(type: GridEventType, payload: T): Promise<void>;
+    pause(): void;
+    resume(): void;
+    clear(type?: GridEventType): void;
+    hasListeners(type: GridEventType): boolean;
+    private addSubscription;
+    private removeSubscription;
+    private dispatch;
+}
+//# sourceMappingURL=event-bus.d.ts.map

package/event-bus/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../../src/event-bus/event-bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC;AAU7D,qBAAa,QAAQ;IACnB,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAwD;IAE5E,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,SAAI,GAAG,MAAM,IAAI;IAY9E,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAYlE,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI;IAOrD,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI;IAQ9C,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5D,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI,IAAI;IAQd,KAAK,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI;IAQjC,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAK1C,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,QAAQ;CAejB"}