@zengrid/shared 1.0.3 → 1.0.4

package/dist/src/data-structures/prefix-sum-array/prefix-sum-array.interface.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Prefix Sum Array interfaces for ZenGrid
+ * Used for efficient range queries and offset calculations
+ */
+/**
+ * Prefix Sum Array for cumulative calculations
+ *
+ * Useful for:
+ * - Variable row heights in virtual scrolling
+ * - Finding element at specific offset (O(log n) with binary search)
+ * - Range sum queries
+ */
+export interface PrefixSumArray {
+    /**
+     * Get cumulative sum up to (but not including) index
+     * @param index - Index to query
+     * @returns Sum of values[0] through values[index-1]
+     * @complexity O(1)
+     */
+    getOffset(index: number): number;
+    /**
+     * Get cumulative sum up to and including index
+     * @param index - Index to query
+     * @returns Sum of values[0] through values[index]
+     * @complexity O(1)
+     */
+    getSumUpTo(index: number): number;
+    /**
+     * Get sum of range [start, end)
+     * @param start - Start index (inclusive)
+     * @param end - End index (exclusive)
+     * @returns Sum of values[start] through values[end-1]
+     * @complexity O(1)
+     */
+    getRangeSum(start: number, end: number): number;
+    /**
+     * Find index where cumulative sum >= target offset
+     * Uses binary search internally
+     * @param offset - Target cumulative value
+     * @returns Index where cumulative sum >= offset
+     * @complexity O(log n)
+     */
+    findIndexAtOffset(offset: number): number;
+    /**
+     * Update value at index and rebuild prefix sums
+     * @param index - Index to update
+     * @param newValue - New value
+     * @complexity O(n) - requires rebuilding from index onward
+     */
+    update(index: number, newValue: number): void;
+    /**
+     * Get original value at index (not cumulative)
+     * @param index - Index to query
+     * @returns Original value
+     * @complexity O(1)
+     */
+    getValue(index: number): number;
+    /**
+     * Total number of elements
+     */
+    readonly length: number;
+    /**
+     * Total sum of all values
+     */
+    readonly total: number;
+    /**
+     * Get underlying prefix sum array (for debugging)
+     */
+    readonly prefixSums: ReadonlyArray<number>;
+}
+/**
+ * Options for creating a PrefixSumArray
+ */
+export interface PrefixSumArrayOptions {
+    /**
+     * Initial values to build prefix sums from
+     */
+    values?: number[];
+}
+//# sourceMappingURL=prefix-sum-array.interface.d.ts.map

package/dist/src/data-structures/prefix-sum-array/prefix-sum-array.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-sum-array.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/prefix-sum-array/prefix-sum-array.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAElC;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAEhD;;;;;;OAMG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAE1C;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAEhC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB"}

package/dist/src/data-structures/rtree/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * R-Tree (Spatial Index) data structure
+ *
+ * Used for efficient spatial queries, hit testing, and range searching.
+ */
+export { RTree } from './rtree';
+export type { IRTree, Rectangle, RTreeData, RTreeOptions, RTreeSearchResult, RTreeStats, } from './rtree.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/rtree/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EACV,MAAM,EACN,SAAS,EACT,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,UAAU,GACX,MAAM,mBAAmB,CAAC"}

package/dist/src/data-structures/rtree/rtree.d.ts

@@ -0,0 +1,81 @@
+import type { IRTree, Rectangle, RTreeOptions, RTreeSearchResult, RTreeStats } from './rtree.interface';
+/**
+ * R-Tree - Spatial Index Data Structure
+ *
+ * An R-Tree is a tree data structure for indexing spatial data.
+ * It groups nearby objects and represents them with their minimum bounding rectangle (MBR).
+ *
+ * **Time Complexity:**
+ * - Insert: O(log n) average, O(n) worst case
+ * - Search: O(log n + k) where k = number of results
+ * - Delete: O(log n) average
+ *
+ * **Space Complexity:** O(n)
+ *
+ * **Use Cases in Grid:**
+ * - Hit testing: Find cell at mouse coordinates - O(log n)
+ * - Range queries: Find all cells in viewport - O(log n + k)
+ * - Merged cells: Detect overlapping cell ranges
+ * - Selection optimization: Quickly find cells in selection rect
+ */
+export declare class RTree<T = any> implements IRTree<T> {
+    private root;
+    private options;
+    private itemCount;
+    constructor(options?: RTreeOptions);
+    /**
+     * Insert an item into the R-Tree
+     */
+    insert(rect: Rectangle, data: T): void;
+    /**
+     * Search for items intersecting a rectangle
+     */
+    search(rect: Rectangle): RTreeSearchResult<T>[];
+    /**
+     * Search for items at a specific point
+     */
+    searchAtPoint(x: number, y: number): RTreeSearchResult<T>[];
+    /**
+     * Find nearest neighbors to a point
+     */
+    nearest(x: number, y: number, maxResults?: number, maxDistance?: number): RTreeSearchResult<T>[];
+    /**
+     * Remove an item from the tree
+     */
+    remove(rect: Rectangle, data?: T): boolean;
+    /**
+     * Clear all items from the tree
+     */
+    clear(): void;
+    /**
+     * Get all items in the tree
+     */
+    all(): RTreeSearchResult<T>[];
+    /**
+     * Check if the tree is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Get statistics about the tree
+     */
+    getStats(): RTreeStats;
+    /**
+     * Rebuild the tree for better performance
+     */
+    rebuild(): void;
+    private createNode;
+    private isNode;
+    private calcBBox;
+    private extendBBox;
+    private intersects;
+    private rectangleDistanceTo;
+    private searchNode;
+    private insertItem;
+    private enlargementNeeded;
+    private area;
+    private split;
+    private findItem;
+    private rectanglesEqual;
+    private getAllItems;
+}
+//# sourceMappingURL=rtree.d.ts.map

package/dist/src/data-structures/rtree/rtree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtree.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/rtree/rtree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,SAAS,EAET,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACX,MAAM,mBAAmB,CAAC;AAmB3B;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,KAAK,CAAC,CAAC,GAAG,GAAG,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAC9C,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,SAAS,CAAa;gBAElB,OAAO,GAAE,YAAiB;IAStC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAMtC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE;IAQ/C;;OAEG;IACH,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE;IAS3D;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAE,MAAU,EAAE,WAAW,GAAE,MAAiB,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE;IAuD7G;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,OAAO;IAmC1C;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,GAAG,IAAI,iBAAiB,CAAC,CAAC,CAAC,EAAE;IAQ7B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,QAAQ,IAAI,UAAU;IAuBtB;;OAEG;IACH,OAAO,IAAI,IAAI;IAWf,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,UAAU;IA6DlB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,KAAK;IA8Bb,OAAO,CAAC,QAAQ;IAgChB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,WAAW;CAcpB"}

package/dist/src/data-structures/rtree/rtree.interface.d.ts

@@ -0,0 +1,143 @@
+/**
+ * R-Tree (Spatial Index) Interface
+ *
+ * Used for:
+ * - Efficient spatial queries (hit testing, range queries)
+ * - Finding cells at point (x, y)
+ * - Finding cells in rectangular region
+ * - Merged cell detection
+ * - Selection range optimization
+ */
+/**
+ * 2D Rectangle (Axis-Aligned Bounding Box)
+ */
+export interface Rectangle {
+    /**
+     * Minimum X coordinate (left edge)
+     */
+    minX: number;
+    /**
+     * Minimum Y coordinate (top edge)
+     */
+    minY: number;
+    /**
+     * Maximum X coordinate (right edge)
+     */
+    maxX: number;
+    /**
+     * Maximum Y coordinate (bottom edge)
+     */
+    maxY: number;
+}
+/**
+ * R-Tree node data
+ */
+export interface RTreeData<T = any> {
+    /**
+     * The bounding rectangle
+     */
+    rect: Rectangle;
+    /**
+     * Associated data
+     */
+    data: T;
+}
+/**
+ * R-Tree search result
+ */
+export interface RTreeSearchResult<T = any> {
+    /**
+     * The bounding rectangle
+     */
+    rect: Rectangle;
+    /**
+     * Associated data
+     */
+    data: T;
+    /**
+     * Distance from query point (if applicable)
+     */
+    distance?: number;
+}
+/**
+ * R-Tree configuration options
+ */
+export interface RTreeOptions {
+    /**
+     * Maximum entries per node
+     * @default 9
+     */
+    maxEntries?: number;
+    /**
+     * Minimum entries per node
+     * @default Math.ceil(maxEntries * 0.4)
+     */
+    minEntries?: number;
+}
+/**
+ * R-Tree statistics
+ */
+export interface RTreeStats {
+    /**
+     * Total number of items in the tree
+     */
+    size: number;
+    /**
+     * Height of the tree
+     */
+    height: number;
+    /**
+     * Total number of nodes
+     */
+    nodeCount: number;
+    /**
+     * Bounding box of all items
+     */
+    bounds: Rectangle | null;
+}
+/**
+ * R-Tree interface
+ */
+export interface IRTree<T = any> {
+    /**
+     * Insert an item into the tree
+     */
+    insert(rect: Rectangle, data: T): void;
+    /**
+     * Search for items intersecting a rectangle
+     */
+    search(rect: Rectangle): RTreeSearchResult<T>[];
+    /**
+     * Search for items at a specific point
+     */
+    searchAtPoint(x: number, y: number): RTreeSearchResult<T>[];
+    /**
+     * Find nearest neighbors to a point
+     */
+    nearest(x: number, y: number, maxResults?: number, maxDistance?: number): RTreeSearchResult<T>[];
+    /**
+     * Remove an item from the tree
+     */
+    remove(rect: Rectangle, data?: T): boolean;
+    /**
+     * Remove all items from the tree
+     */
+    clear(): void;
+    /**
+     * Get all items in the tree
+     */
+    all(): RTreeSearchResult<T>[];
+    /**
+     * Check if the tree is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Get statistics about the tree
+     */
+    getStats(): RTreeStats;
+    /**
+     * Rebuild the tree (optimize structure)
+     */
+    rebuild(): void;
+}
+//# sourceMappingURL=rtree.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rtree.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/rtree/rtree.interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,GAAG;IAChC;;OAEG;IACH,IAAI,EAAE,SAAS,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;CACT;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,GAAG;IACxC;;OAEG;IACH,IAAI,EAAE,SAAS,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IAER;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,GAAG,GAAG;IAC7B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IAEvC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;IAEhD;;OAEG;IACH,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;IAE5D;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;IAEjG;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC;IAE3C;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,GAAG,IAAI,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;IAE9B;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;IAEnB;;OAEG;IACH,QAAQ,IAAI,UAAU,CAAC;IAEvB;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/src/data-structures/segment-tree/index.d.ts

@@ -0,0 +1,4 @@
+export { SegmentTree } from './segment-tree';
+export type { ISegmentTree, SegmentTreeOptions, AggregateFunction, } from './segment-tree.interface';
+export { Aggregations, SegmentTreeUtils, AggregationType } from './segment-tree.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/src/data-structures/segment-tree/segment-tree.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Segment Tree implementation
+ * Efficient range query and update data structure
+ */
+import type { ISegmentTree, SegmentTreeOptions, AggregateFunction } from './segment-tree.interface';
+import { AggregationType } from './segment-tree.interface';
+/**
+ * Segment Tree - Efficient range queries and updates
+ *
+ * Implementation:
+ * - Array-based complete binary tree
+ * - Each node stores the aggregate of its range
+ * - Supports lazy propagation for efficient range updates
+ * - Generic type T for flexibility (numbers, objects, etc.)
+ *
+ * @example
+ * ```typescript
+ * // Sum queries
+ * const tree = new SegmentTree({ values: [1, 3, 5, 7, 9, 11], type: 'sum' });
+ * tree.query(1, 3); // Returns 15 (3 + 5 + 7)
+ * tree.update(1, 10); // Change 3 to 10
+ * tree.query(1, 3); // Returns 22 (10 + 5 + 7)
+ *
+ * // Min queries
+ * const minTree = new SegmentTree({ values: [5, 2, 8, 1, 9], type: 'min' });
+ * minTree.query(0, 4); // Returns 1
+ * minTree.update(3, 10);
+ * minTree.query(0, 4); // Returns 2
+ *
+ * // Status bar aggregation example
+ * const cellValues = [100, 200, 150, 300, 250];
+ * const sumTree = new SegmentTree({ values: cellValues, type: 'sum' });
+ * sumTree.query(1, 3); // Sum of cells 1-3: 650
+ * ```
+ */
+export declare class SegmentTree<T> implements ISegmentTree<T> {
+    private tree;
+    private lazy;
+    private arr;
+    private n;
+    private aggregate;
+    private identityValue;
+    private useLazy;
+    private _type;
+    constructor(options: SegmentTreeOptions<T>);
+    /**
+     * Get aggregation configuration
+     */
+    private getAggregationConfig;
+    /**
+     * Build the segment tree recursively
+     */
+    private buildTree;
+    /**
+     * Push lazy updates down to children
+     */
+    private pushDown;
+    /**
+     * Apply update to a node value
+     * For SUM: multiply update by range size
+     * For MIN/MAX: just use the update value
+     */
+    private applyUpdate;
+    /**
+     * Query range [left, right]
+     */
+    query(left: number, right: number): T;
+    /**
+     * Recursive query helper
+     */
+    private queryTree;
+    /**
+     * Update a single element
+     */
+    update(index: number, value: T): void;
+    /**
+     * Recursive update helper
+     */
+    private updateTree;
+    /**
+     * Update a range [left, right]
+     */
+    rangeUpdate(left: number, right: number, value: T): void;
+    /**
+     * Lazy range update helper
+     */
+    private rangeUpdateLazy;
+    /**
+     * Get value at index
+     */
+    get(index: number): T;
+    /**
+     * Build tree from new array
+     */
+    build(arr: T[]): void;
+    /**
+     * Convert tree to array
+     */
+    toArray(): T[];
+    /**
+     * Find first index where predicate is true
+     */
+    findFirst(left: number, predicate: (value: T) => boolean): number;
+    /**
+     * Get size of array
+     */
+    get size(): number;
+    /**
+     * Get total aggregated value
+     */
+    get total(): T;
+    /**
+     * Get aggregation type
+     */
+    get aggregationType(): AggregationType;
+    /**
+     * Create SegmentTree from array
+     */
+    static from<T>(values: T[], type?: AggregationType): SegmentTree<T>;
+    /**
+     * Create custom SegmentTree
+     */
+    static custom<T>(values: T[], aggregate: AggregateFunction<T>, identity: T): SegmentTree<T>;
+    /**
+     * Debug: Print tree structure
+     */
+    toString(): string;
+    /**
+     * Debug: Validate tree structure
+     */
+    validate(): boolean;
+    private validateNode;
+}
+//# sourceMappingURL=segment-tree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment-tree.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/segment-tree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAkC,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,KAAK,CAAkB;gBAEnB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAgC1C;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;OAEG;IACH,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IA8BhB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAYnB;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC;IAcrC;;OAEG;IACH,OAAO,CAAC,SAAS;IAiCjB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IASrC;;OAEG;IACH,OAAO,CAAC,UAAU;IA+BlB;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAkBxD;;OAEG;IACH,OAAO,CAAC,eAAe;IAqCvB;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IAQrB;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI;IAarB;;OAEG;IACH,OAAO,IAAI,CAAC,EAAE;IAQd;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM;IAUjE;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAKb;IAED;;OAEG;IACH,IAAI,eAAe,IAAI,eAAe,CAErC;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,IAAI,GAAE,eAAqC,GAAG,WAAW,CAAC,CAAC,CAAC;IAIxF;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EACb,MAAM,EAAE,CAAC,EAAE,EACX,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,QAAQ,EAAE,CAAC,GACV,WAAW,CAAC,CAAC,CAAC;IASjB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB,OAAO,CAAC,YAAY;CA2BrB"}

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

@@ -0,0 +1,202 @@
+/**
+ * Segment Tree interfaces for ZenGrid
+ * Efficiently handles range queries and updates for aggregation operations
+ */
+/**
+ * Aggregation function type
+ * Combines two values into one
+ */
+export type AggregateFunction<T> = (a: T, b: T) => T;
+/**
+ * Common aggregation operations
+ */
+export declare enum AggregationType {
+    SUM = "sum",
+    MIN = "min",
+    MAX = "max",
+    GCD = "gcd",
+    LCM = "lcm",
+    PRODUCT = "product",
+    CUSTOM = "custom"
+}
+/**
+ * Segment Tree interface
+ *
+ * A tree data structure for storing intervals or segments, allowing for efficient
+ * querying and updating of array elements over ranges.
+ *
+ * Use cases:
+ * - Status bar aggregations (sum, min, max of selected cells)
+ * - Range statistics (average, count, sum over a range)
+ * - Dynamic cumulative calculations
+ * - Range minimum/maximum queries
+ * - Frequent range updates with queries
+ *
+ * Performance:
+ * - Build: O(n)
+ * - Query: O(log n)
+ * - Update (point): O(log n)
+ * - Update (range): O(log n) with lazy propagation
+ * - Space: O(4n) = O(n)
+ */
+export interface ISegmentTree<T> {
+    /**
+     * Query the aggregated value over a range [left, right]
+     * @param left - Start index (inclusive)
+     * @param right - End index (inclusive)
+     * @returns Aggregated value over the range
+     * @complexity O(log n)
+     */
+    query(left: number, right: number): T;
+    /**
+     * Update a single element at index
+     * @param index - Index to update
+     * @param value - New value
+     * @complexity O(log n)
+     */
+    update(index: number, value: T): void;
+    /**
+     * Update a range of elements [left, right]
+     * @param left - Start index (inclusive)
+     * @param right - End index (inclusive)
+     * @param value - Value to apply to the range
+     * @complexity O(log n) with lazy propagation
+     */
+    rangeUpdate(left: number, right: number, value: T): void;
+    /**
+     * Get the value at a specific index
+     * @param index - Index to query
+     * @returns Value at index
+     * @complexity O(log n) or O(1) depending on implementation
+     */
+    get(index: number): T;
+    /**
+     * Build or rebuild the tree from new array
+     * @param arr - New array of values
+     * @complexity O(n)
+     */
+    build(arr: T[]): void;
+    /**
+     * Get the entire array
+     * @returns Current array values
+     * @complexity O(n)
+     */
+    toArray(): T[];
+    /**
+     * Find the first index where the aggregate from start meets a condition
+     * Useful for binary search on aggregates
+     * @param left - Start index
+     * @param predicate - Condition to test
+     * @returns Index or -1 if not found
+     * @complexity O(log^2 n)
+     */
+    findFirst(left: number, predicate: (value: T) => boolean): number;
+    /**
+     * Get the size of the underlying array
+     */
+    readonly size: number;
+    /**
+     * Get the total aggregated value (entire array)
+     */
+    readonly total: T;
+    /**
+     * Get the aggregation type
+     */
+    readonly aggregationType: AggregationType;
+}
+/**
+ * Options for creating a Segment Tree
+ */
+export interface SegmentTreeOptions<T> {
+    /**
+     * Initial array of values
+     */
+    values?: T[];
+    /**
+     * Aggregation type (for common operations)
+     * If CUSTOM is specified, must provide customAggregate function
+     */
+    type?: AggregationType;
+    /**
+     * Custom aggregation function
+     * Required if type is CUSTOM
+     */
+    customAggregate?: AggregateFunction<T>;
+    /**
+     * Identity value for the aggregation
+     * - For SUM: 0
+     * - For MIN: Infinity
+     * - For MAX: -Infinity
+     * - For PRODUCT: 1
+     * Must be provided for CUSTOM type
+     */
+    identity?: T;
+    /**
+     * Whether to use lazy propagation for range updates
+     * @default true
+     */
+    lazy?: boolean;
+}
+/**
+ * Predefined aggregation functions and identities
+ */
+export declare const Aggregations: {
+    sum: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    min: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    max: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    gcd: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    lcm: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    product: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+};
+/**
+ * Helper functions for segment tree operations
+ */
+export declare const SegmentTreeUtils: {
+    /**
+     * Calculate the tree size needed for array of size n
+     */
+    getTreeSize(n: number): number;
+    /**
+     * Check if index is valid
+     */
+    isValidIndex(index: number, size: number): boolean;
+    /**
+     * Check if range is valid
+     */
+    isValidRange(left: number, right: number, size: number): boolean;
+    /**
+     * Get parent index in tree
+     */
+    parent(index: number): number;
+    /**
+     * Get left child index in tree
+     */
+    leftChild(index: number): number;
+    /**
+     * Get right child index in tree
+     */
+    rightChild(index: number): number;
+    /**
+     * Get the middle point of a range
+     */
+    mid(left: number, right: number): number;
+};
+//# sourceMappingURL=segment-tree.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment-tree.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/segment-tree.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAErD;;GAEG;AACH,oBAAY,eAAe;IACzB,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,MAAM,WAAW;CAClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEtC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAEzD;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEtB;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC;IAEtB;;;;OAIG;IACH,OAAO,IAAI,CAAC,EAAE,CAAC;IAEf;;;;;;;OAOG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC;IAElE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IAEvB;;;OAGG;IACH,eAAe,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAEvC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;gBAEb,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAWjB,MAAM,KAAK,MAAM;;;;gBAOjB,MAAM,KAAK,MAAM;;;CAG5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;mBACY,MAAM,GAAG,MAAM;IAK9B;;OAEG;wBACiB,MAAM,QAAQ,MAAM,GAAG,OAAO;IAIlD;;OAEG;uBACgB,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,OAAO;IAQhE;;OAEG;kBACW,MAAM,GAAG,MAAM;IAI7B;;OAEG;qBACc,MAAM,GAAG,MAAM;IAIhC;;OAEG;sBACe,MAAM,GAAG,MAAM;IAIjC;;OAEG;cACO,MAAM,SAAS,MAAM,GAAG,MAAM;CAGzC,CAAC"}

package/dist/src/data-structures/skip-list/index.d.ts

@@ -0,0 +1,4 @@
+export { SkipList } from './skip-list';
+export type { ISkipList, SkipListNode, SkipListOptions, RangeResult, SkipListStats, } from './skip-list.interface';
+export { defaultComparator, SkipListUtils } from './skip-list.interface';
+//# sourceMappingURL=index.d.ts.map