@tanstack/db 0.5.32 → 0.6.0

package/dist/esm/indexes/auto-index.js

@@ -1,12 +1,13 @@
 import { DEFAULT_COMPARE_OPTIONS } from "../utils.js";
-import { BTreeIndex } from "./btree-index.js";
+import { hasVirtualPropPath } from "../virtual-props.js";
+import { isDevModeEnabled, checkCollectionSizeForIndex } from "./index-registry.js";
 function shouldAutoIndex(collection) {
-  if (collection.config.autoIndex !== `eager`) {
-    return false;
-  }
-  return true;
+  return collection.config.autoIndex === `eager`;
 }
 function ensureIndexForField(fieldName, fieldPath, collection, compareOptions, compareFn) {
+  if (hasVirtualPropPath(fieldPath)) {
+    return;
+  }
   if (!shouldAutoIndex(collection)) {
     return;
   }
@@ -20,6 +21,13 @@ function ensureIndexForField(fieldName, fieldPath, collection, compareOptions, c
   if (existingIndex) {
     return;
   }
+  if (isDevModeEnabled()) {
+    checkCollectionSizeForIndex(
+      collection.id || `unknown`,
+      collection.size,
+      fieldPath
+    );
+  }
   try {
     collection.createIndex(
       (row) => {
@@ -31,7 +39,6 @@ function ensureIndexForField(fieldName, fieldPath, collection, compareOptions, c
       },
       {
         name: `auto:${fieldPath.join(`.`)}`,
-        indexType: BTreeIndex,
         options: compareFn ? { compareFn, compareOptions: compareOpts } : {}
       }
     );

package/dist/esm/indexes/auto-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"auto-index.js","sources":["../../../src/indexes/auto-index.ts"],"sourcesContent":["import { DEFAULT_COMPARE_OPTIONS } from '../utils'\nimport { BTreeIndex } from './btree-index'\nimport type { CompareOptions } from '../query/builder/types'\nimport type { BasicExpression } from '../query/ir'\nimport type { CollectionImpl } from '../collection/index.js'\n\nexport interface AutoIndexConfig {\n  autoIndex?: `off` | `eager`\n}\n\nfunction shouldAutoIndex(collection: CollectionImpl<any, any, any, any, any>) {\n  // Only proceed if auto-indexing is enabled\n  if (collection.config.autoIndex !== `eager`) {\n    return false\n  }\n\n  return true\n}\n\nexport function ensureIndexForField<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  fieldName: string,\n  fieldPath: Array<string>,\n  collection: CollectionImpl<T, TKey, any, any, any>,\n  compareOptions?: CompareOptions,\n  compareFn?: (a: any, b: any) => number,\n) {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  const compareOpts = compareOptions ?? {\n    ...DEFAULT_COMPARE_OPTIONS,\n    ...collection.compareOptions,\n  }\n\n  // Check if we already have an index for this field\n  const existingIndex = Array.from(collection.indexes.values()).find(\n    (index) =>\n      index.matchesField(fieldPath) && index.matchesCompareOptions(compareOpts),\n  )\n\n  if (existingIndex) {\n    return // Index already exists\n  }\n\n  // Create a new index for this field using the collection's createIndex method\n  try {\n    // Use the proxy-based approach to create the proper accessor for nested paths\n    collection.createIndex(\n      (row) => {\n        // Navigate through the field path\n        let current: any = row\n        for (const part of fieldPath) {\n          current = current[part]\n        }\n        return current\n      },\n      {\n        name: `auto:${fieldPath.join(`.`)}`,\n        indexType: BTreeIndex,\n        options: compareFn ? { compareFn, compareOptions: compareOpts } : {},\n      },\n    )\n  } catch (error) {\n    console.warn(\n      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field path \"${fieldPath.join(`.`)}\":`,\n      error,\n    )\n  }\n}\n\n/**\n * Analyzes a where expression and creates indexes for all simple operations on single fields\n */\nexport function ensureIndexForExpression<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  expression: BasicExpression,\n  collection: CollectionImpl<T, TKey, any, any, any>,\n): void {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  // Extract all indexable expressions and create indexes for them\n  const indexableExpressions = extractIndexableExpressions(expression)\n\n  for (const { fieldName, fieldPath } of indexableExpressions) {\n    ensureIndexForField(fieldName, fieldPath, collection)\n  }\n}\n\n/**\n * Extracts all indexable expressions from a where expression\n */\nfunction extractIndexableExpressions(\n  expression: BasicExpression,\n): Array<{ fieldName: string; fieldPath: Array<string> }> {\n  const results: Array<{ fieldName: string; fieldPath: Array<string> }> = []\n\n  function extractFromExpression(expr: BasicExpression): void {\n    if (expr.type !== `func`) {\n      return\n    }\n\n    const func = expr as any\n\n    // Handle 'and' expressions by recursively processing all arguments\n    if (func.name === `and`) {\n      for (const arg of func.args) {\n        extractFromExpression(arg)\n      }\n      return\n    }\n\n    // Check if this is a supported operation\n    const supportedOperations = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]\n    if (!supportedOperations.includes(func.name)) {\n      return\n    }\n\n    // Check if the first argument is a property reference\n    if (func.args.length < 1 || func.args[0].type !== `ref`) {\n      return\n    }\n\n    const fieldRef = func.args[0]\n    const fieldPath = fieldRef.path\n\n    // Skip if the path is empty\n    if (fieldPath.length === 0) {\n      return\n    }\n\n    // For nested paths, use the full path joined with underscores as the field name\n    // For simple paths, use the first (and only) element\n    const fieldName = fieldPath.join(`_`)\n    results.push({ fieldName, fieldPath })\n  }\n\n  extractFromExpression(expression)\n  return results\n}\n"],"names":[],"mappings":";;AAUA,SAAS,gBAAgB,YAAqD;AAE5E,MAAI,WAAW,OAAO,cAAc,SAAS;AAC3C,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,SAAS,oBAId,WACA,WACA,YACA,gBACA,WACA;AACA,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAEA,QAAM,cAAc,kBAAkB;AAAA,IACpC,GAAG;AAAA,IACH,GAAG,WAAW;AAAA,EAAA;AAIhB,QAAM,gBAAgB,MAAM,KAAK,WAAW,QAAQ,OAAA,CAAQ,EAAE;AAAA,IAC5D,CAAC,UACC,MAAM,aAAa,SAAS,KAAK,MAAM,sBAAsB,WAAW;AAAA,EAAA;AAG5E,MAAI,eAAe;AACjB;AAAA,EACF;AAGA,MAAI;AAEF,eAAW;AAAA,MACT,CAAC,QAAQ;AAEP,YAAI,UAAe;AACnB,mBAAW,QAAQ,WAAW;AAC5B,oBAAU,QAAQ,IAAI;AAAA,QACxB;AACA,eAAO;AAAA,MACT;AAAA,MACA;AAAA,QACE,MAAM,QAAQ,UAAU,KAAK,GAAG,CAAC;AAAA,QACjC,WAAW;AAAA,QACX,SAAS,YAAY,EAAE,WAAW,gBAAgB,YAAA,IAAgB,CAAA;AAAA,MAAC;AAAA,IACrE;AAAA,EAEJ,SAAS,OAAO;AACd,YAAQ;AAAA,MACN,GAAG,WAAW,KAAK,IAAI,WAAW,EAAE,OAAO,EAAE,+CAA+C,UAAU,KAAK,GAAG,CAAC;AAAA,MAC/G;AAAA,IAAA;AAAA,EAEJ;AACF;AAKO,SAAS,yBAId,YACA,YACM;AACN,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAGA,QAAM,uBAAuB,4BAA4B,UAAU;AAEnE,aAAW,EAAE,WAAW,UAAA,KAAe,sBAAsB;AAC3D,wBAAoB,WAAW,WAAW,UAAU;AAAA,EACtD;AACF;AAKA,SAAS,4BACP,YACwD;AACxD,QAAM,UAAkE,CAAA;AAExE,WAAS,sBAAsB,MAA6B;AAC1D,QAAI,KAAK,SAAS,QAAQ;AACxB;AAAA,IACF;AAEA,UAAM,OAAO;AAGb,QAAI,KAAK,SAAS,OAAO;AACvB,iBAAW,OAAO,KAAK,MAAM;AAC3B,8BAAsB,GAAG;AAAA,MAC3B;AACA;AAAA,IACF;AAGA,UAAM,sBAAsB,CAAC,MAAM,MAAM,OAAO,MAAM,OAAO,IAAI;AACjE,QAAI,CAAC,oBAAoB,SAAS,KAAK,IAAI,GAAG;AAC5C;AAAA,IACF;AAGA,QAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,CAAC,EAAE,SAAS,OAAO;AACvD;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,KAAK,CAAC;AAC5B,UAAM,YAAY,SAAS;AAG3B,QAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,IACF;AAIA,UAAM,YAAY,UAAU,KAAK,GAAG;AACpC,YAAQ,KAAK,EAAE,WAAW,UAAA,CAAW;AAAA,EACvC;AAEA,wBAAsB,UAAU;AAChC,SAAO;AACT;"}
+{"version":3,"file":"auto-index.js","sources":["../../../src/indexes/auto-index.ts"],"sourcesContent":["import { DEFAULT_COMPARE_OPTIONS } from '../utils'\nimport { hasVirtualPropPath } from '../virtual-props'\nimport { checkCollectionSizeForIndex, isDevModeEnabled } from './index-registry'\nimport type { CompareOptions } from '../query/builder/types'\nimport type { BasicExpression } from '../query/ir'\nimport type { CollectionImpl } from '../collection/index.js'\n\nexport interface AutoIndexConfig {\n  autoIndex?: `off` | `eager`\n}\n\nfunction shouldAutoIndex(collection: CollectionImpl<any, any, any, any, any>) {\n  // Only proceed if auto-indexing is enabled\n  // Note: autoIndex: 'eager' without defaultIndexType is caught at construction time\n  // in CollectionImpl, so we don't need to check for it here.\n  return collection.config.autoIndex === `eager`\n}\n\nexport function ensureIndexForField<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  fieldName: string,\n  fieldPath: Array<string>,\n  collection: CollectionImpl<T, TKey, any, any, any>,\n  compareOptions?: CompareOptions,\n  compareFn?: (a: any, b: any) => number,\n) {\n  if (hasVirtualPropPath(fieldPath)) {\n    return\n  }\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  const compareOpts = compareOptions ?? {\n    ...DEFAULT_COMPARE_OPTIONS,\n    ...collection.compareOptions,\n  }\n\n  // Check if we already have an index for this field\n  const existingIndex = Array.from(collection.indexes.values()).find(\n    (index) =>\n      index.matchesField(fieldPath) && index.matchesCompareOptions(compareOpts),\n  )\n\n  if (existingIndex) {\n    return // Index already exists\n  }\n\n  // Dev mode: check if collection size warrants an index suggestion\n  if (isDevModeEnabled()) {\n    checkCollectionSizeForIndex(\n      collection.id || `unknown`,\n      collection.size,\n      fieldPath,\n    )\n  }\n\n  // Create a new index for this field using the collection's createIndex method\n  // The collection will use its defaultIndexType\n  try {\n    collection.createIndex(\n      (row) => {\n        // Navigate through the field path\n        let current: any = row\n        for (const part of fieldPath) {\n          current = current[part]\n        }\n        return current\n      },\n      {\n        name: `auto:${fieldPath.join(`.`)}`,\n        options: compareFn ? { compareFn, compareOptions: compareOpts } : {},\n      },\n    )\n  } catch (error) {\n    console.warn(\n      `${collection.id ? `[${collection.id}] ` : ``}Failed to create auto-index for field path \"${fieldPath.join(`.`)}\":`,\n      error,\n    )\n  }\n}\n\n/**\n * Analyzes a where expression and creates indexes for all simple operations on single fields\n */\nexport function ensureIndexForExpression<\n  T extends Record<string, any>,\n  TKey extends string | number,\n>(\n  expression: BasicExpression,\n  collection: CollectionImpl<T, TKey, any, any, any>,\n): void {\n  if (!shouldAutoIndex(collection)) {\n    return\n  }\n\n  // Extract all indexable expressions and create indexes for them\n  const indexableExpressions = extractIndexableExpressions(expression)\n\n  for (const { fieldName, fieldPath } of indexableExpressions) {\n    ensureIndexForField(fieldName, fieldPath, collection)\n  }\n}\n\n/**\n * Extracts all indexable expressions from a where expression\n */\nfunction extractIndexableExpressions(\n  expression: BasicExpression,\n): Array<{ fieldName: string; fieldPath: Array<string> }> {\n  const results: Array<{ fieldName: string; fieldPath: Array<string> }> = []\n\n  function extractFromExpression(expr: BasicExpression): void {\n    if (expr.type !== `func`) {\n      return\n    }\n\n    const func = expr as any\n\n    // Handle 'and' expressions by recursively processing all arguments\n    if (func.name === `and`) {\n      for (const arg of func.args) {\n        extractFromExpression(arg)\n      }\n      return\n    }\n\n    // Check if this is a supported operation\n    const supportedOperations = [`eq`, `gt`, `gte`, `lt`, `lte`, `in`]\n    if (!supportedOperations.includes(func.name)) {\n      return\n    }\n\n    // Check if the first argument is a property reference\n    if (func.args.length < 1 || func.args[0].type !== `ref`) {\n      return\n    }\n\n    const fieldRef = func.args[0]\n    const fieldPath = fieldRef.path\n\n    // Skip if the path is empty\n    if (fieldPath.length === 0) {\n      return\n    }\n\n    // For nested paths, use the full path joined with underscores as the field name\n    // For simple paths, use the first (and only) element\n    const fieldName = fieldPath.join(`_`)\n    results.push({ fieldName, fieldPath })\n  }\n\n  extractFromExpression(expression)\n  return results\n}\n"],"names":[],"mappings":";;;AAWA,SAAS,gBAAgB,YAAqD;AAI5E,SAAO,WAAW,OAAO,cAAc;AACzC;AAEO,SAAS,oBAId,WACA,WACA,YACA,gBACA,WACA;AACA,MAAI,mBAAmB,SAAS,GAAG;AACjC;AAAA,EACF;AACA,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAEA,QAAM,cAAc,kBAAkB;AAAA,IACpC,GAAG;AAAA,IACH,GAAG,WAAW;AAAA,EAAA;AAIhB,QAAM,gBAAgB,MAAM,KAAK,WAAW,QAAQ,OAAA,CAAQ,EAAE;AAAA,IAC5D,CAAC,UACC,MAAM,aAAa,SAAS,KAAK,MAAM,sBAAsB,WAAW;AAAA,EAAA;AAG5E,MAAI,eAAe;AACjB;AAAA,EACF;AAGA,MAAI,oBAAoB;AACtB;AAAA,MACE,WAAW,MAAM;AAAA,MACjB,WAAW;AAAA,MACX;AAAA,IAAA;AAAA,EAEJ;AAIA,MAAI;AACF,eAAW;AAAA,MACT,CAAC,QAAQ;AAEP,YAAI,UAAe;AACnB,mBAAW,QAAQ,WAAW;AAC5B,oBAAU,QAAQ,IAAI;AAAA,QACxB;AACA,eAAO;AAAA,MACT;AAAA,MACA;AAAA,QACE,MAAM,QAAQ,UAAU,KAAK,GAAG,CAAC;AAAA,QACjC,SAAS,YAAY,EAAE,WAAW,gBAAgB,YAAA,IAAgB,CAAA;AAAA,MAAC;AAAA,IACrE;AAAA,EAEJ,SAAS,OAAO;AACd,YAAQ;AAAA,MACN,GAAG,WAAW,KAAK,IAAI,WAAW,EAAE,OAAO,EAAE,+CAA+C,UAAU,KAAK,GAAG,CAAC;AAAA,MAC/G;AAAA,IAAA;AAAA,EAEJ;AACF;AAKO,SAAS,yBAId,YACA,YACM;AACN,MAAI,CAAC,gBAAgB,UAAU,GAAG;AAChC;AAAA,EACF;AAGA,QAAM,uBAAuB,4BAA4B,UAAU;AAEnE,aAAW,EAAE,WAAW,UAAA,KAAe,sBAAsB;AAC3D,wBAAoB,WAAW,WAAW,UAAU;AAAA,EACtD;AACF;AAKA,SAAS,4BACP,YACwD;AACxD,QAAM,UAAkE,CAAA;AAExE,WAAS,sBAAsB,MAA6B;AAC1D,QAAI,KAAK,SAAS,QAAQ;AACxB;AAAA,IACF;AAEA,UAAM,OAAO;AAGb,QAAI,KAAK,SAAS,OAAO;AACvB,iBAAW,OAAO,KAAK,MAAM;AAC3B,8BAAsB,GAAG;AAAA,MAC3B;AACA;AAAA,IACF;AAGA,UAAM,sBAAsB,CAAC,MAAM,MAAM,OAAO,MAAM,OAAO,IAAI;AACjE,QAAI,CAAC,oBAAoB,SAAS,KAAK,IAAI,GAAG;AAC5C;AAAA,IACF;AAGA,QAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,CAAC,EAAE,SAAS,OAAO;AACvD;AAAA,IACF;AAEA,UAAM,WAAW,KAAK,KAAK,CAAC;AAC5B,UAAM,YAAY,SAAS;AAG3B,QAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,IACF;AAIA,UAAM,YAAY,UAAU,KAAK,GAAG;AACpC,YAAQ,KAAK,EAAE,WAAW,UAAA,CAAW;AAAA,EACvC;AAEA,wBAAsB,UAAU;AAChC,SAAO;AACT;"}

package/dist/esm/indexes/base-index.d.ts

@@ -19,7 +19,7 @@ export interface IndexStats {
     readonly averageLookupTime: number;
     readonly lastUpdated: Date;
 }
-export interface IndexInterface<TKey extends string | number | undefined = string | number | undefined> {
+export interface IndexInterface<TKey extends string | number = string | number> {
     add: (key: TKey, item: any) => void;
     remove: (key: TKey, item: any) => void;
     update: (key: TKey, oldItem: any, newItem: any) => void;
@@ -48,7 +48,7 @@ export interface IndexInterface<TKey extends string | number | undefined = strin
 /**
  * Base abstract class that all index types extend
  */
-export declare abstract class BaseIndex<TKey extends string | number | undefined = string | number | undefined> implements IndexInterface<TKey> {
+export declare abstract class BaseIndex<TKey extends string | number = string | number> implements IndexInterface<TKey> {
     readonly id: number;
     readonly name?: string;
     readonly expression: BasicExpression;
@@ -98,7 +98,3 @@ export declare abstract class BaseIndex<TKey extends string | number | undefined
  * Type for index constructor
  */
 export type IndexConstructor<TKey extends string | number = string | number> = new (id: number, expression: BasicExpression, name?: string, options?: any) => BaseIndex<TKey>;
-/**
- * Index resolver can be either a class constructor or async loader
- */
-export type IndexResolver<TKey extends string | number = string | number> = IndexConstructor<TKey> | (() => Promise<IndexConstructor<TKey>>);

package/dist/esm/indexes/base-index.js

@@ -1,7 +1,5 @@
 import { compileSingleRowExpression } from "../query/compiler/evaluators.js";
-import { comparisonFunctions } from "../query/builder/functions.js";
 import { DEFAULT_COMPARE_OPTIONS, deepEquals } from "../utils.js";
-const IndexOperation = comparisonFunctions;
 class BaseIndex {
   constructor(id, expression, name, options) {
     this.lookupCount = 0;
@@ -66,7 +64,6 @@ class BaseIndex {
   }
 }
 export {
-  BaseIndex,
-  IndexOperation
+  BaseIndex
 };
 //# sourceMappingURL=base-index.js.map

package/dist/esm/indexes/base-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"base-index.js","sources":["../../../src/indexes/base-index.ts"],"sourcesContent":["import { compileSingleRowExpression } from '../query/compiler/evaluators.js'\nimport { comparisonFunctions } from '../query/builder/functions.js'\nimport { DEFAULT_COMPARE_OPTIONS, deepEquals } from '../utils.js'\nimport type { RangeQueryOptions } from './btree-index.js'\nimport type { CompareOptions } from '../query/builder/types.js'\nimport type { BasicExpression, OrderByDirection } from '../query/ir.js'\n\n/**\n * Operations that indexes can support, imported from available comparison functions\n */\nexport const IndexOperation = comparisonFunctions\n\n/**\n * Type for index operation values\n */\nexport type IndexOperation = (typeof comparisonFunctions)[number]\n\n/**\n * Statistics about index usage and performance\n */\nexport interface IndexStats {\n  readonly entryCount: number\n  readonly lookupCount: number\n  readonly averageLookupTime: number\n  readonly lastUpdated: Date\n}\n\nexport interface IndexInterface<\n  TKey extends string | number | undefined = string | number | undefined,\n> {\n  add: (key: TKey, item: any) => void\n  remove: (key: TKey, item: any) => void\n  update: (key: TKey, oldItem: any, newItem: any) => void\n\n  build: (entries: Iterable<[TKey, any]>) => void\n  clear: () => void\n\n  lookup: (operation: IndexOperation, value: any) => Set<TKey>\n\n  equalityLookup: (value: any) => Set<TKey>\n  inArrayLookup: (values: Array<any>) => Set<TKey>\n\n  rangeQuery: (options: RangeQueryOptions) => Set<TKey>\n  rangeQueryReversed: (options: RangeQueryOptions) => Set<TKey>\n\n  take: (\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ) => Array<TKey>\n  takeFromStart: (n: number, filterFn?: (key: TKey) => boolean) => Array<TKey>\n  takeReversed: (\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ) => Array<TKey>\n  takeReversedFromEnd: (\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ) => Array<TKey>\n\n  get keyCount(): number\n  get orderedEntriesArray(): Array<[any, Set<TKey>]>\n  get orderedEntriesArrayReversed(): Array<[any, Set<TKey>]>\n\n  get indexedKeysSet(): Set<TKey>\n  get valueMapData(): Map<any, Set<TKey>>\n\n  supports: (operation: IndexOperation) => boolean\n\n  matchesField: (fieldPath: Array<string>) => boolean\n  matchesCompareOptions: (compareOptions: CompareOptions) => boolean\n  matchesDirection: (direction: OrderByDirection) => boolean\n\n  getStats: () => IndexStats\n}\n\n/**\n * Base abstract class that all index types extend\n */\nexport abstract class BaseIndex<\n  TKey extends string | number | undefined = string | number | undefined,\n> implements IndexInterface<TKey> {\n  public readonly id: number\n  public readonly name?: string\n  public readonly expression: BasicExpression\n  public abstract readonly supportedOperations: Set<IndexOperation>\n\n  protected lookupCount = 0\n  protected totalLookupTime = 0\n  protected lastUpdated = new Date()\n  protected compareOptions: CompareOptions\n\n  constructor(\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any,\n  ) {\n    this.id = id\n    this.expression = expression\n    this.compareOptions = DEFAULT_COMPARE_OPTIONS\n    this.name = name\n    this.initialize(options)\n  }\n\n  // Abstract methods that each index type must implement\n  abstract add(key: TKey, item: any): void\n  abstract remove(key: TKey, item: any): void\n  abstract update(key: TKey, oldItem: any, newItem: any): void\n  abstract build(entries: Iterable<[TKey, any]>): void\n  abstract clear(): void\n  abstract lookup(operation: IndexOperation, value: any): Set<TKey>\n  abstract take(\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract takeFromStart(\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract takeReversed(\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract takeReversedFromEnd(\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract get keyCount(): number\n  abstract equalityLookup(value: any): Set<TKey>\n  abstract inArrayLookup(values: Array<any>): Set<TKey>\n  abstract rangeQuery(options: RangeQueryOptions): Set<TKey>\n  abstract rangeQueryReversed(options: RangeQueryOptions): Set<TKey>\n  abstract get orderedEntriesArray(): Array<[any, Set<TKey>]>\n  abstract get orderedEntriesArrayReversed(): Array<[any, Set<TKey>]>\n  abstract get indexedKeysSet(): Set<TKey>\n  abstract get valueMapData(): Map<any, Set<TKey>>\n\n  // Common methods\n  supports(operation: IndexOperation): boolean {\n    return this.supportedOperations.has(operation)\n  }\n\n  matchesField(fieldPath: Array<string>): boolean {\n    return (\n      this.expression.type === `ref` &&\n      this.expression.path.length === fieldPath.length &&\n      this.expression.path.every((part, i) => part === fieldPath[i])\n    )\n  }\n\n  /**\n   * Checks if the compare options match the index's compare options.\n   * The direction is ignored because the index can be reversed if the direction is different.\n   */\n  matchesCompareOptions(compareOptions: CompareOptions): boolean {\n    const thisCompareOptionsWithoutDirection = {\n      ...this.compareOptions,\n      direction: undefined,\n    }\n    const compareOptionsWithoutDirection = {\n      ...compareOptions,\n      direction: undefined,\n    }\n\n    return deepEquals(\n      thisCompareOptionsWithoutDirection,\n      compareOptionsWithoutDirection,\n    )\n  }\n\n  /**\n   * Checks if the index matches the provided direction.\n   */\n  matchesDirection(direction: OrderByDirection): boolean {\n    return this.compareOptions.direction === direction\n  }\n\n  getStats(): IndexStats {\n    return {\n      entryCount: this.keyCount,\n      lookupCount: this.lookupCount,\n      averageLookupTime:\n        this.lookupCount > 0 ? this.totalLookupTime / this.lookupCount : 0,\n      lastUpdated: this.lastUpdated,\n    }\n  }\n\n  // Protected methods for subclasses\n  protected abstract initialize(options?: any): void\n\n  protected evaluateIndexExpression(item: any): any {\n    const evaluator = compileSingleRowExpression(this.expression)\n    return evaluator(item as Record<string, unknown>)\n  }\n\n  protected trackLookup(startTime: number): void {\n    const duration = performance.now() - startTime\n    this.lookupCount++\n    this.totalLookupTime += duration\n  }\n\n  protected updateTimestamp(): void {\n    this.lastUpdated = new Date()\n  }\n}\n\n/**\n * Type for index constructor\n */\nexport type IndexConstructor<TKey extends string | number = string | number> =\n  new (\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any,\n  ) => BaseIndex<TKey>\n\n/**\n * Index resolver can be either a class constructor or async loader\n */\nexport type IndexResolver<TKey extends string | number = string | number> =\n  | IndexConstructor<TKey>\n  | (() => Promise<IndexConstructor<TKey>>)\n"],"names":[],"mappings":";;;AAUO,MAAM,iBAAiB;AAsEvB,MAAe,UAEY;AAAA,EAWhC,YACE,IACA,YACA,MACA,SACA;AAVF,SAAU,cAAc;AACxB,SAAU,kBAAkB;AAC5B,SAAU,kCAAkB,KAAA;AAS1B,SAAK,KAAK;AACV,SAAK,aAAa;AAClB,SAAK,iBAAiB;AACtB,SAAK,OAAO;AACZ,SAAK,WAAW,OAAO;AAAA,EACzB;AAAA;AAAA,EAsCA,SAAS,WAAoC;AAC3C,WAAO,KAAK,oBAAoB,IAAI,SAAS;AAAA,EAC/C;AAAA,EAEA,aAAa,WAAmC;AAC9C,WACE,KAAK,WAAW,SAAS,SACzB,KAAK,WAAW,KAAK,WAAW,UAAU,UAC1C,KAAK,WAAW,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS,UAAU,CAAC,CAAC;AAAA,EAEjE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,sBAAsB,gBAAyC;AAC7D,UAAM,qCAAqC;AAAA,MACzC,GAAG,KAAK;AAAA,MACR,WAAW;AAAA,IAAA;AAEb,UAAM,iCAAiC;AAAA,MACrC,GAAG;AAAA,MACH,WAAW;AAAA,IAAA;AAGb,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAiB,WAAsC;AACrD,WAAO,KAAK,eAAe,cAAc;AAAA,EAC3C;AAAA,EAEA,WAAuB;AACrB,WAAO;AAAA,MACL,YAAY,KAAK;AAAA,MACjB,aAAa,KAAK;AAAA,MAClB,mBACE,KAAK,cAAc,IAAI,KAAK,kBAAkB,KAAK,cAAc;AAAA,MACnE,aAAa,KAAK;AAAA,IAAA;AAAA,EAEtB;AAAA,EAKU,wBAAwB,MAAgB;AAChD,UAAM,YAAY,2BAA2B,KAAK,UAAU;AAC5D,WAAO,UAAU,IAA+B;AAAA,EAClD;AAAA,EAEU,YAAY,WAAyB;AAC7C,UAAM,WAAW,YAAY,IAAA,IAAQ;AACrC,SAAK;AACL,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEU,kBAAwB;AAChC,SAAK,kCAAkB,KAAA;AAAA,EACzB;AACF;"}
+{"version":3,"file":"base-index.js","sources":["../../../src/indexes/base-index.ts"],"sourcesContent":["import { compileSingleRowExpression } from '../query/compiler/evaluators.js'\nimport { comparisonFunctions } from '../query/builder/functions.js'\nimport { DEFAULT_COMPARE_OPTIONS, deepEquals } from '../utils.js'\nimport type { RangeQueryOptions } from './btree-index.js'\nimport type { CompareOptions } from '../query/builder/types.js'\nimport type { BasicExpression, OrderByDirection } from '../query/ir.js'\n\n/**\n * Operations that indexes can support, imported from available comparison functions\n */\nexport const IndexOperation = comparisonFunctions\n\n/**\n * Type for index operation values\n */\nexport type IndexOperation = (typeof comparisonFunctions)[number]\n\n/**\n * Statistics about index usage and performance\n */\nexport interface IndexStats {\n  readonly entryCount: number\n  readonly lookupCount: number\n  readonly averageLookupTime: number\n  readonly lastUpdated: Date\n}\n\nexport interface IndexInterface<\n  TKey extends string | number = string | number,\n> {\n  add: (key: TKey, item: any) => void\n  remove: (key: TKey, item: any) => void\n  update: (key: TKey, oldItem: any, newItem: any) => void\n\n  build: (entries: Iterable<[TKey, any]>) => void\n  clear: () => void\n\n  lookup: (operation: IndexOperation, value: any) => Set<TKey>\n\n  equalityLookup: (value: any) => Set<TKey>\n  inArrayLookup: (values: Array<any>) => Set<TKey>\n\n  rangeQuery: (options: RangeQueryOptions) => Set<TKey>\n  rangeQueryReversed: (options: RangeQueryOptions) => Set<TKey>\n\n  take: (\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ) => Array<TKey>\n  takeFromStart: (n: number, filterFn?: (key: TKey) => boolean) => Array<TKey>\n  takeReversed: (\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ) => Array<TKey>\n  takeReversedFromEnd: (\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ) => Array<TKey>\n\n  get keyCount(): number\n  get orderedEntriesArray(): Array<[any, Set<TKey>]>\n  get orderedEntriesArrayReversed(): Array<[any, Set<TKey>]>\n\n  get indexedKeysSet(): Set<TKey>\n  get valueMapData(): Map<any, Set<TKey>>\n\n  supports: (operation: IndexOperation) => boolean\n\n  matchesField: (fieldPath: Array<string>) => boolean\n  matchesCompareOptions: (compareOptions: CompareOptions) => boolean\n  matchesDirection: (direction: OrderByDirection) => boolean\n\n  getStats: () => IndexStats\n}\n\n/**\n * Base abstract class that all index types extend\n */\nexport abstract class BaseIndex<\n  TKey extends string | number = string | number,\n> implements IndexInterface<TKey> {\n  public readonly id: number\n  public readonly name?: string\n  public readonly expression: BasicExpression\n  public abstract readonly supportedOperations: Set<IndexOperation>\n\n  protected lookupCount = 0\n  protected totalLookupTime = 0\n  protected lastUpdated = new Date()\n  protected compareOptions: CompareOptions\n\n  constructor(\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any,\n  ) {\n    this.id = id\n    this.expression = expression\n    this.compareOptions = DEFAULT_COMPARE_OPTIONS\n    this.name = name\n    this.initialize(options)\n  }\n\n  // Abstract methods that each index type must implement\n  abstract add(key: TKey, item: any): void\n  abstract remove(key: TKey, item: any): void\n  abstract update(key: TKey, oldItem: any, newItem: any): void\n  abstract build(entries: Iterable<[TKey, any]>): void\n  abstract clear(): void\n  abstract lookup(operation: IndexOperation, value: any): Set<TKey>\n  abstract take(\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract takeFromStart(\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract takeReversed(\n    n: number,\n    from: TKey,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract takeReversedFromEnd(\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey>\n  abstract get keyCount(): number\n  abstract equalityLookup(value: any): Set<TKey>\n  abstract inArrayLookup(values: Array<any>): Set<TKey>\n  abstract rangeQuery(options: RangeQueryOptions): Set<TKey>\n  abstract rangeQueryReversed(options: RangeQueryOptions): Set<TKey>\n  abstract get orderedEntriesArray(): Array<[any, Set<TKey>]>\n  abstract get orderedEntriesArrayReversed(): Array<[any, Set<TKey>]>\n  abstract get indexedKeysSet(): Set<TKey>\n  abstract get valueMapData(): Map<any, Set<TKey>>\n\n  // Common methods\n  supports(operation: IndexOperation): boolean {\n    return this.supportedOperations.has(operation)\n  }\n\n  matchesField(fieldPath: Array<string>): boolean {\n    return (\n      this.expression.type === `ref` &&\n      this.expression.path.length === fieldPath.length &&\n      this.expression.path.every((part, i) => part === fieldPath[i])\n    )\n  }\n\n  /**\n   * Checks if the compare options match the index's compare options.\n   * The direction is ignored because the index can be reversed if the direction is different.\n   */\n  matchesCompareOptions(compareOptions: CompareOptions): boolean {\n    const thisCompareOptionsWithoutDirection = {\n      ...this.compareOptions,\n      direction: undefined,\n    }\n    const compareOptionsWithoutDirection = {\n      ...compareOptions,\n      direction: undefined,\n    }\n\n    return deepEquals(\n      thisCompareOptionsWithoutDirection,\n      compareOptionsWithoutDirection,\n    )\n  }\n\n  /**\n   * Checks if the index matches the provided direction.\n   */\n  matchesDirection(direction: OrderByDirection): boolean {\n    return this.compareOptions.direction === direction\n  }\n\n  getStats(): IndexStats {\n    return {\n      entryCount: this.keyCount,\n      lookupCount: this.lookupCount,\n      averageLookupTime:\n        this.lookupCount > 0 ? this.totalLookupTime / this.lookupCount : 0,\n      lastUpdated: this.lastUpdated,\n    }\n  }\n\n  protected abstract initialize(options?: any): void\n\n  protected evaluateIndexExpression(item: any): any {\n    const evaluator = compileSingleRowExpression(this.expression)\n    return evaluator(item as Record<string, unknown>)\n  }\n\n  protected trackLookup(startTime: number): void {\n    const duration = performance.now() - startTime\n    this.lookupCount++\n    this.totalLookupTime += duration\n  }\n\n  protected updateTimestamp(): void {\n    this.lastUpdated = new Date()\n  }\n}\n\n/**\n * Type for index constructor\n */\nexport type IndexConstructor<TKey extends string | number = string | number> =\n  new (\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any,\n  ) => BaseIndex<TKey>\n"],"names":[],"mappings":";;AAgFO,MAAe,UAEY;AAAA,EAWhC,YACE,IACA,YACA,MACA,SACA;AAVF,SAAU,cAAc;AACxB,SAAU,kBAAkB;AAC5B,SAAU,kCAAkB,KAAA;AAS1B,SAAK,KAAK;AACV,SAAK,aAAa;AAClB,SAAK,iBAAiB;AACtB,SAAK,OAAO;AACZ,SAAK,WAAW,OAAO;AAAA,EACzB;AAAA;AAAA,EAsCA,SAAS,WAAoC;AAC3C,WAAO,KAAK,oBAAoB,IAAI,SAAS;AAAA,EAC/C;AAAA,EAEA,aAAa,WAAmC;AAC9C,WACE,KAAK,WAAW,SAAS,SACzB,KAAK,WAAW,KAAK,WAAW,UAAU,UAC1C,KAAK,WAAW,KAAK,MAAM,CAAC,MAAM,MAAM,SAAS,UAAU,CAAC,CAAC;AAAA,EAEjE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,sBAAsB,gBAAyC;AAC7D,UAAM,qCAAqC;AAAA,MACzC,GAAG,KAAK;AAAA,MACR,WAAW;AAAA,IAAA;AAEb,UAAM,iCAAiC;AAAA,MACrC,GAAG;AAAA,MACH,WAAW;AAAA,IAAA;AAGb,WAAO;AAAA,MACL;AAAA,MACA;AAAA,IAAA;AAAA,EAEJ;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAiB,WAAsC;AACrD,WAAO,KAAK,eAAe,cAAc;AAAA,EAC3C;AAAA,EAEA,WAAuB;AACrB,WAAO;AAAA,MACL,YAAY,KAAK;AAAA,MACjB,aAAa,KAAK;AAAA,MAClB,mBACE,KAAK,cAAc,IAAI,KAAK,kBAAkB,KAAK,cAAc;AAAA,MACnE,aAAa,KAAK;AAAA,IAAA;AAAA,EAEtB;AAAA,EAIU,wBAAwB,MAAgB;AAChD,UAAM,YAAY,2BAA2B,KAAK,UAAU;AAC5D,WAAO,UAAU,IAA+B;AAAA,EAClD;AAAA,EAEU,YAAY,WAAyB;AAC7C,UAAM,WAAW,YAAY,IAAA,IAAQ;AACrC,SAAK;AACL,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEU,kBAAwB;AAChC,SAAK,kCAAkB,KAAA;AAAA,EACzB;AACF;"}

package/dist/esm/indexes/basic-index.d.ts

@@ -0,0 +1,102 @@
+import { BaseIndex, IndexOperation } from './base-index.js';
+import { CompareOptions } from '../query/builder/types.js';
+import { BasicExpression } from '../query/ir.js';
+/**
+ * Options for range queries
+ */
+export interface RangeQueryOptions {
+    from?: any;
+    to?: any;
+    fromInclusive?: boolean;
+    toInclusive?: boolean;
+}
+/**
+ * Options for Basic index
+ */
+export interface BasicIndexOptions {
+    compareFn?: (a: any, b: any) => number;
+    compareOptions?: CompareOptions;
+}
+/**
+ * Basic index using Map + sorted Array.
+ *
+ * - Map for O(1) equality lookups
+ * - Sorted Array for O(log n) range queries via binary search
+ * - O(n) updates to maintain sort order
+ *
+ * Simpler and smaller than BTreeIndex, good for read-heavy workloads.
+ * Use BTreeIndex for write-heavy workloads with large collections.
+ */
+export declare class BasicIndex<TKey extends string | number = string | number> extends BaseIndex<TKey> {
+    readonly supportedOperations: Set<"eq" | "gt" | "gte" | "lt" | "lte" | "in" | "like" | "ilike">;
+    private valueMap;
+    private sortedValues;
+    private indexedKeys;
+    private compareFn;
+    constructor(id: number, expression: BasicExpression, name?: string, options?: any);
+    protected initialize(_options?: BasicIndexOptions): void;
+    /**
+     * Adds a value to the index
+     */
+    add(key: TKey, item: any): void;
+    /**
+     * Removes a value from the index
+     */
+    remove(key: TKey, item: any): void;
+    /**
+     * Updates a value in the index
+     */
+    update(key: TKey, oldItem: any, newItem: any): void;
+    /**
+     * Builds the index from a collection of entries
+     */
+    build(entries: Iterable<[TKey, any]>): void;
+    /**
+     * Clears all data from the index
+     */
+    clear(): void;
+    /**
+     * Performs a lookup operation
+     */
+    lookup(operation: IndexOperation, value: any): Set<TKey>;
+    /**
+     * Gets the number of indexed keys
+     */
+    get keyCount(): number;
+    /**
+     * Performs an equality lookup - O(1)
+     */
+    equalityLookup(value: any): Set<TKey>;
+    /**
+     * Performs a range query using binary search - O(log n + m)
+     */
+    rangeQuery(options?: RangeQueryOptions): Set<TKey>;
+    /**
+     * Performs a reversed range query
+     */
+    rangeQueryReversed(options?: RangeQueryOptions): Set<TKey>;
+    /**
+     * Returns the next n items in sorted order
+     */
+    take(n: number, from?: any, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    /**
+     * Returns the next n items in reverse sorted order
+     */
+    takeReversed(n: number, from?: any, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    /**
+     * Returns the first n items in sorted order (from the start)
+     */
+    takeFromStart(n: number, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    /**
+     * Returns the first n items in reverse sorted order (from the end)
+     */
+    takeReversedFromEnd(n: number, filterFn?: (key: TKey) => boolean): Array<TKey>;
+    /**
+     * Performs an IN array lookup - O(k) where k is values.length
+     */
+    inArrayLookup(values: Array<any>): Set<TKey>;
+    get indexedKeysSet(): Set<TKey>;
+    get orderedEntriesArray(): Array<[any, Set<TKey>]>;
+    get orderedEntriesArrayReversed(): Array<[any, Set<TKey>]>;
+    get valueMapData(): Map<any, Set<TKey>>;
+}

package/dist/esm/indexes/basic-index.js

@@ -0,0 +1,361 @@
+import { defaultComparator, normalizeValue } from "../utils/comparison.js";
+import { findInsertPositionInArray, deleteInSortedArray } from "../utils/array-utils.js";
+import { BaseIndex } from "./base-index.js";
+class BasicIndex extends BaseIndex {
+  constructor(id, expression, name, options) {
+    super(id, expression, name, options);
+    this.supportedOperations = /* @__PURE__ */ new Set([
+      `eq`,
+      `gt`,
+      `gte`,
+      `lt`,
+      `lte`,
+      `in`
+    ]);
+    this.valueMap = /* @__PURE__ */ new Map();
+    this.sortedValues = [];
+    this.indexedKeys = /* @__PURE__ */ new Set();
+    this.compareFn = defaultComparator;
+    this.compareFn = options?.compareFn ?? defaultComparator;
+    if (options?.compareOptions) {
+      this.compareOptions = options.compareOptions;
+    }
+  }
+  initialize(_options) {
+  }
+  /**
+   * Adds a value to the index
+   */
+  add(key, item) {
+    let indexedValue;
+    try {
+      indexedValue = this.evaluateIndexExpression(item);
+    } catch (error) {
+      throw new Error(
+        `Failed to evaluate index expression for key ${key}: ${error}`,
+        { cause: error }
+      );
+    }
+    const normalizedValue = normalizeValue(indexedValue);
+    if (this.valueMap.has(normalizedValue)) {
+      this.valueMap.get(normalizedValue).add(key);
+    } else {
+      this.valueMap.set(normalizedValue, /* @__PURE__ */ new Set([key]));
+      const insertIdx = findInsertPositionInArray(
+        this.sortedValues,
+        normalizedValue,
+        this.compareFn
+      );
+      this.sortedValues.splice(insertIdx, 0, normalizedValue);
+    }
+    this.indexedKeys.add(key);
+    this.updateTimestamp();
+  }
+  /**
+   * Removes a value from the index
+   */
+  remove(key, item) {
+    let indexedValue;
+    try {
+      indexedValue = this.evaluateIndexExpression(item);
+    } catch (error) {
+      console.warn(
+        `Failed to evaluate index expression for key ${key} during removal:`,
+        error
+      );
+      this.indexedKeys.delete(key);
+      this.updateTimestamp();
+      return;
+    }
+    const normalizedValue = normalizeValue(indexedValue);
+    if (this.valueMap.has(normalizedValue)) {
+      const keySet = this.valueMap.get(normalizedValue);
+      keySet.delete(key);
+      if (keySet.size === 0) {
+        this.valueMap.delete(normalizedValue);
+        deleteInSortedArray(this.sortedValues, normalizedValue, this.compareFn);
+      }
+    }
+    this.indexedKeys.delete(key);
+    this.updateTimestamp();
+  }
+  /**
+   * Updates a value in the index
+   */
+  update(key, oldItem, newItem) {
+    this.remove(key, oldItem);
+    this.add(key, newItem);
+  }
+  /**
+   * Builds the index from a collection of entries
+   */
+  build(entries) {
+    this.clear();
+    const entriesArray = [];
+    for (const [key, item] of entries) {
+      let indexedValue;
+      try {
+        indexedValue = this.evaluateIndexExpression(item);
+      } catch (error) {
+        throw new Error(
+          `Failed to evaluate index expression for key ${key}: ${error}`,
+          { cause: error }
+        );
+      }
+      entriesArray.push({ key, value: normalizeValue(indexedValue) });
+      this.indexedKeys.add(key);
+    }
+    for (const { key, value } of entriesArray) {
+      if (this.valueMap.has(value)) {
+        this.valueMap.get(value).add(key);
+      } else {
+        this.valueMap.set(value, /* @__PURE__ */ new Set([key]));
+      }
+    }
+    this.sortedValues = Array.from(this.valueMap.keys()).sort(this.compareFn);
+    this.updateTimestamp();
+  }
+  /**
+   * Clears all data from the index
+   */
+  clear() {
+    this.valueMap.clear();
+    this.sortedValues = [];
+    this.indexedKeys.clear();
+    this.updateTimestamp();
+  }
+  /**
+   * Performs a lookup operation
+   */
+  lookup(operation, value) {
+    const startTime = performance.now();
+    let result;
+    switch (operation) {
+      case `eq`:
+        result = this.equalityLookup(value);
+        break;
+      case `gt`:
+        result = this.rangeQuery({ from: value, fromInclusive: false });
+        break;
+      case `gte`:
+        result = this.rangeQuery({ from: value, fromInclusive: true });
+        break;
+      case `lt`:
+        result = this.rangeQuery({ to: value, toInclusive: false });
+        break;
+      case `lte`:
+        result = this.rangeQuery({ to: value, toInclusive: true });
+        break;
+      case `in`:
+        result = this.inArrayLookup(value);
+        break;
+      default:
+        throw new Error(`Operation ${operation} not supported by BasicIndex`);
+    }
+    this.trackLookup(startTime);
+    return result;
+  }
+  /**
+   * Gets the number of indexed keys
+   */
+  get keyCount() {
+    return this.indexedKeys.size;
+  }
+  /**
+   * Performs an equality lookup - O(1)
+   */
+  equalityLookup(value) {
+    const normalizedValue = normalizeValue(value);
+    return this.valueMap.get(normalizedValue) ?? /* @__PURE__ */ new Set();
+  }
+  /**
+   * Performs a range query using binary search - O(log n + m)
+   */
+  rangeQuery(options = {}) {
+    const { from, to, fromInclusive = true, toInclusive = true } = options;
+    const result = /* @__PURE__ */ new Set();
+    if (this.sortedValues.length === 0) {
+      return result;
+    }
+    const normalizedFrom = normalizeValue(from);
+    const normalizedTo = normalizeValue(to);
+    let startIdx = 0;
+    if (normalizedFrom !== void 0) {
+      startIdx = findInsertPositionInArray(
+        this.sortedValues,
+        normalizedFrom,
+        this.compareFn
+      );
+      if (!fromInclusive && startIdx < this.sortedValues.length && this.compareFn(this.sortedValues[startIdx], normalizedFrom) === 0) {
+        startIdx++;
+      }
+    }
+    let endIdx = this.sortedValues.length;
+    if (normalizedTo !== void 0) {
+      endIdx = findInsertPositionInArray(
+        this.sortedValues,
+        normalizedTo,
+        this.compareFn
+      );
+      if (toInclusive && endIdx < this.sortedValues.length && this.compareFn(this.sortedValues[endIdx], normalizedTo) === 0) {
+        endIdx++;
+      }
+    }
+    for (let i = startIdx; i < endIdx; i++) {
+      const keys = this.valueMap.get(this.sortedValues[i]);
+      if (keys) {
+        keys.forEach((key) => result.add(key));
+      }
+    }
+    return result;
+  }
+  /**
+   * Performs a reversed range query
+   */
+  rangeQueryReversed(options = {}) {
+    const { from, to, fromInclusive = true, toInclusive = true } = options;
+    const swappedFrom = to ?? (this.sortedValues.length > 0 ? this.sortedValues[this.sortedValues.length - 1] : void 0);
+    const swappedTo = from ?? (this.sortedValues.length > 0 ? this.sortedValues[0] : void 0);
+    return this.rangeQuery({
+      from: swappedFrom,
+      to: swappedTo,
+      fromInclusive: toInclusive,
+      toInclusive: fromInclusive
+    });
+  }
+  /**
+   * Returns the next n items in sorted order
+   */
+  take(n, from, filterFn) {
+    const result = [];
+    let startIdx = 0;
+    if (from !== void 0) {
+      const normalizedFrom = normalizeValue(from);
+      startIdx = findInsertPositionInArray(
+        this.sortedValues,
+        normalizedFrom,
+        this.compareFn
+      );
+      while (startIdx < this.sortedValues.length && this.compareFn(this.sortedValues[startIdx], normalizedFrom) <= 0) {
+        startIdx++;
+      }
+    }
+    for (let i = startIdx; i < this.sortedValues.length && result.length < n; i++) {
+      const keys = this.valueMap.get(this.sortedValues[i]);
+      if (keys) {
+        for (const key of keys) {
+          if (result.length >= n) break;
+          if (!filterFn || filterFn(key)) {
+            result.push(key);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Returns the next n items in reverse sorted order
+   */
+  takeReversed(n, from, filterFn) {
+    const result = [];
+    let startIdx = this.sortedValues.length - 1;
+    if (from !== void 0) {
+      const normalizedFrom = normalizeValue(from);
+      startIdx = findInsertPositionInArray(
+        this.sortedValues,
+        normalizedFrom,
+        this.compareFn
+      ) - 1;
+      while (startIdx >= 0 && this.compareFn(this.sortedValues[startIdx], normalizedFrom) >= 0) {
+        startIdx--;
+      }
+    }
+    for (let i = startIdx; i >= 0 && result.length < n; i--) {
+      const keys = this.valueMap.get(this.sortedValues[i]);
+      if (keys) {
+        for (const key of keys) {
+          if (result.length >= n) break;
+          if (!filterFn || filterFn(key)) {
+            result.push(key);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Returns the first n items in sorted order (from the start)
+   */
+  takeFromStart(n, filterFn) {
+    const result = [];
+    for (let i = 0; i < this.sortedValues.length && result.length < n; i++) {
+      const keys = this.valueMap.get(this.sortedValues[i]);
+      if (keys) {
+        for (const key of keys) {
+          if (result.length >= n) break;
+          if (!filterFn || filterFn(key)) {
+            result.push(key);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Returns the first n items in reverse sorted order (from the end)
+   */
+  takeReversedFromEnd(n, filterFn) {
+    const result = [];
+    for (let i = this.sortedValues.length - 1; i >= 0 && result.length < n; i--) {
+      const keys = this.valueMap.get(this.sortedValues[i]);
+      if (keys) {
+        for (const key of keys) {
+          if (result.length >= n) break;
+          if (!filterFn || filterFn(key)) {
+            result.push(key);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Performs an IN array lookup - O(k) where k is values.length
+   */
+  inArrayLookup(values) {
+    const result = /* @__PURE__ */ new Set();
+    for (const value of values) {
+      const normalizedValue = normalizeValue(value);
+      const keys = this.valueMap.get(normalizedValue);
+      if (keys) {
+        keys.forEach((key) => result.add(key));
+      }
+    }
+    return result;
+  }
+  // Getter methods for testing/compatibility
+  get indexedKeysSet() {
+    return this.indexedKeys;
+  }
+  get orderedEntriesArray() {
+    return this.sortedValues.map((value) => [
+      value,
+      this.valueMap.get(value) ?? /* @__PURE__ */ new Set()
+    ]);
+  }
+  get orderedEntriesArrayReversed() {
+    const result = [];
+    for (let i = this.sortedValues.length - 1; i >= 0; i--) {
+      const value = this.sortedValues[i];
+      result.push([value, this.valueMap.get(value) ?? /* @__PURE__ */ new Set()]);
+    }
+    return result;
+  }
+  get valueMapData() {
+    return this.valueMap;
+  }
+}
+export {
+  BasicIndex
+};
+//# sourceMappingURL=basic-index.js.map

package/dist/esm/indexes/basic-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-index.js","sources":["../../../src/indexes/basic-index.ts"],"sourcesContent":["import { defaultComparator, normalizeValue } from '../utils/comparison.js'\nimport {\n  deleteInSortedArray,\n  findInsertPositionInArray,\n} from '../utils/array-utils.js'\nimport { BaseIndex } from './base-index.js'\nimport type { CompareOptions } from '../query/builder/types.js'\nimport type { BasicExpression } from '../query/ir.js'\nimport type { IndexOperation } from './base-index.js'\n\n/**\n * Options for range queries\n */\nexport interface RangeQueryOptions {\n  from?: any\n  to?: any\n  fromInclusive?: boolean\n  toInclusive?: boolean\n}\n\n/**\n * Options for Basic index\n */\nexport interface BasicIndexOptions {\n  compareFn?: (a: any, b: any) => number\n  compareOptions?: CompareOptions\n}\n\n/**\n * Basic index using Map + sorted Array.\n *\n * - Map for O(1) equality lookups\n * - Sorted Array for O(log n) range queries via binary search\n * - O(n) updates to maintain sort order\n *\n * Simpler and smaller than BTreeIndex, good for read-heavy workloads.\n * Use BTreeIndex for write-heavy workloads with large collections.\n */\nexport class BasicIndex<\n  TKey extends string | number = string | number,\n> extends BaseIndex<TKey> {\n  public readonly supportedOperations = new Set<IndexOperation>([\n    `eq`,\n    `gt`,\n    `gte`,\n    `lt`,\n    `lte`,\n    `in`,\n  ])\n\n  // Map for O(1) equality lookups: indexedValue -> Set of PKs\n  private valueMap = new Map<any, Set<TKey>>()\n  // Sorted array of unique indexed values for range queries\n  private sortedValues: Array<any> = []\n  // Set of all indexed PKs\n  private indexedKeys = new Set<TKey>()\n  // Comparator function\n  private compareFn: (a: any, b: any) => number = defaultComparator\n\n  constructor(\n    id: number,\n    expression: BasicExpression,\n    name?: string,\n    options?: any,\n  ) {\n    super(id, expression, name, options)\n    this.compareFn = options?.compareFn ?? defaultComparator\n    if (options?.compareOptions) {\n      this.compareOptions = options!.compareOptions\n    }\n  }\n\n  protected initialize(_options?: BasicIndexOptions): void {}\n\n  /**\n   * Adds a value to the index\n   */\n  add(key: TKey, item: any): void {\n    let indexedValue: any\n    try {\n      indexedValue = this.evaluateIndexExpression(item)\n    } catch (error) {\n      throw new Error(\n        `Failed to evaluate index expression for key ${key}: ${error}`,\n        { cause: error },\n      )\n    }\n\n    const normalizedValue = normalizeValue(indexedValue)\n\n    if (this.valueMap.has(normalizedValue)) {\n      // Value already exists, just add the key to the set\n      this.valueMap.get(normalizedValue)!.add(key)\n    } else {\n      // New value - add to map and insert into sorted array\n      this.valueMap.set(normalizedValue, new Set([key]))\n\n      // Insert into sorted position\n      const insertIdx = findInsertPositionInArray(\n        this.sortedValues,\n        normalizedValue,\n        this.compareFn,\n      )\n      this.sortedValues.splice(insertIdx, 0, normalizedValue)\n    }\n\n    this.indexedKeys.add(key)\n    this.updateTimestamp()\n  }\n\n  /**\n   * Removes a value from the index\n   */\n  remove(key: TKey, item: any): void {\n    let indexedValue: any\n    try {\n      indexedValue = this.evaluateIndexExpression(item)\n    } catch (error) {\n      console.warn(\n        `Failed to evaluate index expression for key ${key} during removal:`,\n        error,\n      )\n      this.indexedKeys.delete(key)\n      this.updateTimestamp()\n      return\n    }\n\n    const normalizedValue = normalizeValue(indexedValue)\n\n    if (this.valueMap.has(normalizedValue)) {\n      const keySet = this.valueMap.get(normalizedValue)!\n      keySet.delete(key)\n\n      if (keySet.size === 0) {\n        // No more keys for this value, remove from map and sorted array\n        this.valueMap.delete(normalizedValue)\n        deleteInSortedArray(this.sortedValues, normalizedValue, this.compareFn)\n      }\n    }\n\n    this.indexedKeys.delete(key)\n    this.updateTimestamp()\n  }\n\n  /**\n   * Updates a value in the index\n   */\n  update(key: TKey, oldItem: any, newItem: any): void {\n    this.remove(key, oldItem)\n    this.add(key, newItem)\n  }\n\n  /**\n   * Builds the index from a collection of entries\n   */\n  build(entries: Iterable<[TKey, any]>): void {\n    this.clear()\n\n    // Collect all entries first\n    const entriesArray: Array<{ key: TKey; value: any }> = []\n    for (const [key, item] of entries) {\n      let indexedValue: any\n      try {\n        indexedValue = this.evaluateIndexExpression(item)\n      } catch (error) {\n        throw new Error(\n          `Failed to evaluate index expression for key ${key}: ${error}`,\n          { cause: error },\n        )\n      }\n      entriesArray.push({ key, value: normalizeValue(indexedValue) })\n      this.indexedKeys.add(key)\n    }\n\n    // Group by value\n    for (const { key, value } of entriesArray) {\n      if (this.valueMap.has(value)) {\n        this.valueMap.get(value)!.add(key)\n      } else {\n        this.valueMap.set(value, new Set([key]))\n      }\n    }\n\n    // Build sorted array from unique values\n    this.sortedValues = Array.from(this.valueMap.keys()).sort(this.compareFn)\n\n    this.updateTimestamp()\n  }\n\n  /**\n   * Clears all data from the index\n   */\n  clear(): void {\n    this.valueMap.clear()\n    this.sortedValues = []\n    this.indexedKeys.clear()\n    this.updateTimestamp()\n  }\n\n  /**\n   * Performs a lookup operation\n   */\n  lookup(operation: IndexOperation, value: any): Set<TKey> {\n    const startTime = performance.now()\n\n    let result: Set<TKey>\n\n    switch (operation) {\n      case `eq`:\n        result = this.equalityLookup(value)\n        break\n      case `gt`:\n        result = this.rangeQuery({ from: value, fromInclusive: false })\n        break\n      case `gte`:\n        result = this.rangeQuery({ from: value, fromInclusive: true })\n        break\n      case `lt`:\n        result = this.rangeQuery({ to: value, toInclusive: false })\n        break\n      case `lte`:\n        result = this.rangeQuery({ to: value, toInclusive: true })\n        break\n      case `in`:\n        result = this.inArrayLookup(value)\n        break\n      default:\n        throw new Error(`Operation ${operation} not supported by BasicIndex`)\n    }\n\n    this.trackLookup(startTime)\n    return result\n  }\n\n  /**\n   * Gets the number of indexed keys\n   */\n  get keyCount(): number {\n    return this.indexedKeys.size\n  }\n\n  /**\n   * Performs an equality lookup - O(1)\n   */\n  equalityLookup(value: any): Set<TKey> {\n    const normalizedValue = normalizeValue(value)\n    return this.valueMap.get(normalizedValue) ?? new Set()\n  }\n\n  /**\n   * Performs a range query using binary search - O(log n + m)\n   */\n  rangeQuery(options: RangeQueryOptions = {}): Set<TKey> {\n    const { from, to, fromInclusive = true, toInclusive = true } = options\n    const result = new Set<TKey>()\n\n    if (this.sortedValues.length === 0) {\n      return result\n    }\n\n    const normalizedFrom = normalizeValue(from)\n    const normalizedTo = normalizeValue(to)\n\n    // Find start index\n    let startIdx = 0\n    if (normalizedFrom !== undefined) {\n      startIdx = findInsertPositionInArray(\n        this.sortedValues,\n        normalizedFrom,\n        this.compareFn,\n      )\n      // If not inclusive and we found exact match, skip it\n      if (\n        !fromInclusive &&\n        startIdx < this.sortedValues.length &&\n        this.compareFn(this.sortedValues[startIdx], normalizedFrom) === 0\n      ) {\n        startIdx++\n      }\n    }\n\n    // Find end index\n    let endIdx = this.sortedValues.length\n    if (normalizedTo !== undefined) {\n      endIdx = findInsertPositionInArray(\n        this.sortedValues,\n        normalizedTo,\n        this.compareFn,\n      )\n      // If inclusive and we found the value, include it\n      if (\n        toInclusive &&\n        endIdx < this.sortedValues.length &&\n        this.compareFn(this.sortedValues[endIdx], normalizedTo) === 0\n      ) {\n        endIdx++\n      }\n    }\n\n    // Collect all keys in range\n    for (let i = startIdx; i < endIdx; i++) {\n      const keys = this.valueMap.get(this.sortedValues[i])\n      if (keys) {\n        keys.forEach((key) => result.add(key))\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Performs a reversed range query\n   */\n  rangeQueryReversed(options: RangeQueryOptions = {}): Set<TKey> {\n    const { from, to, fromInclusive = true, toInclusive = true } = options\n\n    // Swap from/to and fromInclusive/toInclusive to handle reversed ranges\n    // If to is undefined, we want to start from the end (max value)\n    // If from is undefined, we want to end at the beginning (min value)\n    const swappedFrom =\n      to ??\n      (this.sortedValues.length > 0\n        ? this.sortedValues[this.sortedValues.length - 1]\n        : undefined)\n    const swappedTo =\n      from ?? (this.sortedValues.length > 0 ? this.sortedValues[0] : undefined)\n\n    return this.rangeQuery({\n      from: swappedFrom,\n      to: swappedTo,\n      fromInclusive: toInclusive,\n      toInclusive: fromInclusive,\n    })\n  }\n\n  /**\n   * Returns the next n items in sorted order\n   */\n  take(n: number, from?: any, filterFn?: (key: TKey) => boolean): Array<TKey> {\n    const result: Array<TKey> = []\n\n    let startIdx = 0\n    if (from !== undefined) {\n      const normalizedFrom = normalizeValue(from)\n      startIdx = findInsertPositionInArray(\n        this.sortedValues,\n        normalizedFrom,\n        this.compareFn,\n      )\n      // Skip past the 'from' value (exclusive)\n      while (\n        startIdx < this.sortedValues.length &&\n        this.compareFn(this.sortedValues[startIdx], normalizedFrom) <= 0\n      ) {\n        startIdx++\n      }\n    }\n\n    for (\n      let i = startIdx;\n      i < this.sortedValues.length && result.length < n;\n      i++\n    ) {\n      const keys = this.valueMap.get(this.sortedValues[i])\n      if (keys) {\n        for (const key of keys) {\n          if (result.length >= n) break\n          if (!filterFn || filterFn(key)) {\n            result.push(key)\n          }\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Returns the next n items in reverse sorted order\n   */\n  takeReversed(\n    n: number,\n    from?: any,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey> {\n    const result: Array<TKey> = []\n\n    let startIdx = this.sortedValues.length - 1\n    if (from !== undefined) {\n      const normalizedFrom = normalizeValue(from)\n      startIdx =\n        findInsertPositionInArray(\n          this.sortedValues,\n          normalizedFrom,\n          this.compareFn,\n        ) - 1\n      // Skip past the 'from' value (exclusive)\n      while (\n        startIdx >= 0 &&\n        this.compareFn(this.sortedValues[startIdx], normalizedFrom) >= 0\n      ) {\n        startIdx--\n      }\n    }\n\n    for (let i = startIdx; i >= 0 && result.length < n; i--) {\n      const keys = this.valueMap.get(this.sortedValues[i])\n      if (keys) {\n        for (const key of keys) {\n          if (result.length >= n) break\n          if (!filterFn || filterFn(key)) {\n            result.push(key)\n          }\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Returns the first n items in sorted order (from the start)\n   */\n  takeFromStart(n: number, filterFn?: (key: TKey) => boolean): Array<TKey> {\n    const result: Array<TKey> = []\n    for (let i = 0; i < this.sortedValues.length && result.length < n; i++) {\n      const keys = this.valueMap.get(this.sortedValues[i])\n      if (keys) {\n        for (const key of keys) {\n          if (result.length >= n) break\n          if (!filterFn || filterFn(key)) {\n            result.push(key)\n          }\n        }\n      }\n    }\n    return result\n  }\n\n  /**\n   * Returns the first n items in reverse sorted order (from the end)\n   */\n  takeReversedFromEnd(\n    n: number,\n    filterFn?: (key: TKey) => boolean,\n  ): Array<TKey> {\n    const result: Array<TKey> = []\n    for (\n      let i = this.sortedValues.length - 1;\n      i >= 0 && result.length < n;\n      i--\n    ) {\n      const keys = this.valueMap.get(this.sortedValues[i])\n      if (keys) {\n        for (const key of keys) {\n          if (result.length >= n) break\n          if (!filterFn || filterFn(key)) {\n            result.push(key)\n          }\n        }\n      }\n    }\n    return result\n  }\n\n  /**\n   * Performs an IN array lookup - O(k) where k is values.length\n   */\n  inArrayLookup(values: Array<any>): Set<TKey> {\n    const result = new Set<TKey>()\n\n    for (const value of values) {\n      const normalizedValue = normalizeValue(value)\n      const keys = this.valueMap.get(normalizedValue)\n      if (keys) {\n        keys.forEach((key) => result.add(key))\n      }\n    }\n\n    return result\n  }\n\n  // Getter methods for testing/compatibility\n  get indexedKeysSet(): Set<TKey> {\n    return this.indexedKeys\n  }\n\n  get orderedEntriesArray(): Array<[any, Set<TKey>]> {\n    return this.sortedValues.map((value) => [\n      value,\n      this.valueMap.get(value) ?? new Set(),\n    ])\n  }\n\n  get orderedEntriesArrayReversed(): Array<[any, Set<TKey>]> {\n    const result: Array<[any, Set<TKey>]> = []\n    for (let i = this.sortedValues.length - 1; i >= 0; i--) {\n      const value = this.sortedValues[i]\n      result.push([value, this.valueMap.get(value) ?? new Set()])\n    }\n    return result\n  }\n\n  get valueMapData(): Map<any, Set<TKey>> {\n    return this.valueMap\n  }\n}\n"],"names":[],"mappings":"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"}