@zengrid/core 1.0.6 → 1.1.0

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

@@ -1,147 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,161 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}

package/dist/src/shared/data-structures/disjoint-set/disjoint-set.d.ts

@@ -1,84 +0,0 @@
-/**
- * Disjoint Set (Union-Find) implementation for ZenGrid
- */
-import type { IDisjointSet, DisjointSetOptions, DisjointSetStats } from './disjoint-set.interface';
-/**
- * Disjoint Set implementation with path compression and union by rank
- */
-export declare class DisjointSet<T> implements IDisjointSet<T> {
-    private parent;
-    private rank;
-    private setSize;
-    private elementMap;
-    private hashFn;
-    private equalityFn;
-    constructor(options?: DisjointSetOptions<T>);
-    /**
-     * Create a new set containing only the given element
-     */
-    makeSet(element: T): void;
-    /**
-     * Find the representative (root) of the set containing the element
-     * Uses path compression to optimize future queries
-     */
-    find(element: T): T | undefined;
-    /**
-     * Internal find with path compression
-     */
-    private _findWithCompression;
-    /**
-     * Unite the sets containing two elements
-     * Uses union by rank to keep trees shallow
-     */
-    union(element1: T, element2: T): boolean;
-    /**
-     * Check if two elements are in the same set
-     */
-    connected(element1: T, element2: T): boolean;
-    /**
-     * Get the size of the set containing the element
-     */
-    getSetSize(element: T): number;
-    /**
-     * Get all disjoint sets
-     */
-    getSets(): Map<T, T[]>;
-    /**
-     * Get all elements in the same set as the given element
-     */
-    getSet(element: T): T[];
-    /**
-     * Check if an element exists in the data structure
-     */
-    has(element: T): boolean;
-    /**
-     * Remove an element from the data structure
-     * Note: This is not a standard operation and has O(n) complexity
-     */
-    remove(element: T): boolean;
-    /**
-     * Clear all sets
-     */
-    clear(): void;
-    /**
-     * Get all elements
-     */
-    elements(): T[];
-    /**
-     * Get statistics about the disjoint set
-     */
-    getStats(): DisjointSetStats;
-    /**
-     * Number of elements in the data structure
-     */
-    get size(): number;
-    /**
-     * Number of disjoint sets
-     */
-    get numSets(): number;
-    /**
-     * Whether the data structure is empty
-     */
-    get isEmpty(): boolean;
-}
-//# sourceMappingURL=disjoint-set.d.ts.map

package/dist/src/shared/data-structures/disjoint-set/disjoint-set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"disjoint-set.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/disjoint-set/disjoint-set.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAmBlC;;GAEG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,UAAU,CAA0B;gBAEhC,OAAO,GAAE,kBAAkB,CAAC,CAAC,CAAM;IAgB/C;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAYzB;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAS/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO;IAyCxC;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO;IAW5C;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,MAAM;IAU9B;;OAEG;IACH,OAAO,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IAetB;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE;IAgBvB;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO;IAKxB;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO;IAkD3B;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,QAAQ,IAAI,CAAC,EAAE;IAIf;;OAEG;IACH,QAAQ,IAAI,gBAAgB;IAgB5B;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;CACF"}

package/dist/src/shared/data-structures/disjoint-set/disjoint-set.interface.d.ts

@@ -1,185 +0,0 @@
-/**
- * Disjoint Set (Union-Find) interfaces for ZenGrid
- * Efficient data structure for managing merged cells and connected components
- */
-/**
- * Disjoint Set statistics
- */
-export interface DisjointSetStats {
-    /** Total number of elements */
-    totalElements: number;
-    /** Number of disjoint sets */
-    numSets: number;
-    /** Size of the largest set */
-    largestSetSize: number;
-    /** Average set size */
-    averageSetSize: number;
-    /** Memory usage estimate in bytes */
-    memoryBytes: number;
-}
-/**
- * Disjoint Set interface (Union-Find)
- *
- * A data structure for tracking a partition of elements into disjoint sets.
- * Uses path compression and union by rank for near-constant time operations.
- *
- * Use cases:
- * - Managing merged cells in spreadsheets
- * - Tracking connected components in graphs
- * - Detecting cycles in undirected graphs
- * - Kruskal's minimum spanning tree algorithm
- * - Image segmentation
- * - Network connectivity
- *
- * Performance:
- * - makeSet: O(1)
- * - find: O(α(n)) amortized, where α is inverse Ackermann function (effectively O(1))
- * - union: O(α(n)) amortized
- * - connected: O(α(n)) amortized
- * - Space: O(n)
- *
- * Optimizations:
- * - Path compression: Makes find operations extremely fast
- * - Union by rank: Keeps trees shallow for better performance
- * - Both optimizations together give near-constant time complexity
- */
-export interface IDisjointSet<T> {
-    /**
-     * Create a new set containing only the given element
-     * If element already exists, this is a no-op
-     * @param element - The element to create a set for
-     * @complexity O(1)
-     */
-    makeSet(element: T): void;
-    /**
-     * Find the representative (root) of the set containing the element
-     * Uses path compression to optimize future queries
-     * @param element - The element to find
-     * @returns The representative element, or undefined if element doesn't exist
-     * @complexity O(α(n)) amortized
-     */
-    find(element: T): T | undefined;
-    /**
-     * Unite the sets containing two elements
-     * Uses union by rank to keep trees shallow
-     * @param element1 - First element
-     * @param element2 - Second element
-     * @returns true if sets were merged, false if already in same set or element doesn't exist
-     * @complexity O(α(n)) amortized
-     */
-    union(element1: T, element2: T): boolean;
-    /**
-     * Check if two elements are in the same set
-     * @param element1 - First element
-     * @param element2 - Second element
-     * @returns true if both elements exist and are in the same set
-     * @complexity O(α(n)) amortized
-     */
-    connected(element1: T, element2: T): boolean;
-    /**
-     * Get the size of the set containing the element
-     * @param element - The element to query
-     * @returns Size of the set, or 0 if element doesn't exist
-     * @complexity O(α(n)) amortized
-     */
-    getSetSize(element: T): number;
-    /**
-     * Get all disjoint sets
-     * @returns Map from representative element to array of all elements in that set
-     * @complexity O(n)
-     */
-    getSets(): Map<T, T[]>;
-    /**
-     * Get all elements in the same set as the given element
-     * @param element - The element to query
-     * @returns Array of all elements in the same set, or empty array if element doesn't exist
-     * @complexity O(n) - needs to scan all elements
-     */
-    getSet(element: T): T[];
-    /**
-     * Check if an element exists in the data structure
-     * @param element - The element to check
-     * @complexity O(1)
-     */
-    has(element: T): boolean;
-    /**
-     * Remove an element from the data structure
-     * Note: This is not a standard operation for Disjoint Set and has O(n) complexity
-     * @param element - The element to remove
-     * @returns true if element was found and removed
-     * @complexity O(n)
-     */
-    remove(element: T): boolean;
-    /**
-     * Clear all sets
-     * @complexity O(1)
-     */
-    clear(): void;
-    /**
-     * Get all elements
-     * @returns Array of all elements
-     * @complexity O(n)
-     */
-    elements(): T[];
-    /**
-     * Get statistics about the disjoint set
-     */
-    getStats(): DisjointSetStats;
-    /**
-     * Number of elements in the data structure
-     */
-    readonly size: number;
-    /**
-     * Number of disjoint sets
-     */
-    readonly numSets: number;
-    /**
-     * Whether the data structure is empty
-     */
-    readonly isEmpty: boolean;
-}
-/**
- * Options for creating a Disjoint Set
- */
-export interface DisjointSetOptions<T> {
-    /**
-     * Custom hash function for elements
-     * If not provided, uses JSON.stringify for objects or toString for primitives
-     */
-    hashFn?: (element: T) => string | number;
-    /**
-     * Custom equality function
-     * If not provided, uses strict equality (===)
-     */
-    equalityFn?: (a: T, b: T) => boolean;
-    /**
-     * Initial elements to create sets for
-     */
-    initialElements?: T[];
-}
-/**
- * Utility functions for Disjoint Set
- */
-export declare const DisjointSetUtils: {
-    /**
-     * Calculate expected memory usage
-     * @param n - Number of elements
-     * @returns Estimated memory in bytes
-     */
-    estimateMemory(n: number): number;
-    /**
-     * Check if operations are effectively O(1)
-     * For practical purposes, α(n) ≤ 4 for any realistic n
-     */
-    inverseAckermann(n: number): number;
-    /**
-     * Create a grid coordinate hash function for merged cells
-     * Useful for grid applications where elements are [row, col] coordinates
-     */
-    gridHashFn(element: [number, number]): string;
-    /**
-     * Create equality function for grid coordinates
-     */
-    gridEqualityFn(a: [number, number], b: [number, number]): boolean;
-};
-//# sourceMappingURL=disjoint-set.interface.d.ts.map

package/dist/src/shared/data-structures/disjoint-set/disjoint-set.interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"disjoint-set.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/disjoint-set/disjoint-set.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IAE1B;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAEhC;;;;;;;OAOG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC;IAEzC;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC;IAE7C;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,MAAM,CAAC;IAE/B;;;;OAIG;IACH,OAAO,IAAI,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAEvB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;IAExB;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;IAE5B;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;OAIG;IACH,QAAQ,IAAI,CAAC,EAAE,CAAC;IAEhB;;OAEG;IACH,QAAQ,IAAI,gBAAgB,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAAC;IAEzC;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAErC;;OAEG;IACH,eAAe,CAAC,EAAE,CAAC,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;OAIG;sBACe,MAAM,GAAG,MAAM;IAOjC;;;OAGG;wBACiB,MAAM,GAAG,MAAM;IAUnC;;;OAGG;wBACiB,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAI7C;;OAEG;sBACe,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;CAGlE,CAAC"}

package/dist/src/shared/data-structures/disjoint-set/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Disjoint Set (Union-Find) for ZenGrid
- */
-export { DisjointSet } from './disjoint-set';
-export type { IDisjointSet, DisjointSetOptions, DisjointSetStats, } from './disjoint-set.interface';
-export { DisjointSetUtils } from './disjoint-set.interface';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/data-structures/disjoint-set/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/data-structures/disjoint-set/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC"}