@zengrid/shared 1.0.3 → 1.1.0

package/dist/src/algorithms/sorting/comparators.d.ts

@@ -0,0 +1,126 @@
+import type { Comparator } from '../../types/common';
+import type { NullPosition } from './sorting.interface';
+/**
+ * Options for string comparator
+ */
+export interface StringComparatorOptions {
+    /** Case-insensitive comparison */
+    caseInsensitive?: boolean;
+    /** Use locale-aware comparison */
+    localeCompare?: boolean;
+    /** Locale for comparison (e.g., 'en-US') */
+    locale?: string;
+    /** Where to place null/undefined values */
+    nullPosition?: NullPosition;
+}
+/**
+ * Create a numeric comparator
+ *
+ * @param nullPosition - Where to place null values in sort order
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const numbers = [3, null, 1, undefined, 2];
+ * numbers.sort(numericComparator('last'));
+ * // [1, 2, 3, null, undefined]
+ * ```
+ */
+export declare function numericComparator(nullPosition?: NullPosition): Comparator<any>;
+/**
+ * Create a string comparator
+ *
+ * @param options - Comparator options
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const names = ['Bob', 'alice', 'Charlie'];
+ * names.sort(stringComparator({ caseInsensitive: true }));
+ * // ['alice', 'Bob', 'Charlie']
+ * ```
+ */
+export declare function stringComparator(options?: StringComparatorOptions): Comparator<any>;
+/**
+ * Create a date comparator
+ *
+ * @param nullPosition - Where to place null values
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const dates = [new Date('2023-01-15'), null, new Date('2023-01-01')];
+ * dates.sort(dateComparator('last'));
+ * // [2023-01-01, 2023-01-15, null]
+ * ```
+ */
+export declare function dateComparator(nullPosition?: NullPosition): Comparator<any>;
+/**
+ * Create a boolean comparator (false < true)
+ *
+ * @param nullPosition - Where to place null values
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const values = [true, null, false, true];
+ * values.sort(booleanComparator('last'));
+ * // [false, true, true, null]
+ * ```
+ */
+export declare function booleanComparator(nullPosition?: NullPosition): Comparator<any>;
+/**
+ * Auto-detect type and create appropriate comparator
+ *
+ * @param sampleValues - Sample values to detect type from
+ * @param options - Options for the comparator
+ * @returns Comparator function
+ *
+ * @example
+ * ```typescript
+ * const data = [3, 1, 4, 1, 5];
+ * data.sort(autoComparator(data));
+ * // [1, 1, 3, 4, 5] - numeric comparison
+ * ```
+ */
+export declare function autoComparator(sampleValues: any[], options?: {
+    nullPosition?: NullPosition;
+}): Comparator<any>;
+/**
+ * Reverse a comparator (ascending to descending)
+ *
+ * @param comparator - Comparator to reverse
+ * @returns Reversed comparator
+ *
+ * @example
+ * ```typescript
+ * const desc = reverseComparator(numericComparator());
+ * [1, 2, 3].sort(desc);
+ * // [3, 2, 1]
+ * ```
+ */
+export declare function reverseComparator<T>(comparator: Comparator<T>): Comparator<T>;
+/**
+ * Chain multiple comparators (for multi-column sort)
+ *
+ * @param comparators - Comparators in priority order
+ * @returns Chained comparator
+ *
+ * @example
+ * ```typescript
+ * // Sort by age, then by name
+ * const data = [
+ *   { age: 30, name: 'Bob' },
+ *   { age: 25, name: 'Alice' },
+ *   { age: 30, name: 'Charlie' }
+ * ];
+ *
+ * data.sort(chainComparators(
+ *   (a, b) => a.age - b.age,
+ *   (a, b) => a.name.localeCompare(b.name)
+ * ));
+ * // Alice (25), Bob (30), Charlie (30)
+ * ```
+ */
+export declare function chainComparators<T>(...comparators: Comparator<T>[]): Comparator<T>;
+//# sourceMappingURL=comparators.d.ts.map

package/dist/src/algorithms/sorting/comparators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparators.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/comparators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,kCAAkC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B,kCAAkC;IAClC,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AA2BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,GAAE,YAAqB,GAAG,UAAU,CAAC,GAAG,CAAC,CAatF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAAC,GAAG,CAAC,CAyBvF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,YAAY,GAAE,YAAqB,GAAG,UAAU,CAAC,GAAG,CAAC,CAgBnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,GAAE,YAAqB,GAAG,UAAU,CAAC,GAAG,CAAC,CAQtF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,GAAG,EAAE,EACnB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,YAAY,CAAA;CAAO,GAC5C,UAAU,CAAC,GAAG,CAAC,CAyBjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAE7E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,GAAG,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAUlF"}

package/dist/src/algorithms/sorting/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sorting algorithms and comparators
+ * @packageDocumentation
+ */
+export type { NullPosition, TimsortOptions, SortMetadata } from './sorting.interface';
+export { numericComparator, stringComparator, dateComparator, booleanComparator, autoComparator, reverseComparator, chainComparators, } from './comparators';
+export type { StringComparatorOptions } from './comparators';
+export { timsort, timsortIndices, isSorted } from './timsort';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/algorithms/sorting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEtF,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC"}

package/dist/src/algorithms/sorting/sorting.interface.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Position for null/undefined values in sort order
+ */
+export type NullPosition = 'first' | 'last' | 'natural';
+/**
+ * Options for Timsort algorithm
+ */
+export interface TimsortOptions {
+    /**
+     * Minimum run length for merge sort
+     * Smaller values = more merges, larger values = more insertions
+     * Default: 32 (optimal for most cases)
+     */
+    minRun?: number;
+    /**
+     * Whether to use stable sorting
+     * Default: true
+     */
+    stable?: boolean;
+}
+/**
+ * Result of a sort operation with metadata
+ */
+export interface SortMetadata {
+    /**
+     * Time taken in milliseconds
+     */
+    duration: number;
+    /**
+     * Number of comparisons performed
+     */
+    comparisons?: number;
+    /**
+     * Number of swaps/moves performed
+     */
+    swaps?: number;
+}
+//# sourceMappingURL=sorting.interface.d.ts.map

package/dist/src/algorithms/sorting/sorting.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorting.interface.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/sorting.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/src/algorithms/sorting/timsort-gallop.d.ts

@@ -0,0 +1,21 @@
+import type { Comparator } from '../../types/common';
+/**
+ * Gallop right: Find position where key belongs in array[base:base+len]
+ * Returns offset k where array[base+k-1] < key <= array[base+k]
+ * Uses exponential search followed by binary search
+ */
+export declare function gallopRight<T>(key: T, array: T[], base: number, len: number, hint: number, comparator: Comparator<T>): number;
+/**
+ * Gallop left: Like gallopRight, but finds position where key < array[base+k]
+ */
+export declare function gallopLeft<T>(key: T, array: T[], base: number, len: number, hint: number, comparator: Comparator<T>): number;
+/**
+ * Gallop right in a generic array (for temporary buffer)
+ * Find position where key belongs in arr[base:base+len]
+ */
+export declare function gallopRightInArray<T>(key: T, arr: T[], base: number, len: number, hint: number, comparator: Comparator<T>): number;
+/**
+ * Gallop left in a generic array (for temporary buffer)
+ */
+export declare function gallopLeftInArray<T>(key: T, arr: T[], base: number, len: number, hint: number, comparator: Comparator<T>): number;
+//# sourceMappingURL=timsort-gallop.d.ts.map

package/dist/src/algorithms/sorting/timsort-gallop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timsort-gallop.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/timsort-gallop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,MAAM,CA6CR;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,MAAM,CAwCR;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,CAAC,EAAE,EACR,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,MAAM,CAwCR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,CAAC,EAAE,EACR,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,MAAM,CAwCR"}

package/dist/src/algorithms/sorting/timsort-merge.d.ts

@@ -0,0 +1,6 @@
+import type { TimsortState } from './timsort.interface';
+/**
+ * Merge two adjacent runs with galloping optimization
+ */
+export declare function mergeRuns<T>(state: TimsortState<T>, base1: number, len1: number, base2: number, len2: number): void;
+//# sourceMappingURL=timsort-merge.d.ts.map

package/dist/src/algorithms/sorting/timsort-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timsort-merge.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/timsort-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EACtB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,IAAI,CAgCN"}

package/dist/src/algorithms/sorting/timsort-run.d.ts

@@ -0,0 +1,38 @@
+import type { Comparator } from '../../types/common';
+import type { Run, TimsortState } from './timsort.interface';
+/**
+ * Count length of run starting at lo and reverse if descending
+ * Returns length of run (at least 2 if array has 2+ elements)
+ */
+export declare function countRunAndMakeAscending<T>(array: T[], lo: number, comparator: Comparator<T>): number;
+/**
+ * Reverse array[lo:hi]
+ */
+export declare function reverseRange<T>(array: T[], lo: number, hi: number): void;
+/**
+ * Binary insertion sort - more efficient than regular insertion sort
+ * Sorts array[lo:hi] where array[lo:start] is already sorted
+ */
+export declare function binaryInsertionSort<T>(array: T[], lo: number, hi: number, start: number, comparator: Comparator<T>): void;
+/**
+ * Compute optimal minRun value
+ * Returns a value in range [32, 64] such that n/minRun is close to a power of 2
+ */
+export declare function computeMinRun(n: number): number;
+/**
+ * Push a run onto the pending-run stack
+ */
+export declare function pushRun(runStack: Run[], runBase: number, runLen: number): void;
+/**
+ * Merge runs to maintain stack invariants
+ *
+ * Invariants (from Python's timsort):
+ * 1. runLen[i - 2] > runLen[i - 1] + runLen[i]
+ * 2. runLen[i - 1] > runLen[i]
+ */
+export declare function mergeCollapse<T>(state: TimsortState<T>, mergeAtFn: (state: TimsortState<T>, i: number) => void): void;
+/**
+ * Force merge all runs on the stack
+ */
+export declare function mergeForceCollapse<T>(state: TimsortState<T>, mergeAtFn: (state: TimsortState<T>, i: number) => void): void;
+//# sourceMappingURL=timsort-run.d.ts.map

package/dist/src/algorithms/sorting/timsort-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timsort-run.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/timsort-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAG7D;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,MAAM,CAyBR;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAOxE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,IAAI,CA8BN;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAS/C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,GACrD,IAAI,CAqBN;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,GACrD,IAAI,CAUN"}

package/dist/src/algorithms/sorting/timsort.d.ts

@@ -0,0 +1,55 @@
+import type { Comparator } from '../../types/common';
+import type { TimsortOptions } from './sorting.interface';
+/**
+ * Timsort - Production-grade stable O(n log n) sorting algorithm
+ *
+ * This is a full implementation of Timsort with all optimizations:
+ * - Natural run detection (finds already-sorted sequences)
+ * - Galloping mode (binary search optimization during merges)
+ * - Stack-based merge strategy (maintains merge invariants)
+ * - Reusable temporary buffer (reduces allocations)
+ *
+ * Used by Python, Java, and V8's Array.sort().
+ *
+ * @param array - Array to sort (modified in-place)
+ * @param comparator - Comparison function
+ * @param options - Timsort options
+ * @returns The sorted array
+ *
+ * @complexity
+ * - Time: O(n log n) worst case, O(n) best case (already sorted)
+ * - Space: O(n) for temporary merge buffer
+ */
+export declare function timsort<T>(array: T[], comparator: Comparator<T>, options?: TimsortOptions): T[];
+/**
+ * Sort indices based on values without modifying the values
+ *
+ * @param indices - Array of indices to sort
+ * @param getValue - Function to get value at an index
+ * @param comparator - Comparison function for values
+ * @param options - Timsort options
+ * @returns Sorted array of indices
+ *
+ * @example
+ * ```typescript
+ * const values = ['Charlie', 'Alice', 'Bob'];
+ * const indices = [0, 1, 2];
+ *
+ * const sorted = timsortIndices(
+ *   indices,
+ *   (i) => values[i],
+ *   (a, b) => a.localeCompare(b)
+ * );
+ * // sorted = [1, 2, 0] (Alice, Bob, Charlie)
+ * ```
+ */
+export declare function timsortIndices<T>(indices: number[], getValue: (index: number) => T, comparator: Comparator<T>, options?: TimsortOptions): number[];
+/**
+ * Check if an array is sorted
+ *
+ * @param array - Array to check
+ * @param comparator - Comparison function
+ * @returns True if sorted
+ */
+export declare function isSorted<T>(array: readonly T[], comparator: Comparator<T>): boolean;
+//# sourceMappingURL=timsort.d.ts.map

package/dist/src/algorithms/sorting/timsort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timsort.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/timsort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAY1D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,CAAC,EAAE,EACV,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE,cAAmB,GAC3B,CAAC,EAAE,CAUL;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,OAAO,EAAE,MAAM,EAAE,EACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,EAC9B,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE,cAAmB,GAC3B,MAAM,EAAE,CAOV;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAOnF"}

package/dist/src/algorithms/sorting/timsort.interface.d.ts

@@ -0,0 +1,32 @@
+import type { Comparator } from '../../types/common';
+/**
+ * Minimum gallop threshold
+ * How many times one run must "win" before we switch to galloping mode
+ *
+ * JavaScript Note: Set higher than Python's default (7) due to function call overhead.
+ * Galloping mode has more overhead in JS, so we require more consecutive wins
+ * to justify entering gallop mode.
+ */
+export declare const MIN_GALLOP = 32;
+/**
+ * Minimum merge threshold for stack invariants
+ */
+export declare const MIN_MERGE = 32;
+/**
+ * Run represents a sorted sequence in the array
+ */
+export interface Run {
+    start: number;
+    length: number;
+}
+/**
+ * Internal state shared across Timsort modules
+ */
+export interface TimsortState<T> {
+    array: T[];
+    comparator: Comparator<T>;
+    minGallop: number;
+    runStack: Run[];
+    tmp: T[];
+}
+//# sourceMappingURL=timsort.interface.d.ts.map

package/dist/src/algorithms/sorting/timsort.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timsort.interface.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/sorting/timsort.interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,KAAK,CAAC;AAE7B;;GAEG;AACH,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,GAAG;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,GAAG,EAAE,CAAC,EAAE,CAAC;CACV"}

package/dist/src/data-structures/column-store/column-store.d.ts

@@ -0,0 +1,52 @@
+import type { ColumnStore as IColumnStore, ColumnStoreOptions, ColumnDefinition, AggregateOperation, AggregationResult } from './column-store.interface';
+/**
+ * ColumnStore implementation using typed arrays
+ *
+ * Column-oriented storage for dense grid data.
+ * Uses typed arrays for numeric columns for better performance and memory efficiency.
+ *
+ * @example
+ * ```typescript
+ * const store = new ColumnStore({
+ *   rowCount: 1000,
+ *   columns: [
+ *     { name: 'id', type: 'int32' },
+ *     { name: 'value', type: 'float64' },
+ *     { name: 'label', type: 'string' }
+ *   ]
+ * });
+ *
+ * store.setValue(0, 'id', 1);
+ * store.setValue(0, 'value', 99.5);
+ * store.setValue(0, 'label', 'Item 1');
+ *
+ * const sum = store.aggregate('value', 'sum');
+ * ```
+ */
+export declare class ColumnStore implements IColumnStore {
+    private data;
+    private columnTypes;
+    private rows;
+    private autoGrow;
+    constructor(options?: ColumnStoreOptions);
+    addColumn(definition: ColumnDefinition): void;
+    private createColumn;
+    private fillColumn;
+    removeColumn(columnName: string): boolean;
+    hasColumn(columnName: string): boolean;
+    getValue(row: number, columnName: string): any;
+    setValue(row: number, columnName: string, value: any): void;
+    private coerceValue;
+    getRow(row: number): Record<string, any>;
+    setRow(row: number, values: Record<string, any>): void;
+    getColumn(columnName: string): any[];
+    setColumn(columnName: string, values: any[]): void;
+    aggregate(columnName: string, operation: AggregateOperation): AggregationResult;
+    addRows(count: number): void;
+    clear(): void;
+    private ensureRowExists;
+    get rowCount(): number;
+    get columnCount(): number;
+    get columns(): ReadonlyArray<string>;
+}
+//# sourceMappingURL=column-store.d.ts.map

package/dist/src/data-structures/column-store/column-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-store.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/column-store/column-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,IAAI,YAAY,EAC3B,kBAAkB,EAClB,gBAAgB,EAEhB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,WAAY,YAAW,YAAY;IAC9C,OAAO,CAAC,IAAI,CAAiD;IAC7D,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,QAAQ,CAAU;gBAEd,OAAO,GAAE,kBAAuB;IAc5C,SAAS,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAgB7C,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,UAAU;IAUlB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAQzC,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAItC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG;IAW9C,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAY3D,OAAO,CAAC,WAAW;IA8BnB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAUxC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAUtD,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,EAAE;IASpC,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI;IAiBlD,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,GAAG,iBAAiB;IA6F/E,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA2B5B,KAAK,IAAI,IAAI;IAYb,OAAO,CAAC,eAAe;IAcvB,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAEnC;CACF"}

package/dist/src/data-structures/column-store/column-store.interface.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Column Store interfaces for ZenGrid
+ * Column-oriented storage using typed arrays for performance
+ */
+/**
+ * Supported column data types
+ */
+export type ColumnType = 'int32' | 'float64' | 'string' | 'boolean';
+/**
+ * Aggregation operations
+ */
+export type AggregateOperation = 'sum' | 'avg' | 'min' | 'max' | 'count';
+/**
+ * Column definition
+ */
+export interface ColumnDefinition {
+    /** Column name/identifier */
+    name: string;
+    /** Data type */
+    type: ColumnType;
+    /** Default value for new rows */
+    defaultValue?: any;
+}
+/**
+ * Aggregation result
+ */
+export interface AggregationResult {
+    operation: AggregateOperation;
+    column: string;
+    value: number;
+    count: number;
+}
+/**
+ * Column Store interface
+ *
+ * Column-oriented storage for dense grid data.
+ * Uses typed arrays (Float64Array, Int32Array) for numeric columns for better performance.
+ */
+export interface ColumnStore {
+    /**
+     * Add a new column
+     * @param definition - Column definition
+     * @complexity O(n) where n = rowCount
+     */
+    addColumn(definition: ColumnDefinition): void;
+    /**
+     * Remove a column
+     * @param columnName - Column to remove
+     * @returns true if column existed and was removed
+     * @complexity O(1)
+     */
+    removeColumn(columnName: string): boolean;
+    /**
+     * Check if column exists
+     * @param columnName - Column name
+     * @complexity O(1)
+     */
+    hasColumn(columnName: string): boolean;
+    /**
+     * Get value at (row, column)
+     * @param row - Row index
+     * @param columnName - Column name
+     * @returns Value or undefined if out of bounds
+     * @complexity O(1)
+     */
+    getValue(row: number, columnName: string): any;
+    /**
+     * Set value at (row, column)
+     * @param row - Row index
+     * @param columnName - Column name
+     * @param value - Value to set
+     * @complexity O(1)
+     */
+    setValue(row: number, columnName: string, value: any): void;
+    /**
+     * Get entire row as object
+     * @param row - Row index
+     * @returns Object with column names as keys
+     * @complexity O(c) where c = number of columns
+     */
+    getRow(row: number): Record<string, any>;
+    /**
+     * Set multiple values in a row
+     * @param row - Row index
+     * @param values - Object with column names and values
+     * @complexity O(k) where k = Object.keys(values).length
+     */
+    setRow(row: number, values: Record<string, any>): void;
+    /**
+     * Get entire column as array
+     * @param columnName - Column name
+     * @returns Copy of column data
+     * @complexity O(n) where n = rowCount
+     */
+    getColumn(columnName: string): any[];
+    /**
+     * Set entire column
+     * @param columnName - Column name
+     * @param values - Array of values (length must match rowCount)
+     * @complexity O(n)
+     */
+    setColumn(columnName: string, values: any[]): void;
+    /**
+     * Perform aggregation on a column
+     * @param columnName - Column to aggregate
+     * @param operation - Aggregation operation
+     * @returns Aggregation result
+     * @complexity O(n)
+     */
+    aggregate(columnName: string, operation: AggregateOperation): AggregationResult;
+    /**
+     * Add new rows (expand capacity)
+     * @param count - Number of rows to add
+     * @complexity O(n * c) where n = count, c = columns
+     */
+    addRows(count: number): void;
+    /**
+     * Clear all data but keep column definitions
+     * @complexity O(c) where c = number of columns
+     */
+    clear(): void;
+    /**
+     * Number of rows
+     */
+    readonly rowCount: number;
+    /**
+     * Number of columns
+     */
+    readonly columnCount: number;
+    /**
+     * Column names
+     */
+    readonly columns: ReadonlyArray<string>;
+}
+/**
+ * Options for creating a ColumnStore
+ */
+export interface ColumnStoreOptions {
+    /**
+     * Initial row count
+     * @default 0
+     */
+    rowCount?: number;
+    /**
+     * Column definitions
+     * @default []
+     */
+    columns?: ColumnDefinition[];
+    /**
+     * Whether to grow automatically when accessing rows beyond rowCount
+     * @default false
+     */
+    autoGrow?: boolean;
+}
+//# sourceMappingURL=column-store.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column-store.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/column-store/column-store.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,iCAAiC;IACjC,YAAY,CAAC,EAAE,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAE9C;;;;;OAKG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAE1C;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAEvC;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC;IAE/C;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI,CAAC;IAE5D;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEzC;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IAEvD;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;IAErC;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAEnD;;;;;;OAMG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,GAAG,iBAAiB,CAAC;IAEhF;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE7B;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/dist/src/data-structures/column-store/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Column Store - Column-oriented storage with typed arrays
+ */
+export { ColumnStore } from './column-store';
+export type { ColumnStore as IColumnStore, ColumnStoreOptions, ColumnDefinition, ColumnType, AggregateOperation, AggregationResult, } from './column-store.interface';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/column-store/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EACV,WAAW,IAAI,YAAY,EAC3B,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC"}

package/dist/src/data-structures/command-stack/command-stack.d.ts

@@ -0,0 +1,61 @@
+import type { ICommand, ICommandStack, ICommandStackOptions } from './command-stack.interface';
+/**
+ * Implementation of a command stack for undo/redo functionality.
+ *
+ * Time Complexity:
+ * - execute: O(1)
+ * - undo: O(1)
+ * - redo: O(1)
+ * - canUndo/canRedo: O(1)
+ * - clear: O(1)
+ *
+ * Space Complexity: O(n) where n is the number of commands (up to maxSize)
+ */
+export declare class CommandStack implements ICommandStack {
+    private undoStack;
+    private redoStack;
+    private readonly maxSize;
+    constructor(options?: ICommandStackOptions);
+    /**
+     * Executes a command and adds it to the undo stack.
+     * Clears the redo stack as new actions invalidate the redo history.
+     */
+    execute(command: ICommand): void;
+    /**
+     * Undoes the last executed command.
+     */
+    undo(): boolean;
+    /**
+     * Redoes the last undone command.
+     */
+    redo(): boolean;
+    /**
+     * Checks if there are commands that can be undone.
+     */
+    canUndo(): boolean;
+    /**
+     * Checks if there are commands that can be redone.
+     */
+    canRedo(): boolean;
+    /**
+     * Clears all commands from both stacks.
+     */
+    clear(): void;
+    /**
+     * Gets the number of commands in the undo stack.
+     */
+    getUndoCount(): number;
+    /**
+     * Gets the number of commands in the redo stack.
+     */
+    getRedoCount(): number;
+    /**
+     * Gets the descriptions of all commands in the undo stack.
+     */
+    getUndoHistory(): string[];
+    /**
+     * Gets the descriptions of all commands in the redo stack.
+     */
+    getRedoHistory(): string[];
+}
+//# sourceMappingURL=command-stack.d.ts.map

package/dist/src/data-structures/command-stack/command-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-stack.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/command-stack/command-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAE/F;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,GAAE,oBAAyB;IAQ9C;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAehC;;OAEG;IACH,IAAI,IAAI,OAAO;IAYf;;OAEG;IACH,IAAI,IAAI,OAAO;IAmBf;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;IAI1B;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;CAG3B"}