@zengrid/shared 1.0.3 → 1.1.0

package/dist/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@zengrid/shared",
+  "version": "1.1.0",
+  "description": "14 advanced data structures and algorithms for high-performance grids",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    },
+    "./algorithms/*": {
+      "types": "./dist/algorithms/*/index.d.ts",
+      "import": "./dist/algorithms/*/index.esm.js",
+      "require": "./dist/algorithms/*/index.cjs"
+    },
+    "./data-structures/*": {
+      "types": "./dist/data-structures/*/index.d.ts",
+      "import": "./dist/data-structures/*/index.esm.js",
+      "require": "./dist/data-structures/*/index.cjs"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.esm.js",
+      "require": "./dist/types/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "algorithms",
+    "data-structures",
+    "grid",
+    "utilities"
+  ],
+  "author": "ZenGrid Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zengrid-dev/zengrid.git",
+    "directory": "packages/shared"
+  },
+  "bugs": {
+    "url": "https://github.com/zengrid-dev/zengrid/issues"
+  },
+  "homepage": "https://github.com/zengrid-dev/zengrid#readme"
+}

package/dist/src/algorithms/filter/bloom-filter.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Bloom Filter - Probabilistic Data Structure
+ *
+ * A space-efficient probabilistic data structure for testing set membership.
+ * May have false positives but never false negatives.
+ *
+ * **Time Complexity:**
+ * - Add: O(k) where k = number of hash functions
+ * - Check: O(k)
+ *
+ * **Space Complexity:** O(m) where m = bit array size
+ *
+ * **Use Cases:**
+ * - Quick "definitely not in set" checks (e.g., "does this filter value exist?")
+ * - Cache optimization (avoid expensive lookups for non-existent items)
+ * - Duplicate detection in large datasets
+ * - Spell checkers
+ *
+ * @example
+ * ```typescript
+ * const filter = new BloomFilter(1000, 3); // 1000 bits, 3 hash functions
+ *
+ * // Add some items
+ * filter.add('apple');
+ * filter.add('banana');
+ * filter.add('cherry');
+ *
+ * filter.contains('apple');   // true (definitely in set)
+ * filter.contains('grape');   // false (definitely NOT in set)
+ * filter.contains('apples');  // might be true (false positive possible)
+ * ```
+ *
+ * @example Grid Filter Optimization
+ * ```typescript
+ * // Quickly check if a filter value might exist before scanning column
+ * class ColumnFilter {
+ *   private bloomFilter = new BloomFilter(10000, 4);
+ *
+ *   indexColumn(values: any[]): void {
+ *     values.forEach(v => this.bloomFilter.add(String(v)));
+ *   }
+ *
+ *   mightContain(value: string): boolean {
+ *     return this.bloomFilter.contains(value);
+ *   }
+ * }
+ * ```
+ */
+export declare class BloomFilter {
+    private bitArray;
+    private size;
+    private hashCount;
+    /**
+     * Create a new Bloom Filter
+     *
+     * @param size - Size of the bit array (larger = fewer false positives)
+     * @param hashCount - Number of hash functions (more = fewer false positives, slower)
+     */
+    constructor(size: number, hashCount?: number);
+    /**
+     * Add an item to the filter
+     *
+     * @param item - Item to add
+     */
+    add(item: string): void;
+    /**
+     * Check if an item might be in the set
+     *
+     * @param item - Item to check
+     * @returns true if item might be in set, false if definitely NOT in set
+     */
+    contains(item: string): boolean;
+    /**
+     * Clear the filter
+     */
+    clear(): void;
+    /**
+     * Get the false positive probability
+     *
+     * P(false positive) ≈ (1 - e^(-kn/m))^k
+     * where k = hash functions, n = items added, m = bit array size
+     *
+     * @param itemCount - Number of items added
+     * @returns Estimated false positive probability
+     */
+    getFalsePositiveRate(itemCount: number): number;
+    /**
+     * Calculate optimal bit array size for desired false positive rate
+     *
+     * m = -(n * ln(p)) / (ln(2)^2)
+     *
+     * @param itemCount - Expected number of items
+     * @param falsePositiveRate - Desired false positive rate (e.g., 0.01 for 1%)
+     * @returns Optimal bit array size
+     */
+    static optimalSize(itemCount: number, falsePositiveRate: number): number;
+    /**
+     * Calculate optimal number of hash functions
+     *
+     * k = (m/n) * ln(2)
+     *
+     * @param bitArraySize - Size of bit array
+     * @param itemCount - Expected number of items
+     * @returns Optimal number of hash functions
+     */
+    static optimalHashCount(bitArraySize: number, itemCount: number): number;
+    /**
+     * Generate multiple hash values for an item
+     */
+    private getHashes;
+    /**
+     * First hash function (simple polynomial hash)
+     */
+    private hashFunc1;
+    /**
+     * Second hash function (FNV-1a variant)
+     */
+    private hashFunc2;
+}
+//# sourceMappingURL=bloom-filter.d.ts.map

package/dist/src/algorithms/filter/bloom-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom-filter.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/filter/bloom-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,SAAS,CAAS;IAE1B;;;;;OAKG;gBACS,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAU;IAM/C;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQvB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAY/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;OAQG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAQ/C;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM;IAIxE;;;;;;;;OAQG;IACH,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAMxE;;OAEG;IACH,OAAO,CAAC,SAAS;IAejB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;IACH,OAAO,CAAC,SAAS;CAUlB"}

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

@@ -0,0 +1,7 @@
+/**
+ * Filter Algorithms
+ *
+ * Efficient filtering and probabilistic data structures.
+ */
+export { BloomFilter } from './bloom-filter';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/filter/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/algorithms/graph/bfs.d.ts

@@ -0,0 +1,71 @@
+import type { AdjacencyList, BFSOptions, PathResult } from './graph.interface';
+/**
+ * Breadth-First Search (BFS)
+ *
+ * Explores nodes level by level, visiting all neighbors before moving deeper.
+ *
+ * **Time Complexity:** O(V + E) where V = vertices, E = edges
+ * **Space Complexity:** O(V) for the queue
+ *
+ * **Use Cases:**
+ * - Shortest path in unweighted graphs
+ * - Level-order traversal
+ * - Finding connected components
+ * - Web crawling
+ * - Social network analysis (friends of friends)
+ *
+ * @example
+ * ```typescript
+ * const graph: AdjacencyList<string> = new Map([
+ *   ['A', new Set(['B', 'C'])],
+ *   ['B', new Set(['D', 'E'])],
+ *   ['C', new Set(['F'])],
+ *   ['D', new Set()],
+ *   ['E', new Set()],
+ *   ['F', new Set()],
+ * ]);
+ *
+ * const visited = bfs(graph, 'A');
+ * // visited: ['A', 'B', 'C', 'D', 'E', 'F'] (breadth-first order)
+ * ```
+ *
+ * @param graph - Adjacency list representation
+ * @param start - Starting node
+ * @param options - Traversal options
+ * @returns Array of visited nodes in BFS order
+ */
+export declare function bfs<T>(graph: AdjacencyList<T>, start: T, options?: BFSOptions<T>): T[];
+/**
+ * BFS to find shortest path between two nodes (unweighted)
+ *
+ * @param graph - Adjacency list
+ * @param start - Start node
+ * @param end - End node
+ * @returns Path result with shortest path
+ */
+export declare function bfsShortestPath<T>(graph: AdjacencyList<T>, start: T, end: T): PathResult<T>;
+/**
+ * Find all nodes at a specific distance from start
+ *
+ * @param graph - Adjacency list
+ * @param start - Start node
+ * @param distance - Distance from start
+ * @returns Array of nodes at the specified distance
+ */
+export declare function nodesAtDistance<T>(graph: AdjacencyList<T>, start: T, distance: number): T[];
+/**
+ * Find connected component containing a node
+ *
+ * @param graph - Adjacency list
+ * @param start - Starting node
+ * @returns All nodes in the connected component
+ */
+export declare function connectedComponent<T>(graph: AdjacencyList<T>, start: T): T[];
+/**
+ * Find all connected components in the graph
+ *
+ * @param graph - Adjacency list
+ * @returns Array of connected components
+ */
+export declare function allConnectedComponents<T>(graph: AdjacencyList<T>): T[][];
+//# sourceMappingURL=bfs.d.ts.map

package/dist/src/algorithms/graph/bfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bfs.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/graph/bfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,GAAE,UAAU,CAAC,CAAC,CAAM,GAAG,CAAC,EAAE,CA8B1F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA8C3F;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,EAAE,CA8B3F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAaxE"}

package/dist/src/algorithms/graph/dfs.d.ts

@@ -0,0 +1,62 @@
+import type { AdjacencyList, DFSOptions } from './graph.interface';
+/**
+ * Depth-First Search (DFS)
+ *
+ * Explores as far as possible along each branch before backtracking.
+ *
+ * **Time Complexity:** O(V + E) where V = vertices, E = edges
+ * **Space Complexity:** O(V) for the recursion stack
+ *
+ * **Use Cases:**
+ * - Path finding
+ * - Cycle detection
+ * - Topological sorting
+ * - Connected components
+ * - Maze solving
+ *
+ * @example
+ * ```typescript
+ * const graph: AdjacencyList<string> = new Map([
+ *   ['A', new Set(['B', 'C'])],
+ *   ['B', new Set(['D'])],
+ *   ['C', new Set(['D'])],
+ *   ['D', new Set()],
+ * ]);
+ *
+ * const visited = dfs(graph, 'A');
+ * // visited: ['A', 'B', 'D', 'C'] (depth-first order)
+ * ```
+ *
+ * @param graph - Adjacency list representation
+ * @param start - Starting node
+ * @param options - Traversal options
+ * @returns Array of visited nodes in DFS order
+ */
+export declare function dfs<T>(graph: AdjacencyList<T>, start: T, options?: DFSOptions<T>): T[];
+/**
+ * DFS to find a path between two nodes
+ *
+ * @param graph - Adjacency list
+ * @param start - Start node
+ * @param end - End node
+ * @returns Path from start to end, or empty array if no path exists
+ */
+export declare function dfsPath<T>(graph: AdjacencyList<T>, start: T, end: T): T[];
+/**
+ * Detect if a graph has cycles using DFS
+ *
+ * @param graph - Adjacency list
+ * @returns true if graph has cycles
+ */
+export declare function hasCycle<T>(graph: AdjacencyList<T>): boolean;
+/**
+ * Find all strongly connected components using Tarjan's algorithm
+ *
+ * A strongly connected component is a maximal set of vertices
+ * where every vertex is reachable from every other vertex.
+ *
+ * @param graph - Adjacency list
+ * @returns Array of strongly connected components
+ */
+export declare function stronglyConnectedComponents<T>(graph: AdjacencyList<T>): T[][];
+//# sourceMappingURL=dfs.d.ts.map

package/dist/src/algorithms/graph/dfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dfs.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/graph/dfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,GAAE,UAAU,CAAC,CAAC,CAAM,GAAG,CAAC,EAAE,CAiC1F;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CA0BzE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CA6B5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAiD7E"}

package/dist/src/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/algorithms/graph/graph.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/graph/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,2BAA2B,EAAE,MAAM,OAAO,CAAC;AAG5E,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/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/algorithms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7E,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGxE,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,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAG/F,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACvE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/pattern/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEjF,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/src/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/algorithms/pattern/sequence-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence-detector.d.ts","sourceRoot":"","sources":["../../../../src/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;AAqGD;;;;;;;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/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/algorithms/search/binary-search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/search/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpF,YAAY,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}