@zengrid/core 1.0.1 → 1.0.4

package/dist/src/shared/data-structures/column-store/column-store.interface.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Column Store interfaces for ZenGrid
+ * Column-oriented storage using typed arrays for performance
+ */
+/**
+ * Supported column data types
+ */
+export type ColumnType = 'int32' | 'float64' | 'string' | 'boolean';
+/**
+ * Aggregation operations
+ */
+export type AggregateOperation = 'sum' | 'avg' | 'min' | 'max' | 'count';
+/**
+ * Column definition
+ */
+export interface ColumnDefinition {
+    /** Column name/identifier */
+    name: string;
+    /** Data type */
+    type: ColumnType;
+    /** Default value for new rows */
+    defaultValue?: any;
+}
+/**
+ * Aggregation result
+ */
+export interface AggregationResult {
+    operation: AggregateOperation;
+    column: string;
+    value: number;
+    count: number;
+}
+/**
+ * Column Store interface
+ *
+ * Column-oriented storage for dense grid data.
+ * Uses typed arrays (Float64Array, Int32Array) for numeric columns for better performance.
+ */
+export interface ColumnStore {
+    /**
+     * Add a new column
+     * @param definition - Column definition
+     * @complexity O(n) where n = rowCount
+     */
+    addColumn(definition: ColumnDefinition): void;
+    /**
+     * Remove a column
+     * @param columnName - Column to remove
+     * @returns true if column existed and was removed
+     * @complexity O(1)
+     */
+    removeColumn(columnName: string): boolean;
+    /**
+     * Check if column exists
+     * @param columnName - Column name
+     * @complexity O(1)
+     */
+    hasColumn(columnName: string): boolean;
+    /**
+     * Get value at (row, column)
+     * @param row - Row index
+     * @param columnName - Column name
+     * @returns Value or undefined if out of bounds
+     * @complexity O(1)
+     */
+    getValue(row: number, columnName: string): any;
+    /**
+     * Set value at (row, column)
+     * @param row - Row index
+     * @param columnName - Column name
+     * @param value - Value to set
+     * @complexity O(1)
+     */
+    setValue(row: number, columnName: string, value: any): void;
+    /**
+     * Get entire row as object
+     * @param row - Row index
+     * @returns Object with column names as keys
+     * @complexity O(c) where c = number of columns
+     */
+    getRow(row: number): Record<string, any>;
+    /**
+     * Set multiple values in a row
+     * @param row - Row index
+     * @param values - Object with column names and values
+     * @complexity O(k) where k = Object.keys(values).length
+     */
+    setRow(row: number, values: Record<string, any>): void;
+    /**
+     * Get entire column as array
+     * @param columnName - Column name
+     * @returns Copy of column data
+     * @complexity O(n) where n = rowCount
+     */
+    getColumn(columnName: string): any[];
+    /**
+     * Set entire column
+     * @param columnName - Column name
+     * @param values - Array of values (length must match rowCount)
+     * @complexity O(n)
+     */
+    setColumn(columnName: string, values: any[]): void;
+    /**
+     * Perform aggregation on a column
+     * @param columnName - Column to aggregate
+     * @param operation - Aggregation operation
+     * @returns Aggregation result
+     * @complexity O(n)
+     */
+    aggregate(columnName: string, operation: AggregateOperation): AggregationResult;
+    /**
+     * Add new rows (expand capacity)
+     * @param count - Number of rows to add
+     * @complexity O(n * c) where n = count, c = columns
+     */
+    addRows(count: number): void;
+    /**
+     * Clear all data but keep column definitions
+     * @complexity O(c) where c = number of columns
+     */
+    clear(): void;
+    /**
+     * Number of rows
+     */
+    readonly rowCount: number;
+    /**
+     * Number of columns
+     */
+    readonly columnCount: number;
+    /**
+     * Column names
+     */
+    readonly columns: ReadonlyArray<string>;
+}
+/**
+ * Options for creating a ColumnStore
+ */
+export interface ColumnStoreOptions {
+    /**
+     * Initial row count
+     * @default 0
+     */
+    rowCount?: number;
+    /**
+     * Column definitions
+     * @default []
+     */
+    columns?: ColumnDefinition[];
+    /**
+     * Whether to grow automatically when accessing rows beyond rowCount
+     * @default false
+     */
+    autoGrow?: boolean;
+}
+//# sourceMappingURL=column-store.interface.d.ts.map

package/dist/src/shared/data-structures/column-store/column-store.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-store.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/column-store/column-store.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,iCAAiC;IACjC,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAE1C;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAEvC;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC;IAE/C;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAAC;IAE5D;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEzC;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IAEvD;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;IAErC;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAEnD;;;;;;OAMG;IACH,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,kBAAkB,GAC5B,iBAAiB,CAAC;IAErB;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7B;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/dist/src/shared/data-structures/column-store/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Column Store - Column-oriented storage with typed arrays
+ */
+export { ColumnStore } from './column-store';
+export type { ColumnStore as IColumnStore, ColumnStoreOptions, ColumnDefinition, ColumnType, AggregateOperation, AggregationResult, } from './column-store.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/column-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/column-store/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,WAAW,IAAI,YAAY,EAC3B,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC"}

package/dist/src/shared/data-structures/command-stack/command-stack.d.ts

@@ -0,0 +1,61 @@
+import type { ICommand, ICommandStack, ICommandStackOptions } from './command-stack.interface';
+/**
+ * Implementation of a command stack for undo/redo functionality.
+ *
+ * Time Complexity:
+ * - execute: O(1)
+ * - undo: O(1)
+ * - redo: O(1)
+ * - canUndo/canRedo: O(1)
+ * - clear: O(1)
+ *
+ * Space Complexity: O(n) where n is the number of commands (up to maxSize)
+ */
+export declare class CommandStack implements ICommandStack {
+    private undoStack;
+    private redoStack;
+    private readonly maxSize;
+    constructor(options?: ICommandStackOptions);
+    /**
+     * Executes a command and adds it to the undo stack.
+     * Clears the redo stack as new actions invalidate the redo history.
+     */
+    execute(command: ICommand): void;
+    /**
+     * Undoes the last executed command.
+     */
+    undo(): boolean;
+    /**
+     * Redoes the last undone command.
+     */
+    redo(): boolean;
+    /**
+     * Checks if there are commands that can be undone.
+     */
+    canUndo(): boolean;
+    /**
+     * Checks if there are commands that can be redone.
+     */
+    canRedo(): boolean;
+    /**
+     * Clears all commands from both stacks.
+     */
+    clear(): void;
+    /**
+     * Gets the number of commands in the undo stack.
+     */
+    getUndoCount(): number;
+    /**
+     * Gets the number of commands in the redo stack.
+     */
+    getRedoCount(): number;
+    /**
+     * Gets the descriptions of all commands in the undo stack.
+     */
+    getUndoHistory(): string[];
+    /**
+     * Gets the descriptions of all commands in the redo stack.
+     */
+    getRedoHistory(): string[];
+}
+//# sourceMappingURL=command-stack.d.ts.map

package/dist/src/shared/data-structures/command-stack/command-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-stack.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/command-stack/command-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,GAAE,oBAAyB;IAQ9C;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAehC;;OAEG;IACH,IAAI,IAAI,OAAO;IAYf;;OAEG;IACH,IAAI,IAAI,OAAO;IAmBf;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;IAM1B;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;CAK3B"}

package/dist/src/shared/data-structures/command-stack/command-stack.interface.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Represents a command that can be executed, undone, and redone.
+ */
+export interface ICommand {
+    /**
+     * Executes the command.
+     */
+    execute(): void;
+    /**
+     * Undoes the command.
+     */
+    undo(): void;
+    /**
+     * Redoes the command (default implementation calls execute).
+     */
+    redo?(): void;
+    /**
+     * Optional description of the command for debugging.
+     */
+    description?: string;
+}
+/**
+ * Configuration options for CommandStack.
+ */
+export interface ICommandStackOptions {
+    /**
+     * Maximum number of commands to keep in history.
+     * @default 100
+     */
+    maxSize?: number;
+}
+/**
+ * Interface for a command stack that supports undo/redo operations.
+ */
+export interface ICommandStack {
+    /**
+     * Executes a command and adds it to the undo stack.
+     * Clears the redo stack.
+     */
+    execute(command: ICommand): void;
+    /**
+     * Undoes the last executed command.
+     * @returns true if a command was undone, false otherwise
+     */
+    undo(): boolean;
+    /**
+     * Redoes the last undone command.
+     * @returns true if a command was redone, false otherwise
+     */
+    redo(): boolean;
+    /**
+     * Checks if there are commands that can be undone.
+     */
+    canUndo(): boolean;
+    /**
+     * Checks if there are commands that can be redone.
+     */
+    canRedo(): boolean;
+    /**
+     * Clears all commands from the stack.
+     */
+    clear(): void;
+    /**
+     * Gets the number of commands in the undo stack.
+     */
+    getUndoCount(): number;
+    /**
+     * Gets the number of commands in the redo stack.
+     */
+    getRedoCount(): number;
+    /**
+     * Gets the descriptions of all commands in the undo stack.
+     */
+    getUndoHistory(): string[];
+    /**
+     * Gets the descriptions of all commands in the redo stack.
+     */
+    getRedoHistory(): string[];
+}
+//# sourceMappingURL=command-stack.interface.d.ts.map

package/dist/src/shared/data-structures/command-stack/command-stack.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-stack.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/command-stack/command-stack.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;OAEG;IACH,IAAI,IAAI,IAAI,CAAC;IAEb;;OAEG;IACH,IAAI,CAAC,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEjC;;;OAGG;IACH,IAAI,IAAI,OAAO,CAAC;IAEhB;;;OAGG;IACH,IAAI,IAAI,OAAO,CAAC;IAEhB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;IAEnB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;IAEnB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,YAAY,IAAI,MAAM,CAAC;IAEvB;;OAEG;IACH,YAAY,IAAI,MAAM,CAAC;IAEvB;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE,CAAC;IAE3B;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE,CAAC;CAC5B"}

package/dist/src/shared/data-structures/command-stack/index.d.ts

@@ -0,0 +1,3 @@
+export * from './command-stack';
+export * from './command-stack.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/command-stack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/command-stack/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC"}

package/dist/src/shared/data-structures/dependency-graph/dependency-graph.d.ts

@@ -0,0 +1,147 @@
+import type { IDependencyGraph, NodeId, DependencyGraphOptions, TopologicalSortResult, GraphStats } from './dependency-graph.interface';
+/**
+ * Dependency Graph (Directed Acyclic Graph)
+ *
+ * A graph structure for tracking dependencies between nodes.
+ * Optimized for formula calculation order and cycle detection.
+ *
+ * **Time Complexity:**
+ * - Add node: O(1)
+ * - Add edge: O(1) without cycle check, O(V + E) with cycle check
+ * - Remove node: O(E) where E = edges connected to node
+ * - Topological sort: O(V + E) using Kahn's algorithm
+ * - Cycle detection: O(V + E) using DFS
+ *
+ * **Space Complexity:** O(V + E)
+ *
+ * **Use Cases:**
+ * - Formula dependencies: =SUM(A1:A10) depends on cells A1 through A10
+ * - Calculation order: Calculate dependencies before dependents
+ * - Circular reference detection: =A1 in cell A1 is invalid
+ * - Dirty cell propagation: When B1 changes, recalculate all cells that depend on B1
+ *
+ * @example Basic Formula Dependencies
+ * ```typescript
+ * const graph = new DependencyGraph();
+ *
+ * // Cell A3 contains formula =A1+A2
+ * graph.addDependency('A3', 'A1'); // A3 depends on A1
+ * graph.addDependency('A3', 'A2'); // A3 depends on A2
+ *
+ * // Cell A4 contains formula =A3*2
+ * graph.addDependency('A4', 'A3'); // A4 depends on A3
+ *
+ * // Get calculation order
+ * const { order } = graph.topologicalSort();
+ * // order: ['A1', 'A2', 'A3', 'A4']
+ *
+ * // Detect circular reference
+ * const wouldCycle = graph.wouldCreateCycle('A1', 'A4');
+ * // wouldCycle: true (A4→A3→A1→A4 creates a cycle)
+ * ```
+ *
+ * @example Incremental Recalculation
+ * ```typescript
+ * // User changes cell B1
+ * const affectedCells = graph.getCalculationOrder(['B1']);
+ * // Returns: ['B1', 'C1', 'D1', ...] (all cells that transitively depend on B1)
+ *
+ * // Recalculate only affected cells in correct order
+ * affectedCells.forEach(cellId => {
+ *   calculateCell(cellId);
+ * });
+ * ```
+ */
+export declare class DependencyGraph implements IDependencyGraph {
+    /** Map of node → nodes it depends on */
+    private dependencies;
+    /** Map of node → nodes that depend on it */
+    private dependents;
+    private options;
+    constructor(options?: DependencyGraphOptions);
+    /**
+     * Add a node to the graph
+     */
+    addNode(id: NodeId): void;
+    /**
+     * Add a dependency edge (from depends on to)
+     *
+     * @param from - Dependent node
+     * @param to - Dependency node
+     * @returns true if edge was added, false if it would create a cycle
+     */
+    addDependency(from: NodeId, to: NodeId): boolean;
+    /**
+     * Remove a node and all its dependencies
+     */
+    removeNode(id: NodeId): boolean;
+    /**
+     * Remove a specific dependency
+     */
+    removeDependency(from: NodeId, to: NodeId): boolean;
+    /**
+     * Check if a node exists
+     */
+    hasNode(id: NodeId): boolean;
+    /**
+     * Check if a dependency exists
+     */
+    hasDependency(from: NodeId, to: NodeId): boolean;
+    /**
+     * Get direct dependencies of a node (what it depends on)
+     */
+    getDependencies(id: NodeId): NodeId[];
+    /**
+     * Get direct dependents of a node (what depends on it)
+     */
+    getDependents(id: NodeId): NodeId[];
+    /**
+     * Get all transitive dependencies (recursive)
+     */
+    getTransitiveDependencies(id: NodeId): NodeId[];
+    /**
+     * Get all transitive dependents (recursive)
+     */
+    getTransitiveDependents(id: NodeId): NodeId[];
+    /**
+     * Check if adding a dependency would create a cycle
+     *
+     * Uses DFS to detect if there's a path from 'to' back to 'from'
+     */
+    wouldCreateCycle(from: NodeId, to: NodeId): boolean;
+    /**
+     * Detect all cycles in the graph using DFS
+     */
+    detectCycles(): NodeId[][];
+    /**
+     * Perform topological sort using Kahn's algorithm
+     *
+     * Returns nodes in dependency order (dependencies before dependents)
+     */
+    topologicalSort(): TopologicalSortResult;
+    /**
+     * Get calculation order for incremental updates
+     *
+     * Returns all nodes that need to be recalculated when the given nodes change,
+     * in the correct calculation order.
+     */
+    getCalculationOrder(changedNodes: NodeId[]): NodeId[];
+    /**
+     * Clear all nodes and edges
+     */
+    clear(): void;
+    /**
+     * Get all nodes
+     */
+    getAllNodes(): NodeId[];
+    /**
+     * Get statistics about the graph
+     */
+    getStats(): GraphStats;
+    /**
+     * Clone the graph
+     */
+    clone(): IDependencyGraph;
+    private calculateDepth;
+}
+//# sourceMappingURL=dependency-graph.d.ts.map

package/dist/src/shared/data-structures/dependency-graph/dependency-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/dependency-graph/dependency-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,MAAM,EACN,sBAAsB,EACtB,qBAAqB,EACrB,UAAU,EACX,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,wCAAwC;IACxC,OAAO,CAAC,YAAY,CAAuC;IAE3D,4CAA4C;IAC5C,OAAO,CAAC,UAAU,CAAuC;IAEzD,OAAO,CAAC,OAAO,CAAmC;gBAEtC,OAAO,GAAE,sBAA2B;IAOhD;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAOzB;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IA4BhD;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAsB/B;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IASnD;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI5B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IAIhD;;OAEG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE;IAIrC;;OAEG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE;IAInC;;OAEG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE;IAqB/C;;OAEG;IACH,uBAAuB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE;IAqB7C;;;;OAIG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IA0BnD;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE,EAAE;IAsC1B;;;;OAIG;IACH,eAAe,IAAI,qBAAqB;IAuDxC;;;;;OAKG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAmCrD;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,WAAW,IAAI,MAAM,EAAE;IAIvB;;OAEG;IACH,QAAQ,IAAI,UAAU;IA+BtB;;OAEG;IACH,KAAK,IAAI,gBAAgB;IAoBzB,OAAO,CAAC,cAAc;CAoBvB"}

package/dist/src/shared/data-structures/dependency-graph/dependency-graph.interface.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Dependency Graph (DAG) Interface
+ *
+ * Used for:
+ * - Formula dependency tracking (cell A1 depends on B1, C1)
+ * - Topological sorting for calculation order
+ * - Cycle detection to prevent circular references
+ * - Dirty cell tracking for incremental recalculation
+ */
+/**
+ * Graph node identifier
+ */
+export type NodeId = string | number;
+/**
+ * Dependency relationship
+ */
+export interface Dependency {
+    /**
+     * Source node (dependent)
+     */
+    from: NodeId;
+    /**
+     * Target node (dependency)
+     */
+    to: NodeId;
+}
+/**
+ * Topological sort result
+ */
+export interface TopologicalSortResult {
+    /**
+     * Sorted nodes in dependency order
+     */
+    order: NodeId[];
+    /**
+     * Whether the graph has cycles
+     */
+    hasCycle: boolean;
+    /**
+     * Nodes involved in cycles (if any)
+     */
+    cycleNodes: NodeId[];
+}
+/**
+ * Graph statistics
+ */
+export interface GraphStats {
+    /**
+     * Total number of nodes
+     */
+    nodeCount: number;
+    /**
+     * Total number of edges (dependencies)
+     */
+    edgeCount: number;
+    /**
+     * Nodes with no dependencies (sources)
+     */
+    sourceCount: number;
+    /**
+     * Nodes with no dependents (sinks)
+     */
+    sinkCount: number;
+    /**
+     * Maximum dependency chain length
+     */
+    maxDepth: number;
+}
+/**
+ * Dependency Graph options
+ */
+export interface DependencyGraphOptions {
+    /**
+     * Allow self-loops (node depending on itself)
+     * @default false
+     */
+    allowSelfLoops?: boolean;
+    /**
+     * Throw error on cycle detection
+     * @default false
+     */
+    throwOnCycle?: boolean;
+}
+/**
+ * Dependency Graph interface
+ */
+export interface IDependencyGraph {
+    /**
+     * Add a node to the graph
+     */
+    addNode(id: NodeId): void;
+    /**
+     * Add a dependency edge (from depends on to)
+     */
+    addDependency(from: NodeId, to: NodeId): boolean;
+    /**
+     * Remove a node and all its dependencies
+     */
+    removeNode(id: NodeId): boolean;
+    /**
+     * Remove a specific dependency
+     */
+    removeDependency(from: NodeId, to: NodeId): boolean;
+    /**
+     * Check if a node exists
+     */
+    hasNode(id: NodeId): boolean;
+    /**
+     * Check if a dependency exists
+     */
+    hasDependency(from: NodeId, to: NodeId): boolean;
+    /**
+     * Get all dependencies of a node (what it depends on)
+     */
+    getDependencies(id: NodeId): NodeId[];
+    /**
+     * Get all dependents of a node (what depends on it)
+     */
+    getDependents(id: NodeId): NodeId[];
+    /**
+     * Get all transitive dependencies (recursive)
+     */
+    getTransitiveDependencies(id: NodeId): NodeId[];
+    /**
+     * Get all transitive dependents (recursive)
+     */
+    getTransitiveDependents(id: NodeId): NodeId[];
+    /**
+     * Detect if adding a dependency would create a cycle
+     */
+    wouldCreateCycle(from: NodeId, to: NodeId): boolean;
+    /**
+     * Detect all cycles in the graph
+     */
+    detectCycles(): NodeId[][];
+    /**
+     * Perform topological sort
+     */
+    topologicalSort(): TopologicalSortResult;
+    /**
+     * Get calculation order for incremental updates
+     */
+    getCalculationOrder(changedNodes: NodeId[]): NodeId[];
+    /**
+     * Clear all nodes and edges
+     */
+    clear(): void;
+    /**
+     * Get all nodes
+     */
+    getAllNodes(): NodeId[];
+    /**
+     * Get statistics about the graph
+     */
+    getStats(): GraphStats;
+    /**
+     * Clone the graph
+     */
+    clone(): IDependencyGraph;
+}
+//# sourceMappingURL=dependency-graph.interface.d.ts.map

package/dist/src/shared/data-structures/dependency-graph/dependency-graph.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-graph.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/dependency-graph/dependency-graph.interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAEjD;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAEhC;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAEpD;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAE7B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAEjD;;OAEG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEtC;;OAEG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEpC;;OAEG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAEhD;;OAEG;IACH,uBAAuB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE9C;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAEpD;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE,EAAE,CAAC;IAE3B;;OAEG;IACH,eAAe,IAAI,qBAAqB,CAAC;IAEzC;;OAEG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAEtD;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,WAAW,IAAI,MAAM,EAAE,CAAC;IAExB;;OAEG;IACH,QAAQ,IAAI,UAAU,CAAC;IAEvB;;OAEG;IACH,KAAK,IAAI,gBAAgB,CAAC;CAC3B"}

package/dist/src/shared/data-structures/dependency-graph/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dependency Graph (DAG) data structure
+ *
+ * Used for formula dependency tracking, cycle detection, and calculation ordering.
+ */
+export { DependencyGraph } from './dependency-graph';
+export type { IDependencyGraph, NodeId, Dependency, DependencyGraphOptions, TopologicalSortResult, GraphStats, } from './dependency-graph.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/dependency-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/dependency-graph/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EACV,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,sBAAsB,EACtB,qBAAqB,EACrB,UAAU,GACX,MAAM,8BAA8B,CAAC"}