@signaldb/sync 2.0.0-beta.7 → 2.0.0-beta.9

package/dist/core/src/Collection/index.d.ts

@@ -1,294 +0,0 @@
-import type ReactivityAdapter from '../types/ReactivityAdapter';
-import EventEmitter from '../utils/EventEmitter';
-import type Selector from '../types/Selector';
-import type Modifier from '../types/Modifier';
-import type DataAdapter from '../DataAdapter';
-import type { QueryOptions } from '../DataAdapter';
-import type StorageAdapter from '../types/StorageAdapter';
-import Cursor from './Cursor';
-import type { AsyncFindOptions, BaseItem, FindOptions, SyncFindOptions, Transform, TransformAll } from './types';
-export type { AnyFindOptions, AsyncFindOptions, BaseItem, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions, SyncFindOptions, } from './types';
-export type { CursorOptions } from './Cursor';
-export type { ObserveCallbacks } from './Observer';
-export { default as createIndex } from '../createIndex';
-export interface CollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> {
-    /**
-     * @deprecated Use new constructor parameters instead.
-     */
-    name?: string;
-    /**
-     * @deprecated Use `DataAdapter` options instead.
-     */
-    persistence?: StorageAdapter<T, I>;
-    primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
-    reactivity?: ReactivityAdapter;
-    transform?: Transform<E, U>;
-    transformAll?: TransformAll<T, E>;
-    indices?: string[];
-    enableDebugMode?: boolean;
-    fieldTracking?: boolean;
-}
-interface CollectionEvents<T extends BaseItem, E extends BaseItem = T, U = E> {
-    'added': (item: T) => void;
-    'changed': (item: T, modifier: Modifier<T>) => void;
-    'removed': (item: T) => 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': <Async extends boolean, O extends FindOptions<T, Async>>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, 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;
-    'replaceOne': (selector: Selector<T>, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
-    'removeOne': (selector: Selector<T>) => void;
-    'removeMany': (selector: Selector<T>) => void;
-    'validate': (item: T) => void;
-    '_debug.getItems': (callstack: string, selector: Selector<T> | undefined, measuredTime: number) => void;
-    '_debug.find': <Async extends boolean, O extends FindOptions<T, Async>>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, U, Async>) => void;
-    '_debug.findOne': <Async extends boolean, O extends FindOptions<T, Async>>(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;
-    '_debug.replaceOne': (callstack: string, selector: Selector<T>, item: Omit<T, 'id'> & Partial<Pick<T, 'id'>>) => void;
-    '_debug.removeOne': (callstack: string, selector: Selector<T>) => void;
-    '_debug.removeMany': (callstack: string, selector: Selector<T>) => void;
-}
-/**
- * Represents a collection of data items with support for in-memory operations,
- * persistence, reactivity, and event-based notifications. The collection provides
- * CRUD operations, observer patterns, and batch operations.
- * @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).
- */
-export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E extends BaseItem = T, U = E> extends EventEmitter<CollectionEvents<T, E, U>> {
-    private static collections;
-    private static debugMode;
-    private static batchOperationInProgress;
-    private static fieldTracking;
-    private static onCreationCallbacks;
-    private static onDisposeCallbacks;
-    static getCollections(): Collection<any, any, any, any>[];
-    static onCreation(callback: (collection: Collection<any>) => void): void;
-    static onDispose(callback: (collection: Collection<any>) => void): void;
-    /**
-     * Enables debug mode for all collections.
-     */
-    static enableDebugMode: () => void;
-    /**
-     * Enables field tracking for all collections.
-     * @param enable - A boolean indicating whether to enable field tracking.
-     */
-    static setFieldTracking: (enable: boolean) => void;
-    /**
-     * Executes a batch operation, allowing multiple modifications to the collection
-     * 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<ReturnType>(callback: () => Promise<ReturnType>): Promise<void>;
-    static batch<ReturnType>(callback: () => ReturnType): void;
-    readonly name: string;
-    private backend;
-    private options;
-    private isPullingSignal;
-    private isPushingSignal;
-    private readySignal;
-    private debugMode;
-    private batchOperationInProgress;
-    private isDisposed;
-    private postBatchCallbacks;
-    private fieldTracking;
-    private queryListenersMap;
-    /**
-     * 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.
-     * @param options.reactivity - The reactivity adapter for observing changes in the collection.
-     * @param options.transform - A transformation function to apply to items when retrieving them.
-     * @param options.persistence - The persistence adapter for saving and loading items.
-     * @param options.indices - An array of index providers for optimized querying.
-     * @param options.enableDebugMode - A boolean to enable or disable debug mode.
-     * @param options.fieldTracking - A boolean to enable or disable field tracking by default.
-     * @param options.transformAll - A function that will be able to solve the n+1 problem
-     */
-    constructor(options?: CollectionOptions<T, I, E, U>);
-    constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, E, U>);
-    isBatchOperationInProgress(): boolean;
-    /**
-     * Checks whether the collection is currently performing a pull operation
-     * ⚡️ this function is reactive!
-     * (loading data from the persistence adapter).
-     * @returns A boolean indicating if the collection is in the process of pulling data.
-     */
-    isPulling(): boolean;
-    /**
-     * Checks whether the collection is currently performing a push operation
-     * ⚡️ this function is reactive!
-     * (saving data to the persistence adapter).
-     * @returns A boolean indicating if the collection is in the process of pushing data.
-     */
-    isPushing(): boolean;
-    /**
-     * Checks whether the collection is currently performing either a pull or push operation,
-     * ⚡️ this function is reactive!
-     * indicating that it is loading or saving data.
-     * @returns A boolean indicating if the collection is in the process of loading or saving data.
-     */
-    isLoading(): boolean;
-    /**
-     * Retrieves the current debug mode status of the collection.
-     * @returns A boolean indicating whether debug mode is enabled for the collection.
-     */
-    getDebugMode(): boolean;
-    /**
-     * Enables or disables debug mode for the collection.
-     * When debug mode is enabled, additional debugging information and events are emitted.
-     * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) debug mode.
-     */
-    setDebugMode(enable: boolean): void;
-    /**
-     * Enables or disables field tracking for the collection.
-     * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) field tracking.
-     */
-    setFieldTracking(enable: boolean): void;
-    /**
-     * Resolves when the persistence adapter finished initializing
-     * and the collection is ready to be used.
-     * @returns A promise that resolves when the collection is ready.
-     * @example
-     * ```ts
-     * const collection = new Collection({
-     *   persistence: // ...
-     * })
-     * await collection.isReady()
-     *
-     * collection.insert({ name: 'Item 1' })
-     */
-    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 transform;
-    private transformAll;
-    private getItem;
-    private getItems;
-    private withPushState;
-    private queryListeners;
-    /**
-     * Disposes the collection, unregisters persistence adapters, clears memory, and
-     * cleans up all resources used by the collection.
-     * @returns A promise that resolves when the collection is disposed.
-     */
-    dispose(): Promise<void>;
-    /**
-     * Finds multiple items in the collection based on a selector and optional options.
-     * Returns a cursor for reactive data queries.
-     * @param [selector] - The criteria to select items.
-     * @param [options] - Options for the find operation, such as limit and sort.
-     * @returns A cursor to fetch and observe the matching items.
-     */
-    find(selector?: Selector<T>, options?: SyncFindOptions<T>): Cursor<E, U, false>;
-    find(selector: Selector<T> | undefined, options: AsyncFindOptions<T>): Cursor<E, U, true>;
-    find(selector?: Selector<T>, options?: FindOptions<T, boolean>): Cursor<E, U, boolean>;
-    /**
-     * 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.
-     * @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(selector: Selector<T>, options?: Omit<SyncFindOptions<T>, 'limit'>): U | undefined;
-    findOne(selector: Selector<T>, options: Omit<AsyncFindOptions<T>, 'limit'>): Promise<U | undefined>;
-    findOne(selector: Selector<T>, options?: Omit<FindOptions<T, boolean>, 'limit'>): 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<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'>>): 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'>>>): Promise<I[]>;
-    /**
-     * Updates a single item in the collection that matches the given selector.
-     * @param selector - The criteria to select the item to update.
-     * @param modifier - The modifications to apply to the item.
-     * @param [options] - Optional settings for the update operation.
-     * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
-     * @returns The number of items updated (0 or 1).
-     * @throws {Error} If the collection is disposed or invalid arguments are provided.
-     */
-    updateOne(selector: Selector<T>, modifier: Modifier<T>, options?: {
-        upsert?: boolean;
-    }): Promise<number>;
-    /**
-     * Updates multiple items in the collection that match the given selector.
-     * @param selector - The criteria to select the items to update.
-     * @param modifier - The modifications to apply to the items.
-     * @param [options] - Optional settings for the update operation.
-     * @param [options.upsert] - If `true`, creates new items if no items match the selector.
-     * @returns The number of items updated.
-     * @throws {Error} If the collection is disposed or invalid arguments are provided.
-     */
-    updateMany(selector: Selector<T>, modifier: Modifier<T>, options?: {
-        upsert?: boolean;
-    }): Promise<number>;
-    /**
-     * Replaces a single item in the collection that matches the given selector.
-     * @param selector - The criteria to select the item to replace.
-     * @param replacement - The item to replace the selected item with.
-     * @param [options] - Optional settings for the replace operation.
-     * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
-     * @returns The number of items replaced (0 or 1).
-     * @throws {Error} If the collection is disposed or invalid arguments are provided.
-     */
-    replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>, options?: {
-        upsert?: boolean;
-    }): 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>): 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>): Promise<number>;
-}

package/dist/core/src/Collection/types.d.ts

@@ -1,28 +0,0 @@
-import type { QueryOptions } from '../DataAdapter';
-import type ReactivityAdapter from '../types/ReactivityAdapter';
-export type BaseItem<I = any> = {
-    id: I;
-} & Record<string, any>;
-export type Transform<T, U = T> = ((document: T) => U) | null | undefined;
-export type TransformAll<T extends BaseItem, O extends BaseItem = T> = ((items: T[], fields: FieldSpecifier<O> | undefined) => O[]) | null | undefined;
-export type SortSpecifier<T> = {
-    [P in keyof T]?: -1 | 1;
-} & Record<string, -1 | 1>;
-export type FieldSpecifier<T> = {
-    [P in keyof T]?: 0 | 1;
-} & Record<string, 0 | 1>;
-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;
-}
-export type AsyncFindOptions<T extends BaseItem> = Omit<FindOptions<T, true>, 'async'> & {
-    async: true;
-};
-export type SyncFindOptions<T extends BaseItem> = Omit<FindOptions<T, false>, 'async'> & {
-    async?: false;
-};
-export type AnyFindOptions<T extends BaseItem> = AsyncFindOptions<T> | SyncFindOptions<T>;

package/dist/core/src/DataAdapter.d.ts

@@ -1,35 +0,0 @@
-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 type StateChangeCallback = (state: 'active' | 'complete' | 'error') => void;
-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[];
-    executeQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): Promise<T[]>;
-    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T>, options: O, callback: StateChangeCallback): () => void;
-    dispose(): Promise<void>;
-    isReady(): Promise<void>;
-}
-export default interface DataAdapter {
-    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
-}

package/dist/core/src/DefaultDataAdapter.d.ts

@@ -1,35 +0,0 @@
-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 collections;
-    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 executeAndCacheQuery;
-    private updateQueries;
-    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
-    fetchItemsFromStorage<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection?: Collection<T, I, E, U>): Promise<void>;
-}
-export {};

package/dist/core/src/WorkerDataAdapter.d.ts

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

package/dist/core/src/WorkerDataAdapterHost.d.ts

@@ -1,62 +0,0 @@
-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;
-    log?: (message: string, ...args: any[]) => 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>;
-    executeQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<T[]>;
-    insert: (collectionName: string, items: [T][]) => Promise<(T | Error)[]>;
-    updateOne: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
-    updateMany: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
-    replaceOne: (collectionName: string, args: [Selector<T>, Omit<T, 'id'> & Partial<Pick<T, 'id'>>][]) => Promise<(T[] | Error)[]>;
-    removeOne: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
-    removeMany: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
-    isReady: (collectionName: string) => Promise<void>;
-};
-export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
-    private workerContext;
-    private options;
-    private id;
-    private log;
-    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/core/src/createIndex.d.ts

@@ -1,7 +0,0 @@
-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/core/src/createIndexProvider.d.ts

@@ -1,8 +0,0 @@
-import type { BaseItem } from './Collection';
-import type IndexProvider from './types/IndexProvider';
-/**
- * Creates an IndexProvider based on the given definition.
- * @param definition - The definition of the IndexProvider.
- * @returns The created IndexProvider.
- */
-export default function createIndexProvider<T extends BaseItem<I> = BaseItem, I = any>(definition: IndexProvider<T, I>): IndexProvider<T, I>;

package/dist/core/src/createReactivityAdapter.d.ts

@@ -1,8 +0,0 @@
-import type Dependency from './types/Dependency';
-import type ReactivityAdapter from './types/ReactivityAdapter';
-/**
- * Creates an ReactivityAdapter based on the given definition.
- * @param definition - The definition of the ReactivityAdapter.
- * @returns The created ReactivityAdapter.
- */
-export default function createReactivityAdapter<T extends Dependency = Dependency>(definition: ReactivityAdapter<T>): ReactivityAdapter<T>;

package/dist/core/src/createStorageAdapter.d.ts

@@ -1,9 +0,0 @@
-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/core/src/getIndexInfo.d.ts

@@ -1,39 +0,0 @@
-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 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 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.
- *   - `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>(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 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.
- *   - `ids`: An array of matched item ids.
- *   - `optimizedSelector`: A selector optimized based on the index results, with unused
- *     conditions removed.
- */
-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/core/src/index.d.ts

@@ -1,22 +0,0 @@
-export type { default as ReactivityAdapter } from './types/ReactivityAdapter';
-export type { default as StorageAdapter, Changeset, } from './types/StorageAdapter';
-export type { default as Selector } from './types/Selector';
-export type { default as Modifier } from './types/Modifier';
-export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, CollectionOptions, } from './Collection';
-export type { default as DataAdapter } from './DataAdapter';
-export { default as Cursor } from './Collection/Cursor';
-export { default as Collection } from './Collection';
-export { default as createStorageAdapter } from './createStorageAdapter';
-export { default as createReactivityAdapter } from './createReactivityAdapter';
-export { default as isEqual } from './utils/isEqual';
-export { default as modify } from './utils/modify';
-export { default as randomId } from './utils/randomId';
-export { default as EventEmitter } from './utils/EventEmitter';
-export { default as get } from './utils/get';
-export { default as serializeValue } from './utils/serializeValue';
-export { default as reactiveOrAsync, unwrap } from './utils/reactiveOrAsync';
-export { default as DefaultDataAdapter } from './DefaultDataAdapter';
-export { default as AsyncDataAdapter } from './AsyncDataAdapter';
-export { default as WorkerDataAdapter } from './WorkerDataAdapter';
-export { default as WorkerDataAdapterHost } from './WorkerDataAdapterHost';
-export { default as AutoFetchDataAdapter } from './AutoFetchDataAdapter';

package/dist/core/src/types/Dependency.d.ts

@@ -1,4 +0,0 @@
-export default interface Dependency {
-    depend(): void;
-    notify(): void;
-}

package/dist/core/src/types/IndexProvider.d.ts

@@ -1,26 +0,0 @@
-import type { BaseItem } from '../Collection';
-import type { FlatSelector } from './Selector';
-export type IndexResult<IdType> = {
-    ids: IdType[];
-    fields: string[];
-    keepSelector?: boolean;
-    matched: true;
-} | {
-    ids?: never;
-    fields?: never;
-    keepSelector?: never;
-    matched: false;
-};
-export type SynchronousQueryFunction<T extends BaseItem<I> = BaseItem, I = any> = (selector: FlatSelector<T>) => IndexResult<I>;
-export type AsynchronousQueryFunction<T extends BaseItem<I> = BaseItem, I = any> = (selector: FlatSelector<T>) => Promise<IndexResult<I>>;
-interface IndexProvider<T extends BaseItem<I> = BaseItem, I = any> {
-    query: SynchronousQueryFunction<T, I>;
-    rebuild(items: T[]): void;
-    insert(items: T[]): void;
-    remove(items: T[]): void;
-    update(pairs: {
-        oldItem: T;
-        newItem: T;
-    }[]): void;
-}
-export default IndexProvider;