@zengrid/shared 1.0.3 → 1.0.4

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/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,EACV,SAAS,EACT,eAAe,EACf,UAAU,EACV,UAAU,GACX,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,EACV,SAAS,EACT,eAAe,EACf,UAAU,EACV,UAAU,EACX,MAAM,uBAAuB,CAAC;AAiB/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -0,0 +1,173 @@
+/**
+ * LRU Cache Interface
+ *
+ * Used for:
+ * - Caching rendered cells to avoid re-rendering
+ * - Caching formula evaluation results
+ * - Caching formatted values (numbers, dates)
+ * - Caching API responses
+ * - Memory-bounded caches with automatic eviction
+ */
+/**
+ * Cache entry metadata
+ */
+export interface CacheEntry<V> {
+    /**
+     * The cached value
+     */
+    value: V;
+    /**
+     * Timestamp when entry was created
+     */
+    createdAt: number;
+    /**
+     * Timestamp when entry was last accessed
+     */
+    lastAccessedAt: number;
+    /**
+     * Number of times this entry has been accessed
+     */
+    accessCount: number;
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    /**
+     * Current number of entries
+     */
+    size: number;
+    /**
+     * Maximum capacity
+     */
+    capacity: number;
+    /**
+     * Total number of get operations
+     */
+    hits: number;
+    /**
+     * Total number of failed get operations
+     */
+    misses: number;
+    /**
+     * Hit rate (hits / (hits + misses))
+     */
+    hitRate: number;
+    /**
+     * Total number of evictions
+     */
+    evictions: number;
+    /**
+     * Total number of set operations
+     */
+    sets: number;
+    /**
+     * Memory usage in bytes (approximate)
+     */
+    memoryBytes: number;
+}
+/**
+ * LRU Cache options
+ */
+export interface LRUCacheOptions {
+    /**
+     * Maximum number of entries
+     * @default 1000
+     */
+    capacity?: number;
+    /**
+     * Time-to-live in milliseconds (0 = infinite)
+     * @default 0
+     */
+    ttl?: number;
+    /**
+     * Callback when an entry is evicted
+     */
+    onEvict?: <K, V>(key: K, value: V) => void;
+    /**
+     * Track access statistics
+     * @default false
+     */
+    trackStats?: boolean;
+}
+/**
+ * LRU Cache interface
+ */
+export interface ILRUCache<K, V> {
+    /**
+     * Get a value from the cache
+     *
+     * @param key - The key to look up
+     * @returns The cached value or undefined if not found or expired
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set a value in the cache
+     *
+     * @param key - The key to store
+     * @param value - The value to cache
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if a key exists in the cache
+     *
+     * @param key - The key to check
+     * @returns True if the key exists and is not expired
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a specific entry
+     *
+     * @param key - The key to delete
+     * @returns True if the entry existed and was deleted
+     */
+    delete(key: K): boolean;
+    /**
+     * Clear all entries from the cache
+     */
+    clear(): void;
+    /**
+     * Get the current size of the cache
+     *
+     * @returns Number of entries
+     */
+    size(): number;
+    /**
+     * Get cache statistics
+     *
+     * @returns Statistics object
+     */
+    getStats(): CacheStats;
+    /**
+     * Get all keys in the cache (in LRU order)
+     *
+     * @returns Array of keys, oldest first
+     */
+    keys(): K[];
+    /**
+     * Get all values in the cache (in LRU order)
+     *
+     * @returns Array of values, oldest first
+     */
+    values(): V[];
+    /**
+     * Get all entries with metadata
+     *
+     * @returns Array of entries with metadata
+     */
+    entries(): Array<[K, CacheEntry<V>]>;
+    /**
+     * Peek at a value without updating LRU order
+     *
+     * @param key - The key to peek at
+     * @returns The cached value or undefined
+     */
+    peek(key: K): V | undefined;
+    /**
+     * Resize the cache capacity
+     *
+     * @param newCapacity - New maximum capacity
+     */
+    resize(newCapacity: number): void;
+}
+//# sourceMappingURL=lru-cache.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lru-cache.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/lru-cache/lru-cache.interface.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,KAAK,EAAE,CAAC,CAAC;IAET;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAE3C;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,CAAC;IAC7B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE3B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAE5B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAErB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAExB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;OAIG;IACH,IAAI,IAAI,MAAM,CAAC;IAEf;;;;OAIG;IACH,QAAQ,IAAI,UAAU,CAAC;IAEvB;;;;OAIG;IACH,IAAI,IAAI,CAAC,EAAE,CAAC;IAEZ;;;;OAIG;IACH,MAAM,IAAI,CAAC,EAAE,CAAC;IAEd;;;;OAIG;IACH,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAErC;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE5B;;;;OAIG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC"}

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

@@ -0,0 +1,6 @@
+/**
+ * Prefix Sum Array - Efficient range queries and offset calculations
+ */
+export { PrefixSumArray } from './prefix-sum-array';
+export type { PrefixSumArray as IPrefixSumArray, PrefixSumArrayOptions, } from './prefix-sum-array.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/prefix-sum-array/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,YAAY,EACV,cAAc,IAAI,eAAe,EACjC,qBAAqB,GACtB,MAAM,8BAA8B,CAAC"}

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

@@ -0,0 +1,63 @@
+import type { PrefixSumArray as IPrefixSumArray, PrefixSumArrayOptions } from './prefix-sum-array.interface';
+/**
+ * PrefixSumArray implementation
+ *
+ * Stores cumulative sums for efficient range queries and offset lookups.
+ * Essential for virtual scrolling with variable row heights.
+ *
+ * @example
+ * ```typescript
+ * // Row heights: [30, 40, 50, 30, 60]
+ * const heights = new PrefixSumArray({ values: [30, 40, 50, 30, 60] });
+ *
+ * // Get offset to row 2 (sum of rows 0 and 1)
+ * heights.getOffset(2); // 70 (30 + 40)
+ *
+ * // Find which row is at scroll offset 100
+ * heights.findIndexAtOffset(100); // 2 (rows 0,1,2 total 120, row 2 starts at 70)
+ *
+ * // Get range sum (rows 1-3)
+ * heights.getRangeSum(1, 4); // 120 (40 + 50 + 30)
+ * ```
+ */
+export declare class PrefixSumArray implements IPrefixSumArray {
+    private values;
+    private sums;
+    constructor(options?: PrefixSumArrayOptions);
+    /**
+     * Build prefix sum array from values
+     * sums[i] = sum of values[0...i-1]
+     * sums[0] = 0 (no elements before index 0)
+     */
+    private build;
+    getOffset(index: number): number;
+    getSumUpTo(index: number): number;
+    getRangeSum(start: number, end: number): number;
+    findIndexAtOffset(offset: number): number;
+    update(index: number, newValue: number): void;
+    getValue(index: number): number;
+    get length(): number;
+    get total(): number;
+    get prefixSums(): ReadonlyArray<number>;
+    /**
+     * Add a new value to the end
+     * @param value - Value to append
+     */
+    push(value: number): void;
+    /**
+     * Remove and return the last value
+     * @returns Removed value or undefined if empty
+     */
+    pop(): number | undefined;
+    /**
+     * Clear all values
+     */
+    clear(): void;
+    /**
+     * Create from array of values
+     * @param values - Array of non-negative numbers
+     * @returns New PrefixSumArray instance
+     */
+    static from(values: number[]): PrefixSumArray;
+}
+//# sourceMappingURL=prefix-sum-array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-sum-array.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/prefix-sum-array/prefix-sum-array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,IAAI,eAAe,EACjC,qBAAqB,EACtB,MAAM,8BAA8B,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,cAAe,YAAW,eAAe;IACpD,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,IAAI,CAAW;gBAEX,OAAO,GAAE,qBAA0B;IAM/C;;;;OAIG;IACH,OAAO,CAAC,KAAK;IASb,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAShC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IASjC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAS/C,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IA6BzC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAoB7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAS/B,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,UAAU,IAAI,aAAa,CAAC,MAAM,CAAC,CAEtC;IAED;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IASzB;;;OAGG;IACH,GAAG,IAAI,MAAM,GAAG,SAAS;IASzB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,cAAc;CAG9C"}