@zengrid/shared 1.0.3 → 1.1.0

package/dist/src/data-structures/interval-tree/interval-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval-tree.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/interval-tree/interval-tree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAqBnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACtD,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuC;gBAEtD,OAAO,GAAE,mBAAwB;IAM7C,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IA2BpD,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAY9C,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAQxC,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAM7C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAI7C,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAMtD,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAMvD,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS;IAKtC,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS;IAKtC,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAIvC,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,EAAE;IAM5B,OAAO,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAI5D,MAAM,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC;IAQ3E,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,KAAK,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC;IAQpE,KAAK,IAAI,IAAI;IAMb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,EACX,SAAS,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,EACjD,OAAO,CAAC,EAAE,mBAAmB,GAC5B,YAAY,CAAC,CAAC,CAAC;IAIlB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,OAAO;CAGpB"}

package/dist/src/data-structures/interval-tree/interval-tree.interface.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Interval Tree interfaces for ZenGrid
+ * Efficiently finds all intervals that overlap with a given interval or point
+ */
+/**
+ * Represents an interval with a start and end
+ */
+export interface Interval {
+    /** Start of the interval (inclusive) */
+    start: number;
+    /** End of the interval (inclusive) */
+    end: number;
+}
+/**
+ * An interval with associated data
+ */
+export interface IntervalData<T> extends Interval {
+    /** User data associated with this interval */
+    data: T;
+    /** Optional unique identifier */
+    id?: string | number;
+}
+/**
+ * Interval Tree interface
+ *
+ * An augmented binary search tree for efficient interval queries.
+ * Each node stores an interval and the maximum endpoint in its subtree.
+ *
+ * Use cases:
+ * - Finding all overlapping time ranges
+ * - Range queries in calendars/schedules
+ * - Collision detection (e.g., overlapping cells in a grid)
+ * - Finding visible rows/columns in virtual scrolling
+ * - Query optimization (index range scans)
+ *
+ * Performance:
+ * - Insert: O(log n) average, O(n) worst case (use Red-Black tree for guaranteed O(log n))
+ * - Delete: O(log n) average
+ * - Search overlapping: O(log n + k) where k = number of results
+ * - Point query: O(log n + k)
+ * - Space: O(n)
+ */
+export interface IIntervalTree<T> {
+    /**
+     * Insert an interval with associated data
+     * @param interval - The interval to insert
+     * @param data - Data to associate with the interval
+     * @returns The inserted interval with data
+     * @complexity O(log n) average
+     */
+    insert(interval: Interval, data: T): IntervalData<T>;
+    /**
+     * Delete an interval by reference
+     * @param intervalData - The interval to delete
+     * @returns true if found and deleted
+     * @complexity O(log n)
+     */
+    delete(intervalData: IntervalData<T>): boolean;
+    /**
+     * Delete an interval by ID
+     * @param id - The ID of the interval to delete
+     * @returns true if found and deleted
+     * @complexity O(n) - requires linear search
+     */
+    deleteById(id: string | number): boolean;
+    /**
+     * Find all intervals that overlap with the given interval
+     * @param interval - The query interval
+     * @returns Array of overlapping intervals
+     * @complexity O(log n + k) where k = number of results
+     */
+    search(interval: Interval): IntervalData<T>[];
+    /**
+     * Find all intervals that contain the given point
+     * @param point - The point to query
+     * @returns Array of intervals containing the point
+     * @complexity O(log n + k) where k = number of results
+     */
+    searchPoint(point: number): IntervalData<T>[];
+    /**
+     * Find all intervals that are completely contained within the given interval
+     * @param interval - The containing interval
+     * @returns Array of contained intervals
+     * @complexity O(n) worst case
+     */
+    searchContained(interval: Interval): IntervalData<T>[];
+    /**
+     * Find all intervals that completely contain the given interval
+     * @param interval - The interval to be contained
+     * @returns Array of containing intervals
+     * @complexity O(n) worst case
+     */
+    searchContaining(interval: Interval): IntervalData<T>[];
+    /**
+     * Find the interval with the earliest start time
+     * @returns The interval or undefined if tree is empty
+     * @complexity O(log n)
+     */
+    findMin(): IntervalData<T> | undefined;
+    /**
+     * Find the interval with the latest end time
+     * @returns The interval or undefined if tree is empty
+     * @complexity O(log n)
+     */
+    findMax(): IntervalData<T> | undefined;
+    /**
+     * Check if any interval overlaps with the given interval
+     * @param interval - The query interval
+     * @complexity O(log n)
+     */
+    hasOverlap(interval: Interval): boolean;
+    /**
+     * Get all intervals in sorted order (by start time)
+     * @returns Array of all intervals sorted by start
+     * @complexity O(n)
+     */
+    inorder(): IntervalData<T>[];
+    /**
+     * Iterate over all intervals in sorted order
+     * @param callback - Function to call for each interval
+     * @complexity O(n)
+     */
+    forEach(callback: (interval: IntervalData<T>) => void): void;
+    /**
+     * Filter intervals by a predicate
+     * @param predicate - Test function
+     * @returns New interval tree with intervals that pass the test
+     * @complexity O(n)
+     */
+    filter(predicate: (interval: IntervalData<T>) => boolean): IIntervalTree<T>;
+    /**
+     * Map intervals to a new interval tree
+     * @param mapper - Transform function for the data
+     * @returns New interval tree with transformed data
+     * @complexity O(n)
+     */
+    map<U>(mapper: (data: T, interval: Interval) => U): IIntervalTree<U>;
+    /**
+     * Clear all intervals
+     * @complexity O(1)
+     */
+    clear(): void;
+    /**
+     * Number of intervals in the tree
+     */
+    readonly size: number;
+    /**
+     * Whether the tree is empty
+     */
+    readonly isEmpty: boolean;
+    /**
+     * Height of the tree (for debugging/analysis)
+     */
+    readonly height: number;
+}
+/**
+ * Options for creating an IntervalTree
+ */
+export interface IntervalTreeOptions {
+    /**
+     * Whether to use a balanced tree (Red-Black tree)
+     * Guarantees O(log n) operations but slightly slower constants
+     * @default false (uses simple BST)
+     */
+    balanced?: boolean;
+    /**
+     * Whether to allow duplicate intervals
+     * @default true
+     */
+    allowDuplicates?: boolean;
+    /**
+     * Custom comparator for intervals
+     * Defaults to comparing by start time, then end time
+     */
+    comparator?: (a: Interval, b: Interval) => number;
+}
+/**
+ * Helper functions for interval operations
+ */
+export declare const IntervalUtils: {
+    /**
+     * Check if two intervals overlap
+     */
+    overlaps(a: Interval, b: Interval): boolean;
+    /**
+     * Check if interval contains a point
+     */
+    contains(interval: Interval, point: number): boolean;
+    /**
+     * Check if interval A contains interval B
+     */
+    containsInterval(a: Interval, b: Interval): boolean;
+    /**
+     * Get the intersection of two intervals
+     * Returns undefined if they don't overlap
+     */
+    intersection(a: Interval, b: Interval): Interval | undefined;
+    /**
+     * Get the union of two overlapping intervals
+     * Returns undefined if they don't overlap
+     */
+    union(a: Interval, b: Interval): Interval | undefined;
+    /**
+     * Merge overlapping intervals
+     */
+    mergeOverlapping(intervals: Interval[]): Interval[];
+    /**
+     * Default comparator: compare by start, then by end
+     */
+    defaultComparator(a: Interval, b: Interval): number;
+};
+//# sourceMappingURL=interval-tree.interface.d.ts.map

package/dist/src/data-structures/interval-tree/interval-tree.interface.d.ts.map

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

package/dist/src/data-structures/interval-tree/node.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Interval Tree Node
+ * Internal node structure for the interval tree
+ */
+import type { IntervalData } from './interval-tree.interface';
+/**
+ * Internal tree node
+ * Each node stores an interval and the maximum endpoint in its subtree
+ */
+export declare class IntervalNode<T> {
+    interval: IntervalData<T>;
+    max: number;
+    left: IntervalNode<T> | null;
+    right: IntervalNode<T> | null;
+    height: number;
+    constructor(interval: IntervalData<T>);
+}
+/**
+ * Get height of a node (0 for null nodes)
+ */
+export declare function getHeight<T>(node: IntervalNode<T> | null): number;
+/**
+ * Update max value for a node based on its interval and children
+ */
+export declare function updateMax<T>(node: IntervalNode<T>): void;
+/**
+ * Update height for a node based on its children
+ */
+export declare function updateHeight<T>(node: IntervalNode<T>): void;
+/**
+ * Find minimum node in a subtree (leftmost node)
+ */
+export declare function findMinNode<T>(node: IntervalNode<T> | null): IntervalNode<T> | null;
+//# sourceMappingURL=node.d.ts.map

package/dist/src/data-structures/interval-tree/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/interval-tree/node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;GAGG;AACH,qBAAa,YAAY,CAAC,CAAC;IACzB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IACpC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IACrC,MAAM,EAAE,MAAM,CAAK;gBAEP,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC;CAItC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,MAAM,CAEjE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAE3D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAMnF"}

package/dist/src/data-structures/interval-tree/operations/balance.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AVL Tree Balancing Operations
+ * Handles tree balancing through rotations
+ */
+import { IntervalNode } from '../node';
+/**
+ * Get balance factor of a node (left height - right height)
+ */
+export declare function getBalanceFactor<T>(node: IntervalNode<T>): number;
+/**
+ * Left rotation
+ * Rotates the node to the left, making its right child the new root
+ *
+ * @param node - Node to rotate
+ * @returns New root after rotation
+ */
+export declare function rotateLeft<T>(node: IntervalNode<T>): IntervalNode<T>;
+/**
+ * Right rotation
+ * Rotates the node to the right, making its left child the new root
+ *
+ * @param node - Node to rotate
+ * @returns New root after rotation
+ */
+export declare function rotateRight<T>(node: IntervalNode<T>): IntervalNode<T>;
+/**
+ * Balance a node using AVL rotations
+ * Performs rotations based on balance factor to maintain AVL property
+ *
+ * @param node - Node to balance
+ * @returns Balanced node (may be a different node after rotation)
+ */
+export declare function balance<T>(node: IntervalNode<T>): IntervalNode<T>;
+//# sourceMappingURL=balance.d.ts.map

package/dist/src/data-structures/interval-tree/operations/balance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balance.d.ts","sourceRoot":"","sources":["../../../../../src/data-structures/interval-tree/operations/balance.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAsC,MAAM,SAAS,CAAC;AAE3E;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAcpE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAcrE;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAwBjE"}

package/dist/src/data-structures/interval-tree/operations/delete.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Delete Operations
+ * Handles deletion of intervals from the tree
+ */
+import type { Interval, IntervalData } from '../interval-tree.interface';
+import { IntervalNode } from '../node';
+/**
+ * Delete an interval from the tree
+ *
+ * @param node - Root of the subtree
+ * @param interval - Interval to delete
+ * @param comparator - Comparator function for intervals
+ * @param balanced - Whether to balance the tree
+ * @param onDelete - Callback when a node is deleted
+ * @returns New root of the subtree (null if deleted)
+ */
+export declare function deleteNode<T>(node: IntervalNode<T> | null, interval: IntervalData<T>, comparator: (a: Interval, b: Interval) => number, balanced: boolean, onDelete?: () => void): IntervalNode<T> | null;
+/**
+ * Find an interval by ID in the tree
+ *
+ * @param node - Root of the subtree
+ * @param id - ID to search for
+ * @returns The interval data if found, null otherwise
+ */
+export declare function findById<T>(node: IntervalNode<T> | null, id: string | number): IntervalData<T> | null;
+//# sourceMappingURL=delete.d.ts.map

package/dist/src/data-structures/interval-tree/operations/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../../src/data-structures/interval-tree/operations/delete.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAwC,MAAM,SAAS,CAAC;AAG7E;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,UAAU,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,EAChD,QAAQ,EAAE,OAAO,EACjB,QAAQ,CAAC,EAAE,MAAM,IAAI,GACpB,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAmDxB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,EAAE,EAAE,MAAM,GAAG,MAAM,GAClB,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAQxB"}

package/dist/src/data-structures/interval-tree/operations/insert.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Insert Operations
+ * Handles insertion of intervals into the tree
+ */
+import type { Interval, IntervalData } from '../interval-tree.interface';
+import { IntervalNode } from '../node';
+/**
+ * Insert an interval into the tree
+ *
+ * @param node - Root of the subtree
+ * @param interval - Interval to insert
+ * @param comparator - Comparator function for intervals
+ * @param allowDuplicates - Whether to allow duplicate intervals
+ * @param balanced - Whether to balance the tree
+ * @param onInsert - Callback called when a new node is inserted
+ * @returns New root of the subtree
+ */
+export declare function insertNode<T>(node: IntervalNode<T> | null, interval: IntervalData<T>, comparator: (a: Interval, b: Interval) => number, allowDuplicates: boolean, balanced: boolean, onInsert?: () => void): IntervalNode<T>;
+//# sourceMappingURL=insert.d.ts.map

package/dist/src/data-structures/interval-tree/operations/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../../src/data-structures/interval-tree/operations/insert.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,YAAY,EAA2B,MAAM,SAAS,CAAC;AAGhE;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,UAAU,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,EAChD,eAAe,EAAE,OAAO,EACxB,QAAQ,EAAE,OAAO,EACjB,QAAQ,CAAC,EAAE,MAAM,IAAI,GACpB,YAAY,CAAC,CAAC,CAAC,CA2CjB"}

package/dist/src/data-structures/interval-tree/operations/search.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Search Operations
+ * Handles various search queries on the interval tree
+ */
+import type { Interval, IntervalData } from '../interval-tree.interface';
+import { IntervalNode } from '../node';
+/**
+ * Find all intervals that overlap with the given interval
+ *
+ * @param node - Root of the subtree
+ * @param interval - Query interval
+ * @param result - Array to collect results
+ */
+export declare function searchOverlap<T>(node: IntervalNode<T> | null, interval: Interval, result: IntervalData<T>[]): void;
+/**
+ * Check if any interval overlaps with the given interval
+ *
+ * @param node - Root of the subtree
+ * @param interval - Query interval
+ * @returns true if any overlap exists
+ */
+export declare function hasOverlap<T>(node: IntervalNode<T> | null, interval: Interval): boolean;
+/**
+ * Find all intervals completely contained within the given interval
+ *
+ * @param node - Root of the subtree
+ * @param interval - Containing interval
+ * @param result - Array to collect results
+ */
+export declare function searchContained<T>(node: IntervalNode<T> | null, interval: Interval, result: IntervalData<T>[]): void;
+/**
+ * Find all intervals that completely contain the given interval
+ *
+ * @param node - Root of the subtree
+ * @param interval - Interval to be contained
+ * @param result - Array to collect results
+ */
+export declare function searchContaining<T>(node: IntervalNode<T> | null, interval: Interval, result: IntervalData<T>[]): void;
+/**
+ * Find the interval with the maximum endpoint
+ *
+ * @param node - Root of the subtree
+ * @returns Interval with the maximum endpoint
+ */
+export declare function findMaxEndpoint<T>(node: IntervalNode<T>): IntervalData<T>;
+//# sourceMappingURL=search.d.ts.map

package/dist/src/data-structures/interval-tree/operations/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/data-structures/interval-tree/operations/search.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAEzE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GACxB,IAAI,CAmBN;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAqBvF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GACxB,IAAI,CAiBN;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GACxB,IAAI,CAiBN;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAmBzE"}

package/dist/src/data-structures/interval-tree/operations/traversal.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Traversal Operations
+ * Handles traversal and iteration over the tree
+ */
+import type { IntervalData } from '../interval-tree.interface';
+import { IntervalNode } from '../node';
+/**
+ * Inorder traversal of the tree
+ *
+ * @param node - Root of the subtree
+ * @param result - Array to collect results
+ */
+export declare function inorder<T>(node: IntervalNode<T> | null, result: IntervalData<T>[]): void;
+/**
+ * Iterate over all intervals in the tree
+ *
+ * @param node - Root of the subtree
+ * @param callback - Function to call for each interval
+ */
+export declare function forEach<T>(node: IntervalNode<T> | null, callback: (interval: IntervalData<T>) => void): void;
+/**
+ * Validate tree structure
+ *
+ * @param node - Root of the subtree
+ * @param comparator - Comparator function for intervals
+ * @returns true if valid
+ */
+export declare function validateNode<T>(node: IntervalNode<T> | null, comparator: (a: IntervalData<T>, b: IntervalData<T>) => number): boolean;
+//# sourceMappingURL=traversal.d.ts.map

package/dist/src/data-structures/interval-tree/operations/traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal.d.ts","sourceRoot":"","sources":["../../../../../src/data-structures/interval-tree/operations/traversal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAKxF;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,QAAQ,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,GAC5C,IAAI,CAKN;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,MAAM,GAC7D,OAAO,CAuBT"}

package/dist/src/data-structures/interval-tree/operations/utilities.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Utility Operations
+ * Static and helper methods for IntervalTree
+ */
+import type { IIntervalTree, Interval, IntervalData, IntervalTreeOptions } from '../interval-tree.interface';
+import type { IntervalNode } from '../node';
+/**
+ * Filter intervals by a predicate
+ */
+export declare function filter<T>(tree: IIntervalTree<T>, root: IntervalNode<T> | null, predicate: (interval: IntervalData<T>) => boolean, options: IntervalTreeOptions): IIntervalTree<T>;
+/**
+ * Map intervals to a new interval tree
+ */
+export declare function map<T, U>(tree: IIntervalTree<T>, root: IntervalNode<T> | null, mapper: (data: T, interval: Interval) => U, options: IntervalTreeOptions): IIntervalTree<U>;
+/**
+ * Get tree structure as string
+ */
+export declare function treeToString<T>(root: IntervalNode<T> | null, balanced: boolean): string;
+/**
+ * Validate tree structure
+ */
+export declare function validate<T>(root: IntervalNode<T> | null, comparator: (a: Interval, b: Interval) => number): boolean;
+/**
+ * Create IntervalTree from array of intervals
+ */
+export declare function fromArray<T>(IntervalTreeClass: new (opts?: IntervalTreeOptions) => IIntervalTree<T>, intervals: Array<{
+    interval: Interval;
+    data: T;
+}>, options?: IntervalTreeOptions): IIntervalTree<T>;
+//# sourceMappingURL=utilities.d.ts.map

package/dist/src/data-structures/interval-tree/operations/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../../../src/data-structures/interval-tree/operations/utilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,SAAS,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,OAAO,EACjD,OAAO,EAAE,mBAAmB,GAC3B,aAAa,CAAC,CAAC,CAAC,CAWlB;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,KAAK,CAAC,EAC1C,OAAO,EAAE,mBAAmB,GAC3B,aAAa,CAAC,CAAC,CAAC,CAUlB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAIvF;AAUD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAC5B,UAAU,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,GAC/C,OAAO,CAET;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,iBAAiB,EAAE,KAAK,IAAI,CAAC,EAAE,mBAAmB,KAAK,aAAa,CAAC,CAAC,CAAC,EACvE,SAAS,EAAE,KAAK,CAAC;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,EACjD,OAAO,CAAC,EAAE,mBAAmB,GAC5B,aAAa,CAAC,CAAC,CAAC,CAMlB"}

package/dist/src/data-structures/lru-cache/index.d.ts

@@ -0,0 +1,3 @@
+export { LRUCache } from './lru-cache';
+export type { ILRUCache, LRUCacheOptions, CacheEntry, CacheStats } from './lru-cache.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/data-structures/lru-cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/lru-cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/data-structures/lru-cache/lru-cache.d.ts

@@ -0,0 +1,134 @@
+import type { ILRUCache, LRUCacheOptions, CacheEntry, CacheStats } from './lru-cache.interface';
+/**
+ * LRU Cache - Least Recently Used Cache
+ *
+ * A cache with automatic eviction of least recently used entries.
+ * Uses doubly-linked list + hash map for O(1) operations.
+ *
+ * **Time Complexity:**
+ * - get: O(1)
+ * - set: O(1)
+ * - delete: O(1)
+ * - has: O(1)
+ * - clear: O(n)
+ *
+ * **Space Complexity:** O(n) where n = number of entries
+ *
+ * **Use Cases in Grid:**
+ * - Cache rendered cells: Avoid re-rendering visible cells
+ * - Cache formula results: =SUM(A1:A1000) computed once
+ * - Cache formatted values: "$1,234.56" cached instead of re-formatting
+ * - Cache API responses: Reduce server requests
+ *
+ * @example Cell Rendering Cache
+ * ```typescript
+ * const cellCache = new LRUCache<string, HTMLElement>({ capacity: 500 });
+ *
+ * function renderCell(row: number, col: number): HTMLElement {
+ *   const key = `${row},${col}`;
+ *   let element = cellCache.get(key);
+ *
+ *   if (!element) {
+ *     element = createCellElement(row, col); // Expensive operation
+ *     cellCache.set(key, element);
+ *   }
+ *
+ *   return element;
+ * }
+ * ```
+ *
+ * @example Formula Cache
+ * ```typescript
+ * const formulaCache = new LRUCache<string, number>({
+ *   capacity: 1000,
+ *   ttl: 5000, // 5 seconds
+ * });
+ *
+ * function evaluateFormula(formula: string): number {
+ *   return formulaCache.get(formula) ?? computeFormula(formula);
+ * }
+ * ```
+ */
+export declare class LRUCache<K, V> implements ILRUCache<K, V> {
+    private capacity;
+    private ttl;
+    private cache;
+    private head;
+    private tail;
+    private onEvict?;
+    private trackStats;
+    private hits;
+    private misses;
+    private evictions;
+    private sets;
+    constructor(options?: LRUCacheOptions);
+    /**
+     * Get a value from the cache
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set a value in the cache
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if a key exists
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a specific entry
+     */
+    delete(key: K): boolean;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get current size
+     */
+    size(): number;
+    /**
+     * Get statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all keys (oldest to newest)
+     */
+    keys(): K[];
+    /**
+     * Get all values (oldest to newest)
+     */
+    values(): V[];
+    /**
+     * Get all entries with metadata
+     */
+    entries(): Array<[K, CacheEntry<V>]>;
+    /**
+     * Peek without updating LRU order
+     */
+    peek(key: K): V | undefined;
+    /**
+     * Resize cache capacity
+     */
+    resize(newCapacity: number): void;
+    /**
+     * Check if a node is expired
+     */
+    private isExpired;
+    /**
+     * Move node to head (most recently used)
+     */
+    private moveToHead;
+    /**
+     * Add node to head
+     */
+    private addToHead;
+    /**
+     * Remove node from list
+     */
+    private removeNode;
+    /**
+     * Evict least recently used entry
+     */
+    private evictLRU;
+}
+//# sourceMappingURL=lru-cache.d.ts.map

package/dist/src/data-structures/lru-cache/lru-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-cache.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/lru-cache/lru-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAiBhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,OAAO,CAAC,CAA6B;IAC7C,OAAO,CAAC,UAAU,CAAU;IAG5B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,IAAI,CAAa;gBAEb,OAAO,GAAE,eAAoB;IAYzC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IA0B1B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAyB3B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAYpB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAUvB;;OAEG;IACH,KAAK,IAAI,IAAI;IAab;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,QAAQ,IAAI,UAAU;IAsBtB;;OAEG;IACH,IAAI,IAAI,CAAC,EAAE;IAYX;;OAEG;IACH,MAAM,IAAI,CAAC,EAAE;IAYb;;OAEG;IACH,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IAoBpC;;OAEG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAa3B;;OAEG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAejC;;OAEG;IACH,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB;;OAEG;IACH,OAAO,CAAC,UAAU;IAclB;;OAEG;IACH,OAAO,CAAC,QAAQ;CAcjB"}