@signaldb/core 1.7.0 → 2.0.0-beta.0

package/dist/Collection/index.d.ts

@@ -1,44 +1,41 @@
-import type MemoryAdapter from '../types/MemoryAdapter';
 import type ReactivityAdapter from '../types/ReactivityAdapter';
-import type PersistenceAdapter from '../types/PersistenceAdapter';
 import EventEmitter from '../utils/EventEmitter';
 import type Selector from '../types/Selector';
 import type Modifier from '../types/Modifier';
-import type IndexProvider from '../types/IndexProvider';
+import type DataAdapter from '../DataAdapter';
+import type { QueryOptions } from '../DataAdapter';
+import type StorageAdapter from '../types/StorageAdapter';
 import Cursor from './Cursor';
 import type { BaseItem, FindOptions, Transform } from './types';
 export type { BaseItem, Transform, SortSpecifier, FieldSpecifier, FindOptions } from './types';
 export type { CursorOptions } from './Cursor';
 export type { ObserveCallbacks } from './Observer';
-export { default as createIndex } from './createIndex';
+export { default as createIndex } from '../createIndex';
 export interface CollectionOptions<T extends BaseItem<I>, I, U = T> {
+    /**
+     * @deprecated Use new constructor parameters instead.
+     */
     name?: string;
-    memory?: MemoryAdapter;
+    /**
+     * @deprecated Use `DataAdapter` options instead.
+     */
+    persistence?: StorageAdapter<T, I>;
+    primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
     reactivity?: ReactivityAdapter;
     transform?: Transform<T, U>;
-    persistence?: PersistenceAdapter<T, I>;
-    indices?: IndexProvider<T, I>[];
+    indices?: string[];
     enableDebugMode?: boolean;
     fieldTracking?: boolean;
-    primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
 }
 interface CollectionEvents<T extends BaseItem, U = T> {
     'added': (item: T) => void;
     'changed': (item: T, modifier: Modifier<T>) => void;
     'removed': (item: T) => void;
-    'persistence.init': () => void;
-    'persistence.error': (error: Error) => void;
-    'persistence.transmitted': () => void;
-    'persistence.received': () => void;
-    'persistence.pullStarted': () => void;
-    'persistence.pullCompleted': () => void;
-    'persistence.pushStarted': () => void;
-    'persistence.pushCompleted': () => void;
-    'observer.created': <O extends FindOptions<T>>(selector?: Selector<T>, options?: O) => void;
-    'observer.disposed': <O extends FindOptions<T>>(selector?: Selector<T>, options?: O) => void;
+    'observer.created': <O extends QueryOptions<T>>(selector?: Selector<T>, options?: O) => void;
+    'observer.disposed': <O extends QueryOptions<T>>(selector?: Selector<T>, options?: O) => void;
     'getItems': (selector: Selector<T> | undefined) => void;
-    'find': <O extends FindOptions<T>>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U>) => void;
-    'findOne': <O extends FindOptions<T>>(selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
+    'find': <O extends FindOptions<T, Async>, Async extends boolean>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U, Async>) => void;
+    'findOne': <O extends QueryOptions<T>>(selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
     'insert': (item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
     'updateOne': (selector: Selector<T>, modifier: Modifier<T>) => void;
     'updateMany': (selector: Selector<T>, modifier: Modifier<T>) => void;
@@ -47,8 +44,8 @@ interface CollectionEvents<T extends BaseItem, U = T> {
     'removeMany': (selector: Selector<T>) => void;
     'validate': (item: T) => void;
     '_debug.getItems': (callstack: string, selector: Selector<T> | undefined, measuredTime: number) => void;
-    '_debug.find': <O extends FindOptions<T>>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U>) => void;
-    '_debug.findOne': <O extends FindOptions<T>>(callstack: string, selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
+    '_debug.find': <O extends FindOptions<T, Async>, Async extends boolean>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<T, U, Async>) => void;
+    '_debug.findOne': <O extends FindOptions<T, Async>, Async extends boolean>(callstack: string, selector: Selector<T>, options: O | undefined, item: U | undefined) => void;
     '_debug.insert': (callstack: string, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
     '_debug.updateOne': (callstack: string, selector: Selector<T>, modifier: Modifier<T>) => void;
     '_debug.updateMany': (callstack: string, selector: Selector<T>, modifier: Modifier<T>) => void;
@@ -88,29 +85,31 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * while deferring index rebuilding until all operations in the batch are completed.
      * This improves performance by avoiding repetitive index recalculations and
      * provides atomicity for the batch of operations.
+     * Supports both synchronous and asynchronous callbacks.
      * @param callback - The batch operation to execute.
+     * @returns A promise if the callback returns a promise, otherwise `void`.
      */
-    static batch(callback: () => void): void;
+    static batch<ReturnType>(callback: () => Promise<ReturnType>): Promise<void>;
+    static batch<ReturnType>(callback: () => ReturnType): void;
     readonly name: string;
+    private backend;
     private options;
-    private persistenceAdapter;
     private isPullingSignal;
     private isPushingSignal;
-    private indexProviders;
-    private indicesOutdated;
-    private idIndex;
+    private readySignal;
     private debugMode;
     private batchOperationInProgress;
     private isDisposed;
     private postBatchCallbacks;
     private fieldTracking;
-    private persistenceReadyPromise;
     /**
      * Initializes a new instance of the `Collection` class with optional configuration.
      * Sets up memory, persistence, reactivity, and indices as specified in the options.
      * @template T - The type of the items stored in the collection.
      * @template I - The type of the unique identifier for the items.
      * @template U - The transformed item type after applying transformations (default is T).
+     * @param name - The name of the collection.
+     * @param dataAdapter - The data adapter for creating the collection backend.
      * @param options - Optional configuration for the collection.
      * @param options.name - An optional name for the collection.
      * @param options.memory - The in-memory adapter for storing items.
@@ -122,6 +121,8 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
      */
     constructor(options?: CollectionOptions<T, I, U>);
+    constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, U>);
+    isBatchOperationInProgress(): boolean;
     /**
      * Checks whether the collection is currently performing a pull operation
      * ⚡️ this function is reactive!
@@ -172,18 +173,19 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      *
      * collection.insert({ name: 'Item 1' })
      */
-    isReady(): Promise<void>;
+    ready(): Promise<void>;
+    /**
+     * Checks if the collection is ready.
+     * ⚡️ this function is reactive!
+     * @returns A boolean indicating whether the collection is ready.
+     */
+    isReady(): boolean;
     private profile;
     private executeInDebugMode;
-    private rebuildIndices;
-    private rebuildAllIndices;
-    private getIndexInfo;
-    private getItemAndIndex;
-    private deleteFromIdIndex;
-    private memory;
-    private memoryArray;
     private transform;
+    private getItem;
     private getItems;
+    private withPushState;
     /**
      * Disposes the collection, unregisters persistence adapters, clears memory, and
      * cleans up all resources used by the collection.
@@ -198,37 +200,41 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @param [options] - Options for the find operation, such as limit and sort.
      * @returns A cursor to fetch and observe the matching items.
      */
-    find<O extends FindOptions<T>>(selector?: Selector<T>, options?: O): Cursor<T, U>;
+    find<Async extends boolean = false, O extends FindOptions<T, Async> = FindOptions<T, Async>>(selector?: Selector<T>, options?: O): Cursor<T, U, Async>;
     /**
      * Finds a single item in the collection based on a selector and optional options.
      * ⚡️ this function is reactive!
      * Returns the found item or undefined if no item matches.
+     * @template Async - Whether to perform the operation asynchronously.
      * @template O - The options type for the find operation.
      * @param selector - The criteria to select the item.
      * @param [options] - Options for the find operation, such as projection.
      * @returns The found item or `undefined`.
      */
-    findOne<O extends Omit<FindOptions<T>, 'limit'>>(selector: Selector<T>, options?: O): NonNullable<U> | undefined;
+    findOne<Async extends boolean = false, O extends Omit<FindOptions<T, Async>, 'limit'> = Omit<FindOptions<T, Async>, 'limit'>>(selector: Selector<T>, options?: O): Async extends true ? Promise<U | undefined> : U | undefined;
     /**
      * Performs a batch operation, deferring index rebuilds and allowing multiple
      * modifications to be made atomically. Executes any post-batch callbacks afterwards.
      * @param callback - The batch operation to execute.
+     * @returns A promise if the callback returns a promise, otherwise void.
      */
-    batch(callback: () => void): void;
+    batch<ReturnType>(callback: () => Promise<ReturnType>): Promise<void>;
+    batch<ReturnType>(callback: () => ReturnType): void;
+    onPostBatch(callback: () => void): void;
     /**
      * Inserts a single item into the collection. Generates a unique ID if not provided.
      * @param item - The item to insert.
      * @returns The ID of the inserted item.
      * @throws {Error} If the collection is disposed or the item has an invalid ID.
      */
-    insert(item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): I;
+    insert(item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): Promise<I>;
     /**
      * Inserts multiple items into the collection. Generates unique IDs for items if not provided.
      * @param items - The items to insert.
      * @returns An array of IDs of the inserted items.
      * @throws {Error} If the collection is disposed or the items are invalid.
      */
-    insertMany(items: Array<Omit<T, 'id'> & Partial<Pick<T, 'id'>>>): I[];
+    insertMany(items: Array<Omit<T, 'id'> & Partial<Pick<T, 'id'>>>): Promise<I[]>;
     /**
      * Updates a single item in the collection that matches the given selector.
      * @param selector - The criteria to select the item to update.
@@ -240,7 +246,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      */
     updateOne(selector: Selector<T>, modifier: Modifier<T>, options?: {
         upsert?: boolean;
-    }): 0 | 1;
+    }): Promise<number>;
     /**
      * Updates multiple items in the collection that match the given selector.
      * @param selector - The criteria to select the items to update.
@@ -252,7 +258,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      */
     updateMany(selector: Selector<T>, modifier: Modifier<T>, options?: {
         upsert?: boolean;
-    }): number;
+    }): Promise<number>;
     /**
      * Replaces a single item in the collection that matches the given selector.
      * @param selector - The criteria to select the item to replace.
@@ -264,19 +270,19 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      */
     replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>, options?: {
         upsert?: boolean;
-    }): 0 | 1;
+    }): Promise<number>;
     /**
      * Removes a single item from the collection that matches the given selector.
      * @param selector - The criteria to select the item to remove.
      * @returns The number of items removed (0 or 1).
      * @throws {Error} If the collection is disposed or invalid arguments are provided.
      */
-    removeOne(selector: Selector<T>): 0 | 1;
+    removeOne(selector: Selector<T>): Promise<number>;
     /**
      * Removes multiple items from the collection that match the given selector.
      * @param selector - The criteria to select the items to remove.
      * @returns The number of items removed.
      * @throws {Error} If the collection is disposed or invalid arguments are provided.
      */
-    removeMany(selector: Selector<T>): number;
+    removeMany(selector: Selector<T>): Promise<number>;
 }

package/dist/Collection/types.d.ts

@@ -1,3 +1,4 @@
+import type { QueryOptions } from '../DataAdapter';
 import type ReactivityAdapter from '../types/ReactivityAdapter';
 export type BaseItem<I = any> = {
     id: I;
@@ -9,17 +10,11 @@ export type SortSpecifier<T> = {
 export type FieldSpecifier<T> = {
     [P in keyof T]?: 0 | 1;
 } & Record<string, 0 | 1>;
-export interface FindOptions<T extends BaseItem> {
-    /** Sort order (default: natural order) */
-    sort?: SortSpecifier<T> | undefined;
-    /** Number of results to skip at the beginning */
-    skip?: number | undefined;
-    /** Maximum number of results to return */
-    limit?: number | undefined;
-    /** Dictionary of fields to return or exclude. */
-    fields?: FieldSpecifier<T> | undefined;
+export interface FindOptions<T extends BaseItem, Async extends boolean> extends QueryOptions<T> {
     /** pass `false` to disable reactivity */
     reactive?: ReactivityAdapter | false;
     /** pass `true` to enable automatic field-level reactitivy */
     fieldTracking?: boolean;
+    /** pass `true` to execute the query asynchronously */
+    async?: Async;
 }

package/dist/DataAdapter.d.ts

@@ -0,0 +1,33 @@
+import type { BaseItem, FieldSpecifier, SortSpecifier } from './Collection';
+import type Collection from './Collection';
+import type Modifier from './types/Modifier';
+import type Selector from './types/Selector';
+export interface QueryOptions<T extends BaseItem> {
+    /** Sort order (default: natural order) */
+    sort?: SortSpecifier<T> | undefined;
+    /** Number of results to skip at the beginning */
+    skip?: number | undefined;
+    /** Maximum number of results to return */
+    limit?: number | undefined;
+    /** Dictionary of fields to return or exclude. */
+    fields?: FieldSpecifier<T> | undefined;
+}
+export interface CollectionBackend<T extends BaseItem<I>, I> {
+    insert(item: T): Promise<T>;
+    updateOne(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
+    updateMany(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
+    replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): Promise<T[]>;
+    removeOne(selector: Selector<T>): Promise<T[]>;
+    removeMany(selector: Selector<T>): Promise<T[]>;
+    registerQuery<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): void;
+    unregisterQuery<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): void;
+    getQueryState<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): 'active' | 'complete' | 'error';
+    getQueryError<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): Error | null;
+    getQueryResult<O extends QueryOptions<T>>(selector: Selector<T>, options?: O): T[];
+    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T> | undefined, options: O | undefined, callback: (state: 'active' | 'complete' | 'error') => void): () => void;
+    dispose(): Promise<void>;
+    isReady(): Promise<void>;
+}
+export default interface DataAdapter {
+    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+}

package/dist/DefaultDataAdapter.d.ts

@@ -0,0 +1,32 @@
+import type { BaseItem } from './Collection';
+import type Collection from './Collection';
+import type DataAdapter from './DataAdapter';
+import type { CollectionBackend } from './DataAdapter';
+import type StorageAdapter from './types/StorageAdapter';
+interface DefaultDataAdapterOptions {
+    storage?: (name: string) => StorageAdapter<any, any> | undefined;
+    onError?: (name: string, error: Error) => void;
+}
+export default class DefaultDataAdapter implements DataAdapter {
+    private items;
+    private options;
+    private storageAdapters;
+    private indices;
+    private activeQueries;
+    private queryEmitters;
+    private queuedQueryUpdates;
+    private cachedQueryResults;
+    constructor(options?: DefaultDataAdapterOptions);
+    private ensureStorageAdapter;
+    private rebuildIndices;
+    private setupStorageAdapter;
+    private getIndexInfo;
+    private applyIndexDeltas;
+    private getItem;
+    private queryItems;
+    private executeQuery;
+    private flushQueuedQueryUpdates;
+    private updateQueries;
+    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+}
+export {};

package/dist/WorkerDataAdapter.d.ts

@@ -0,0 +1,22 @@
+import type { BaseItem } from './Collection';
+import type Collection from './Collection';
+import type DataAdapter from './DataAdapter';
+import type { CollectionBackend } from './DataAdapter';
+interface WorkerDataAdapterOptions {
+    id?: string;
+}
+export default class WorkerDataAdapter implements DataAdapter {
+    private worker;
+    private options;
+    private id;
+    private isDisposed;
+    private workerReady;
+    private collectionReady;
+    private queries;
+    constructor(worker: Worker, options: WorkerDataAdapterOptions);
+    private exec;
+    private queryListeners;
+    private updateQuery;
+    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices?: string[]): CollectionBackend<T, I>;
+}
+export {};

package/dist/WorkerDataAdapterHost.d.ts

@@ -0,0 +1,59 @@
+import type { BaseItem } from './Collection';
+import type { QueryOptions } from './DataAdapter';
+import type Modifier from './types/Modifier';
+import type StorageAdapter from './types/StorageAdapter';
+import type Selector from './types/Selector';
+interface WorkerContext {
+    addEventListener: (type: 'message', listener: (event: MessageEvent) => any) => void;
+    postMessage: (message: any) => void;
+}
+interface WorkerDataAdapterHostOptions {
+    id?: string;
+    storage: (name: string) => StorageAdapter<any, any>;
+    onError?: (error: Error) => void;
+}
+type CollectionMethods<T extends BaseItem<I>, I = any> = {
+    registerCollection: (collectionName: string, indices: string[]) => Promise<void>;
+    unregisterCollection: (collectionName: string) => Promise<void>;
+    registerQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
+    unregisterQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
+    insert: (collectionName: string, item: T) => Promise<T>;
+    updateOne: (collectionName: string, selector: Selector<T>, modifier: Modifier<T>) => Promise<T[]>;
+    updateMany: (collectionName: string, selector: Selector<T>, modifier: Modifier<T>) => Promise<T[]>;
+    replaceOne: (collectionName: string, selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => Promise<T[]>;
+    removeOne: (collectionName: string, selector: Selector<T>) => Promise<T[]>;
+    removeMany: (collectionName: string, selector: Selector<T>) => Promise<T[]>;
+    isReady: (collectionName: string) => Promise<void>;
+};
+export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
+    private workerContext;
+    private options;
+    private id;
+    private storageAdapters;
+    private storageAdapterReady;
+    private collectionIndices;
+    private queries;
+    private onError;
+    constructor(workerContext: WorkerContext, options: WorkerDataAdapterHostOptions);
+    private respond;
+    private handleMessage;
+    private getIndexInfo;
+    private queryItems;
+    private executeQuery;
+    private ensureQuery;
+    private emitQueryUpdate;
+    private ensureStorageAdapter;
+    private checkQueryUpdates;
+    protected registerCollection: CollectionMethods<T, I>['registerCollection'];
+    protected unregisterCollection: CollectionMethods<T, I>['unregisterCollection'];
+    protected registerQuery: CollectionMethods<T, I>['registerQuery'];
+    protected unregisterQuery: CollectionMethods<T, I>['unregisterQuery'];
+    protected insert: CollectionMethods<T, I>['insert'];
+    protected updateOne: CollectionMethods<T, I>['updateOne'];
+    protected updateMany: CollectionMethods<T, I>['updateMany'];
+    protected replaceOne: CollectionMethods<T, I>['replaceOne'];
+    protected removeOne: CollectionMethods<T, I>['removeOne'];
+    protected removeMany: CollectionMethods<T, I>['removeMany'];
+    protected isReady: CollectionMethods<T, I>['isReady'];
+}
+export {};

package/dist/createIndex.d.ts

@@ -0,0 +1,7 @@
+import type { BaseItem } from './Collection/types';
+/**
+ * creates an index for a specific field
+ * @param field name of the field
+ * @returns an index provider to pass to the `indices` option of the collection constructor
+ */
+export default function createIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string): import("./types/IndexProvider").default<T, I>;

package/dist/createStorageAdapter.d.ts

@@ -0,0 +1,9 @@
+import type StorageAdapter from './types/StorageAdapter';
+/**
+ * Creates an StorageAdapter based on the given definition.
+ * @param definition - The definition of the StorageAdapter.
+ * @returns The created StorageAdapter.
+ */
+export default function createStorageAdapter<T extends {
+    id: I;
+} & Record<string, any>, I>(definition: StorageAdapter<T, I>): StorageAdapter<T, I>;

package/dist/{Collection/getIndexInfo.d.ts → getIndexInfo.d.ts}

@@ -1,41 +1,39 @@
-import type IndexProvider from '../types/IndexProvider';
-import type { FlatSelector } from '../types/Selector';
-import type Selector from '../types/Selector';
-import type { BaseItem } from './types';
+import type { AsynchronousQueryFunction, SynchronousQueryFunction } from './types/IndexProvider';
+import type { FlatSelector } from './types/Selector';
+import type Selector from './types/Selector';
+import type { BaseItem } from './Collection/types';
+type IndexInfo<T extends BaseItem<I> = BaseItem, I = any> = {
+    matched: boolean;
+    ids: I[];
+    optimizedSelector: FlatSelector<T>;
+};
 /**
  * Retrieves merged index information for a given flat selector by querying multiple
- * index providers. Combines results from all index providers to determine matched positions
+ * index providers. Combines results from all index providers to determine matched ids
  * and an optimized selector.
  * @template T - The type of the items in the collection.
  * @template I - The type of the unique identifier for the items.
- * @param indexProviders - An array of index providers to query.
+ * @param queryFunctions - An array of index providers to query.
  * @param selector - The flat selector used to filter items.
  * @returns An object containing:
  *   - `matched`: A boolean indicating if the selector matched any items.
- *   - `positions`: An array of matched item positions.
+ *   - `ids`: An array of matched item ids.
  *   - `optimizedSelector`: A flat selector optimized based on the index results.
  */
-export declare function getMergedIndexInfo<T extends BaseItem<I> = BaseItem, I = any>(indexProviders: IndexProvider<T, I>[], selector: FlatSelector<T>): {
-    matched: boolean;
-    positions: number[];
-    optimizedSelector: FlatSelector<T>;
-};
+export declare function getMergedIndexInfo<T extends BaseItem<I> = BaseItem, I = any>(queryFunctions: (SynchronousQueryFunction<T, I> | AsynchronousQueryFunction<T, I>)[], selector: FlatSelector<T>): IndexInfo<T, I> | Promise<IndexInfo<T, I>>;
 /**
  * Retrieves index information for a given complex selector by querying multiple
  * index providers. Handles nested `$and` and `$or` conditions in the selector and
  * optimizes the selector to minimize processing overhead.
  * @template T - The type of the items in the collection.
  * @template I - The type of the unique identifier for the items.
- * @param indexProviders - An array of index providers to query.
+ * @param queryFunctions - An array of index providers to query.
  * @param selector - The complex selector used to filter items.
  * @returns An object containing:
  *   - `matched`: A boolean indicating if the selector matched any items.
- *   - `positions`: An array of matched item positions.
+ *   - `ids`: An array of matched item ids.
  *   - `optimizedSelector`: A selector optimized based on the index results, with unused
  *     conditions removed.
  */
-export default function getIndexInfo<T extends BaseItem<I> = BaseItem, I = any>(indexProviders: IndexProvider<T, I>[], selector: Selector<T>): {
-    matched: boolean;
-    positions: number[];
-    optimizedSelector: Selector<T>;
-};
+export default function getIndexInfo<QueryFunction extends SynchronousQueryFunction<T, I> | AsynchronousQueryFunction<T, I>, T extends BaseItem<I> = BaseItem, I = any>(queryFunctions: QueryFunction[], selector: Selector<T>): QueryFunction extends AsynchronousQueryFunction<T, I> ? Promise<IndexInfo<T, I>> : IndexInfo<T, I>;
+export {};

package/dist/index.cjs.js

@@ -2,27 +2,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const Cursor = require("./index.cjs2.js");
 const index = require("./index.cjs3.js");
-const AutoFetchCollection = require("./index.cjs4.js");
-const combinePersistenceAdapters = require("./index.cjs5.js");
-const createIndexProvider = require("./index.cjs6.js");
-const createMemoryAdapter = require("./index.cjs7.js");
-const createPersistenceAdapter = require("./index.cjs8.js");
-const createReactivityAdapter = require("./index.cjs9.js");
-const isEqual = require("./index.cjs10.js");
-const modify = require("./index.cjs11.js");
-const randomId = require("./index.cjs12.js");
-const EventEmitter = require("./index.cjs13.js");
-const createIndex = require("./index.cjs14.js");
+const createStorageAdapter = require("./index.cjs4.js");
+const createReactivityAdapter = require("./index.cjs5.js");
+const isEqual = require("./index.cjs6.js");
+const modify = require("./index.cjs7.js");
+const randomId = require("./index.cjs8.js");
+const EventEmitter = require("./index.cjs9.js");
+const get = require("./index.cjs10.js");
+const serializeValue = require("./index.cjs11.js");
+const DefaultDataAdapter = require("./index.cjs12.js");
+const AsyncDataAdapter = require("./index.cjs13.js");
+const WorkerDataAdapter = require("./index.cjs14.js");
+const WorkerDataAdapterHost = require("./index.cjs15.js");
+const AutoFetchDataAdapter = require("./index.cjs16.js");
 exports.Cursor = Cursor.default;
 exports.Collection = index.default;
-exports.AutoFetchCollection = AutoFetchCollection;
-exports.combinePersistenceAdapters = combinePersistenceAdapters.default;
-exports.createIndexProvider = createIndexProvider;
-exports.createMemoryAdapter = createMemoryAdapter;
-exports.createPersistenceAdapter = createPersistenceAdapter;
+exports.createStorageAdapter = createStorageAdapter;
 exports.createReactivityAdapter = createReactivityAdapter;
 exports.isEqual = isEqual;
 exports.modify = modify;
 exports.randomId = randomId;
 exports.EventEmitter = EventEmitter;
-exports.createIndex = createIndex.default;
+exports.get = get;
+exports.serializeValue = serializeValue;
+exports.DefaultDataAdapter = DefaultDataAdapter;
+exports.AsyncDataAdapter = AsyncDataAdapter;
+exports.WorkerDataAdapter = WorkerDataAdapter;
+exports.WorkerDataAdapterHost = WorkerDataAdapterHost;
+exports.AutoFetchDataAdapter = AutoFetchDataAdapter;

package/dist/index.cjs10.js

@@ -1,29 +1,18 @@
 "use strict";
-function isEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (a instanceof RegExp && b instanceof RegExp)
-    return a.toString() === b.toString();
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (typeof a !== "object")
-    return false;
-  if (typeof b !== "object")
-    return false;
-  if (a === null)
-    return false;
-  if (b === null)
-    return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length)
-    return false;
-  for (const key of aKeys) {
-    if (!bKeys.includes(key))
-      return false;
-    if (!isEqual(a[key], b[key]))
-      return false;
+function get(value, path) {
+  const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+  if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) {
+    return;
   }
-  return true;
+  const segments = normalized.split(".");
+  let current = value;
+  for (const key of segments) {
+    if (current == null)
+      return;
+    current = current[key];
+  }
+  if (current === void 0)
+    return;
+  return current;
 }
-module.exports = isEqual;
+module.exports = get;

package/dist/index.cjs11.js

@@ -1,12 +1,15 @@
 "use strict";
-const mingo = require("mingo");
-const deepClone = require("./index.cjs19.js");
-function modify(item, modifier) {
-  const hasOperators = Object.keys(modifier).some((key) => key.startsWith("$"));
-  if (!hasOperators)
-    return modifier;
-  const clonedItem = deepClone.default(item);
-  mingo.update(clonedItem, modifier);
-  return clonedItem;
+function serializeValue(value) {
+  if (value == null)
+    return null;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number")
+    return value.toString();
+  if (typeof value === "boolean")
+    return value.toString();
+  if (value instanceof Date)
+    return value.toISOString();
+  return JSON.stringify(value);
 }
-module.exports = modify;
+module.exports = serializeValue;