@zengrid/core 1.0.1 → 1.0.4

package/dist/src/shared/algorithms/graph/graph.interface.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Graph algorithm interfaces and types
+ */
+/**
+ * Generic graph representation (adjacency list)
+ */
+export type AdjacencyList<T = any> = Map<T, Set<T>>;
+/**
+ * Weighted edge
+ */
+export interface WeightedEdge<T> {
+    from: T;
+    to: T;
+    weight: number;
+}
+/**
+ * DFS traversal options
+ */
+export interface DFSOptions<T> {
+    /**
+     * Callback when visiting a node
+     */
+    onVisit?: (node: T, depth: number) => void;
+    /**
+     * Callback when backtracking from a node
+     */
+    onBacktrack?: (node: T) => void;
+    /**
+     * Callback when detecting a back edge (cycle)
+     */
+    onBackEdge?: (from: T, to: T) => void;
+}
+/**
+ * BFS traversal options
+ */
+export interface BFSOptions<T> {
+    /**
+     * Callback when visiting a node
+     */
+    onVisit?: (node: T, level: number) => void;
+    /**
+     * Maximum depth to traverse
+     */
+    maxDepth?: number;
+}
+/**
+ * Path result
+ */
+export interface PathResult<T> {
+    /**
+     * Nodes in the path
+     */
+    path: T[];
+    /**
+     * Total cost/distance
+     */
+    cost: number;
+    /**
+     * Whether a path was found
+     */
+    found: boolean;
+}
+//# sourceMappingURL=graph.interface.d.ts.map

package/dist/src/shared/algorithms/graph/graph.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/graph/graph.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAC;IACR,EAAE,EAAE,CAAC,CAAC;IACN,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAEhC;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;OAEG;IACH,IAAI,EAAE,CAAC,EAAE,CAAC;IAEV;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB"}

package/dist/src/shared/algorithms/graph/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Graph Algorithms
+ *
+ * Efficient algorithms for graph traversal, path finding, and analysis.
+ */
+export { dfs, dfsPath, hasCycle, stronglyConnectedComponents, } from './dfs';
+export { bfs, bfsShortestPath, nodesAtDistance, connectedComponent, allConnectedComponents, } from './bfs';
+export type { AdjacencyList, WeightedEdge, DFSOptions, BFSOptions, PathResult, } from './graph.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/graph/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,GAAG,EACH,OAAO,EACP,QAAQ,EACR,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAGf,OAAO,EACL,GAAG,EACH,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,OAAO,CAAC;AAGf,YAAY,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,mBAAmB,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * Algorithms for ZenGrid
+ */
+export { binarySearch, binarySearchLeft, binarySearchRight, } from './search';
+export type { BinarySearchOptions, BinarySearchResult, } from './search';
+export { dfs, dfsPath, hasCycle, stronglyConnectedComponents, bfs, bfsShortestPath, nodesAtDistance, connectedComponent, allConnectedComponents, } from './graph';
+export type { AdjacencyList, WeightedEdge, DFSOptions, BFSOptions, PathResult, } from './graph';
+export { BloomFilter } from './filter';
+export { detectSequence, generateSequence, autofill, } from './pattern';
+export type { SequenceType, SequencePattern, } from './pattern';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared/algorithms/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,GAAG,EACH,OAAO,EACP,QAAQ,EACR,2BAA2B,EAC3B,GAAG,EACH,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AACjB,YAAY,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,QAAQ,GACT,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,YAAY,EACZ,eAAe,GAChB,MAAM,WAAW,CAAC"}

package/dist/src/shared/algorithms/pattern/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pattern Detection Algorithms
+ *
+ * Algorithms for detecting patterns in data sequences and autofill.
+ */
+export { detectSequence, generateSequence, autofill, } from './sequence-detector';
+export type { SequenceType, SequencePattern, } from './sequence-detector';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/pattern/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/pattern/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,QAAQ,GACT,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EACV,YAAY,EACZ,eAAe,GAChB,MAAM,qBAAqB,CAAC"}

package/dist/src/shared/algorithms/pattern/sequence-detector.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Sequence Detection for Autofill
+ *
+ * Detects patterns in data sequences for intelligent autofill.
+ *
+ * **Supported Patterns:**
+ * - Arithmetic sequences: 1, 2, 3, 4, ...
+ * - Geometric sequences: 2, 4, 8, 16, ...
+ * - Date sequences: Jan 1, Jan 2, Jan 3, ...
+ * - Day sequences: Mon, Tue, Wed, ...
+ * - Text patterns: Item 1, Item 2, Item 3, ...
+ *
+ * @example
+ * ```typescript
+ * // Detect arithmetic sequence
+ * const pattern = detectSequence([1, 2, 3, 4]);
+ * // pattern: { type: 'arithmetic', step: 1 }
+ *
+ * // Generate next values
+ * const next = generateSequence(pattern, 5, 3);
+ * // next: [5, 6, 7]
+ * ```
+ */
+/**
+ * Sequence pattern types
+ */
+export type SequenceType = 'arithmetic' | 'geometric' | 'date' | 'text' | 'constant' | 'none';
+/**
+ * Detected sequence pattern
+ */
+export interface SequencePattern {
+    type: SequenceType;
+    step?: number;
+    ratio?: number;
+    template?: string;
+    confidence: number;
+}
+/**
+ * Detect sequence pattern from an array of values
+ *
+ * @param values - Array of values (at least 2 required)
+ * @returns Detected pattern
+ */
+export declare function detectSequence(values: any[]): SequencePattern;
+/**
+ * Generate next values in a sequence
+ *
+ * @param pattern - Detected sequence pattern
+ * @param startValue - Starting value
+ * @param count - Number of values to generate
+ * @returns Array of generated values
+ */
+export declare function generateSequence(pattern: SequencePattern, startValue: any, count: number): any[];
+/**
+ * Autofill a range based on detected pattern
+ *
+ * @param source - Source values to detect pattern from
+ * @param targetLength - Desired length of result
+ * @returns Autofilled array
+ */
+export declare function autofill(source: any[], targetLength: number): any[];
+//# sourceMappingURL=sequence-detector.d.ts.map

package/dist/src/shared/algorithms/pattern/sequence-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-detector.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/pattern/sequence-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,YAAY,GACZ,WAAW,GACX,MAAM,GACN,MAAM,GACN,UAAU,GACV,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,eAAe,CAkC7D;AAoGD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,CAsDhG;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,GAAG,EAAE,CAqBnE"}

package/dist/src/shared/algorithms/search/binary-search.d.ts

@@ -0,0 +1,86 @@
+import type { Comparator } from '../../types';
+/**
+ * Options for binary search
+ */
+export interface BinarySearchOptions<T> {
+    /**
+     * Custom comparator function
+     * @default (a, b) => a - b for numbers
+     */
+    comparator?: Comparator<T>;
+    /**
+     * If true, returns insertion point when not found
+     * Insertion point is the index where the target should be inserted
+     * @default false
+     */
+    returnInsertionPoint?: boolean;
+}
+/**
+ * Result of binary search
+ */
+export interface BinarySearchResult {
+    /**
+     * Whether the target was found
+     */
+    found: boolean;
+    /**
+     * Index where target was found, or -1 if not found
+     * If returnInsertionPoint is true and not found, returns insertion index
+     */
+    index: number;
+}
+/**
+ * Performs binary search on a sorted array
+ *
+ * @param array - Sorted array to search
+ * @param target - Value to find
+ * @param options - Search options
+ * @returns Search result with found status and index
+ *
+ * @example
+ * ```typescript
+ * const result = binarySearch([1, 3, 5, 7, 9], 5);
+ * // { found: true, index: 2 }
+ *
+ * const result2 = binarySearch([1, 3, 5, 7], 4, { returnInsertionPoint: true });
+ * // { found: false, index: 2 } - insert at index 2 to maintain order
+ * ```
+ *
+ * @complexity O(log n) where n = array.length
+ */
+export declare function binarySearch<T>(array: ReadonlyArray<T>, target: T, options?: BinarySearchOptions<T>): BinarySearchResult;
+/**
+ * Find the leftmost (first) occurrence of target in sorted array
+ *
+ * @param array - Sorted array (may have duplicates)
+ * @param target - Value to find
+ * @param comparator - Custom comparator
+ * @returns Index of first occurrence, or -1 if not found
+ *
+ * @example
+ * ```typescript
+ * const index = binarySearchLeft([1, 2, 2, 2, 3], 2);
+ * // 1 (first occurrence of 2)
+ * ```
+ *
+ * @complexity O(log n)
+ */
+export declare function binarySearchLeft<T>(array: ReadonlyArray<T>, target: T, comparator?: Comparator<T>): number;
+/**
+ * Find the rightmost (last) occurrence of target in sorted array
+ *
+ * @param array - Sorted array (may have duplicates)
+ * @param target - Value to find
+ * @param comparator - Custom comparator
+ * @returns Index of last occurrence, or -1 if not found
+ *
+ * @example
+ * ```typescript
+ * const index = binarySearchRight([1, 2, 2, 2, 3], 2);
+ * // 3 (last occurrence of 2)
+ * ```
+ *
+ * @complexity O(log n)
+ */
+export declare function binarySearchRight<T>(array: ReadonlyArray<T>, target: T, comparator?: Comparator<T>): number;
+//# sourceMappingURL=binary-search.d.ts.map

package/dist/src/shared/algorithms/search/binary-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/search/binary-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC;;;OAGG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAE3B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,mBAAmB,CAAC,CAAC,CAAM,GACnC,kBAAkB,CA+BpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,UAAU,GAAE,UAAU,CAAC,CAAC,CAAsC,GAC7D,MAAM,CAqBR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,UAAU,GAAE,UAAU,CAAC,CAAC,CAAsC,GAC7D,MAAM,CAqBR"}

package/dist/src/shared/algorithms/search/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Search algorithms
+ */
+export { binarySearch, binarySearchLeft, binarySearchRight, } from './binary-search';
+export type { BinarySearchOptions, BinarySearchResult, } from './binary-search';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shared/algorithms/search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/search/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC"}

package/dist/src/shared/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/shared/algorithms/sorting/comparators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparators.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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,CAC/B,YAAY,GAAE,YAAqB,GAClC,UAAU,CAAC,GAAG,CAAC,CAajB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,uBAA4B,GACpC,UAAU,CAAC,GAAG,CAAC,CAyBjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,YAAY,GAAE,YAAqB,GAClC,UAAU,CAAC,GAAG,CAAC,CAgBjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,GAAE,YAAqB,GAClC,UAAU,CAAC,GAAG,CAAC,CAQjB;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,CA2BjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,UAAU,CAAC,CAAC,CAAC,CAEf;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,GAAG,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAC9B,UAAU,CAAC,CAAC,CAAC,CAUf"}

package/dist/src/shared/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/shared/algorithms/sorting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/sorting/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,YAAY,EACZ,cAAc,EACd,YAAY,GACb,MAAM,qBAAqB,CAAC;AAE7B,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/shared/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/shared/algorithms/sorting/sorting.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timsort.d.ts","sourceRoot":"","sources":["../../../../../src/shared/algorithms/sorting/timsort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAyB1D;;;;;;;;;;;;;;;;;;;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,EACxB,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,OAAO,CAOT"}

package/dist/src/shared/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/shared/data-structures/column-store/column-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-store.d.ts","sourceRoot":"","sources":["../../../../../src/shared/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;IAiBpB,OAAO,CAAC,UAAU;IAalB,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;IAmBlD,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,kBAAkB,GAC5B,iBAAiB;IA+FpB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAiC5B,KAAK,IAAI,IAAI;IAYb,OAAO,CAAC,eAAe;IAgBvB,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAEnC;CACF"}