@zengrid/core 1.0.7 → 1.1.0

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

@@ -1,80 +0,0 @@
-/**
- * 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/shared/data-structures/prefix-sum-array/prefix-sum-array.interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefix-sum-array.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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/shared/data-structures/rtree/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * 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/shared/data-structures/rtree/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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/shared/data-structures/rtree/rtree.d.ts

@@ -1,81 +0,0 @@
-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/shared/data-structures/rtree/rtree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rtree.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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/shared/data-structures/rtree/rtree.interface.d.ts

@@ -1,143 +0,0 @@
-/**
- * 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/shared/data-structures/rtree/rtree.interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rtree.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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/shared/data-structures/segment-tree/index.d.ts

@@ -1,4 +0,0 @@
-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/shared/data-structures/segment-tree/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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/shared/data-structures/segment-tree/segment-tree.d.ts

@@ -1,134 +0,0 @@
-/**
- * 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/shared/data-structures/segment-tree/segment-tree.d.ts.map

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

@@ -1,202 +0,0 @@
-/**
- * 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/shared/data-structures/segment-tree/segment-tree.interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"segment-tree.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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"}