@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/Collection/Observer.d.ts

@@ -1,3 +1,4 @@
+import { QueryDelta } from '../utils/queryDelta';
 type AddedCallback<T> = (item: T) => void;
 type AddedBeforeCallback<T> = (item: T, before: T) => void;
 type ChangedCallback<T> = (item: T) => void;
@@ -42,9 +43,41 @@ export default class Observer<T extends {
      * @param getItems - A function that returns a promise resolving to the new items or the items themselves.
      */
     runChecks(getItems: () => Promise<T[]> | T[]): void;
+    /**
+     * Brings the observer up to date from a description of what changed, instead of from the new
+     * result.
+     *
+     * `runChecks` has to rediscover the change by comparing the whole new result against the whole
+     * old one — a cost proportional to the result, paid on every write, to find out that one row
+     * moved. When the change is already known it can simply be reported, and the cost becomes
+     * proportional to the change.
+     *
+     * The delta must have been computed against exactly the result this observer holds. If it was
+     * not, this reports nothing, falls back to `runChecks`, and returns `false`.
+     *
+     * Note that the reported moves are minimal, where a comparison reports every item whose
+     * neighbour changed. Applying them yields the same order either way — there are simply fewer of
+     * them.
+     * @param delta - The change to report.
+     * @param getItems - Used to fall back to a comparison when the delta cannot be applied.
+     * @returns Whether the delta was applied.
+     */
+    applyDelta(delta: QueryDelta<T>, getItems: () => Promise<T[]> | T[]): boolean;
+    /**
+     * Reports a delta and adopts the result it produces.
+     *
+     * The single place the callbacks are fired from, whether the change arrived as a delta or was
+     * found by comparing two results — so the two can never disagree about what a consumer is told.
+     * @param delta - The change to report.
+     * @param nextItems - The result the delta produces.
+     */
+    private emitDelta;
+    private finishCheck;
     private checkItems;
+    private stopped;
     /**
      * Stops the observer by unbinding all events and cleaning up resources.
+     * Safe to call multiple times - will only unbind once.
      */
     stop(): void;
     /**

package/dist/Collection/index.d.ts

@@ -1,14 +1,13 @@
-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 { BaseItem, FindOptions, Transform, TransformAll } from './types';
-export type { BaseItem, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions } from './types';
-export type { CursorOptions } from './Cursor';
+import { default as ReactivityAdapter } from '../types/ReactivityAdapter';
+import { default as EventEmitter } from '../utils/EventEmitter';
+import { default as Selector } from '../types/Selector';
+import { default as Modifier } from '../types/Modifier';
+import { default as DataAdapter, QueryOptions } from '../DataAdapter';
+import { default as StorageAdapter } from '../types/StorageAdapter';
+import { default as Cursor } from './Cursor';
+import { AsyncFindOptions, BaseItem, FindOptions, SyncFindOptions, Transform, TransformAll } from './types';
+export type { AnyFindOptions, AsyncFindOptions, BaseItem, Transform, TransformAll, SortSpecifier, FieldSpecifier, FindOptions, SyncFindOptions, } from './types';
+export type { CursorOptions, QueryStateAccessor } 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> {
@@ -34,8 +33,14 @@ interface CollectionEvents<T extends BaseItem, E extends BaseItem = T, U = E> {
     '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;
+    /**
+     * A query backing at least one live cursor failed and will not deliver
+     * results. The cursor keeps returning its neutral empty value, so without
+     * listening here a consumer cannot distinguish failure from "no data".
+     */
+    'query.error': <O extends QueryOptions<T>>(error: Error, selector?: Selector<T>, options?: O) => void;
     'getItems': (selector: Selector<T> | undefined) => void;
-    'find': <O extends FindOptions<T, Async>, Async extends boolean>(selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, U, Async>) => 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;
@@ -45,8 +50,8 @@ interface CollectionEvents<T extends BaseItem, E extends BaseItem = T, U = E> {
     '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, Async>, Async extends boolean>(callstack: string, selector: Selector<T> | undefined, options: O | undefined, cursor: Cursor<E, 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.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;
@@ -69,7 +74,22 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
     private static fieldTracking;
     private static onCreationCallbacks;
     private static onDisposeCallbacks;
+    private static largeQueryWarningThreshold;
+    private static reportedLargeQueries;
     static getCollections(): Collection<any, any, any, any>[];
+    /**
+     * Reports live queries whose result is larger than `rows`, once each, with
+     * the stack that registered them.
+     *
+     * A reactive query is re-evaluated whenever the data under it changes, and
+     * one registered from a long-lived place — a navigation bar, a provider
+     * near the root — keeps that cost for the lifetime of the application. There
+     * is otherwise nothing to see: the query works, and its price is only
+     * visible as an application that has grown slow. Finding one such query in a
+     * real app took a purpose-built profiler and the better part of a day.
+     * @param rows - Result size to report above, or `null` to switch the check off.
+     */
+    static reportLargeQueries(rows: number | null): void;
     static onCreation(callback: (collection: Collection<any>) => void): void;
     static onDispose(callback: (collection: Collection<any>) => void): void;
     /**
@@ -87,11 +107,27 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
      * This improves performance by avoiding repetitive index recalculations and
      * provides atomicity for the batch of operations.
      * Supports both synchronous and asynchronous callbacks.
+     *
+     * **Without a `collections` argument this affects every collection in the
+     * process, not only the ones being written to.** Each of them defers every
+     * live query's requery until the batch ends. That is what makes a batch
+     * cheap for a handful of writes belonging to one event, and what makes it
+     * dangerous around a loop whose length is data-dependent: while it is open
+     * nothing anywhere updates, and everything deferred is flushed at once when
+     * it closes. One application wrapped a sync of roughly 1,100 records this
+     * way and its screens stopped resolving their data for the whole drain.
+     *
+     * Pass the collections being written to whenever that scope is known — it is
+     * both cheaper and safer. `Collection.batch([logs, versions], () => …)`
+     * defers those two and leaves everything else live.
+     * @param collections - The collections to batch. Omit to batch all of them.
      * @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;
+    static batch<ReturnType>(collections: Collection<any, any, any, any>[], callback: () => Promise<ReturnType>): Promise<void>;
+    static batch<ReturnType>(collections: Collection<any, any, any, any>[], callback: () => ReturnType): void;
     readonly name: string;
     private backend;
     private options;
@@ -104,6 +140,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
     private postBatchCallbacks;
     private fieldTracking;
     private queryListenersMap;
+    private settledQueriesSet;
     /**
      * Initializes a new instance of the `Collection` class with optional configuration.
      * Sets up memory, persistence, reactivity, and indices as specified in the options.
@@ -125,6 +162,15 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
      */
     constructor(options?: CollectionOptions<T, I, E, U>);
     constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, E, U>);
+    /**
+     * Reports a live query the first time its result is found to be larger than
+     * the configured threshold. Once per query, because it re-runs on every
+     * write and a warning per write would be its own performance problem.
+     * @param selector - The query's selector.
+     * @param options - The query's options.
+     * @param registrationStack - Where the query was registered, if captured.
+     */
+    private reportIfLargeQuery;
     isBatchOperationInProgress(): boolean;
     /**
      * Checks whether the collection is currently performing a pull operation
@@ -200,23 +246,24 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, E ext
     /**
      * Finds multiple items in the collection based on a selector and optional options.
      * Returns a cursor for reactive data queries.
-     * @template O - The options type for the find operation.
      * @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<Async extends boolean = false, O extends FindOptions<T, Async> = FindOptions<T, Async>>(selector?: Selector<T>, options?: O): Cursor<E, U, Async>;
+    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.
-     * @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<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;
+    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.

package/dist/Collection/types.d.ts

@@ -1,5 +1,5 @@
-import type { QueryOptions } from '../DataAdapter';
-import type ReactivityAdapter from '../types/ReactivityAdapter';
+import { QueryOptions } from '../DataAdapter';
+import { default as ReactivityAdapter } from '../types/ReactivityAdapter';
 export type BaseItem<I = any> = {
     id: I;
 } & Record<string, any>;
@@ -19,3 +19,10 @@ export interface FindOptions<T extends BaseItem, Async extends boolean> extends
     /** 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/DataAdapter.d.ts

@@ -1,7 +1,7 @@
-import type { BaseItem, FieldSpecifier, SortSpecifier } from './Collection';
-import type Collection from './Collection';
-import type Modifier from './types/Modifier';
-import type Selector from './types/Selector';
+import { BaseItem, FieldSpecifier, SortSpecifier, default as Collection } from './Collection';
+import { default as Modifier } from './types/Modifier';
+import { default as Selector } from './types/Selector';
+import { QueryDelta } from './utils/queryDelta';
 export interface QueryOptions<T extends BaseItem> {
     /** Sort order (default: natural order) */
     sort?: SortSpecifier<T> | undefined;
@@ -12,7 +12,19 @@ export interface QueryOptions<T extends BaseItem> {
     /** Dictionary of fields to return or exclude. */
     fields?: FieldSpecifier<T> | undefined;
 }
-export type StateChangeCallback = (state: 'active' | 'complete' | 'error') => void;
+/**
+ * Notified when a query's state changes.
+ *
+ * A `'complete'` notification may carry a delta describing how the result changed since the last
+ * one. An adapter that can produce one saves its listeners from rediscovering the change by
+ * comparing the whole result against the whole previous result; one that cannot simply omits it,
+ * and its listeners fall back to exactly that comparison.
+ *
+ * A delta is only ever passed when it is relative to what `getQueryResult` returned the last time
+ * it was asked. An adapter that layers anything on top of its stored result — an optimistic write
+ * still in flight, for instance — must omit the delta for as long as it does.
+ */
+export type StateChangeCallback<T extends BaseItem = BaseItem> = (state: 'active' | 'complete' | 'error', delta?: QueryDelta<T>) => void;
 export interface CollectionBackend<T extends BaseItem<I>, I> {
     insert(item: T): Promise<T>;
     updateOne(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
@@ -22,11 +34,17 @@ export interface CollectionBackend<T extends BaseItem<I>, I> {
     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;
+    /**
+     * Re-runs a query that is currently in the `'error'` state. Optional so
+     * existing custom adapters keep compiling — an adapter that never surfaces
+     * an error state has nothing to implement.
+     */
+    retryQuery?<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;
+    onQueryStateChange<O extends QueryOptions<T>>(selector: Selector<T>, options: O, callback: StateChangeCallback<T>): () => void;
     dispose(): Promise<void>;
     isReady(): Promise<void>;
 }

package/dist/DefaultDataAdapter.d.ts

@@ -1,8 +1,6 @@
-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';
+import { BaseItem, default as Collection } from './Collection';
+import { default as DataAdapter, CollectionBackend } from './DataAdapter';
+import { default as StorageAdapter } from './types/StorageAdapter';
 interface DefaultDataAdapterOptions {
     storage?: (name: string) => StorageAdapter<any, any> | undefined;
     onError?: (name: string, error: Error) => void;
@@ -11,6 +9,7 @@ export default class DefaultDataAdapter implements DataAdapter {
     private items;
     private options;
     private storageAdapters;
+    private collections;
     private indices;
     private activeQueries;
     private queryEmitters;
@@ -29,5 +28,6 @@ export default class DefaultDataAdapter implements DataAdapter {
     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/WorkerDataAdapter.d.ts

@@ -1,11 +1,15 @@
-import type { BaseItem } from './Collection';
-import type Collection from './Collection';
-import type DataAdapter from './DataAdapter';
-import type { CollectionBackend } from './DataAdapter';
+import { BaseItem, default as Collection } from './Collection';
+import { default as DataAdapter, CollectionBackend } from './DataAdapter';
 interface WorkerDataAdapterOptions {
     id?: string;
     log?: (message: string, ...args: any[]) => void;
 }
+export interface WorkerDataAdapterEndpoint {
+    addEventListener: (type: 'message', listener: (event: MessageEvent) => void) => void;
+    removeEventListener: (type: 'message', listener: (event: MessageEvent) => void) => void;
+    postMessage: (message: unknown) => void;
+    terminate?: () => void;
+}
 export default class WorkerDataAdapter implements DataAdapter {
     private worker;
     private options;
@@ -16,8 +20,56 @@ export default class WorkerDataAdapter implements DataAdapter {
     private collectionReady;
     private batchExecutionHelpers;
     private queries;
-    constructor(worker: Worker, options: WorkerDataAdapterOptions);
+    private pendingRequests;
+    private pendingWrites;
+    private pendingWriteSeq;
+    private pendingWriteVersions;
+    private bumpPendingWriteVersion;
+    constructor(worker: WorkerDataAdapterEndpoint, options: WorkerDataAdapterOptions);
+    private resolveWorkerReady;
+    private handleWorkerMessage;
+    private handleQueryUpdate;
     private exec;
+    /**
+     * Issues a call whose result nobody is waiting for, and makes sure a failure has somewhere to
+     * go. A bare rejection here would surface as an uncaught error — which is what a disposed
+     * collection produced every time a cursor was cleaned up after it.
+     * @param method - The method to call on the worker.
+     * @param collectionName - The collection it applies to.
+     * @param args - The remaining arguments.
+     * @param onError - Called when the call fails, in place of merely logging it.
+     */
+    private execInBackground;
+    private queryItemsById;
+    private flattenPendingWrites;
+    private static pushPendingEntry;
+    private static dropPendingEntry;
+    private static writeFlatEntry;
+    private static providesFullItems;
+    private observableItems;
+    private observableItemsByIds;
+    private servedResult;
+    private advanceServedResult;
+    private changesetForIds;
+    private computeServedResult;
+    /**
+     * Registers a write's effect locally and notifies every active query it
+     * touches, then returns a function that drops it again once the write
+     * settles.
+     * @param collectionName - The collection the write targets.
+     * @param upserts - Items inserted or updated by the write.
+     * @param deletes - Ids removed by the write.
+     * @returns A function that drops the pending write and re-notifies.
+     */
+    private applyPendingWrite;
+    private affectedQueries;
+    private servedResults;
+    private notifyWithDeltas;
+    private matchObservableItems;
+    private resolveUpdate;
+    private resolveRemoval;
+    private resolveReplacement;
+    private withPendingWrite;
     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>;

package/dist/WorkerDataAdapterHost.d.ts

@@ -1,9 +1,9 @@
-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 {
+import { BaseItem } from './Collection';
+import { QueryOptions } from './DataAdapter';
+import { default as Modifier } from './types/Modifier';
+import { default as StorageAdapter } from './types/StorageAdapter';
+import { default as Selector } from './types/Selector';
+export interface WorkerDataAdapterHostEndpoint {
     addEventListener: (type: 'message', listener: (event: MessageEvent) => any) => void;
     postMessage: (message: any) => void;
 }
@@ -37,13 +37,15 @@ export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
     private collectionIndices;
     private queries;
     private onError;
-    constructor(workerContext: WorkerContext, options: WorkerDataAdapterHostOptions);
+    constructor(workerContext: WorkerDataAdapterHostEndpoint, options: WorkerDataAdapterHostOptions);
     private respond;
     private handleMessage;
     private getIndexInfo;
     private queryItems;
     private executeQuery;
     private ensureQuery;
+    private setQueryItems;
+    private queryItemIds;
     private emitQueryUpdate;
     private ensureStorageAdapter;
     private checkQueryUpdates;

package/dist/createIndex.d.ts

@@ -1,7 +1,7 @@
-import type { BaseItem } from './Collection/types';
+import { 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>;
+export default function createIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string): import('./types/IndexProvider').default<T, I>;

package/dist/createIndexProvider.d.ts

@@ -1,5 +1,5 @@
-import type { BaseItem } from './Collection';
-import type IndexProvider from './types/IndexProvider';
+import { BaseItem } from './Collection';
+import { default as IndexProvider } from './types/IndexProvider';
 /**
  * Creates an IndexProvider based on the given definition.
  * @param definition - The definition of the IndexProvider.

package/dist/createReactivityAdapter.d.ts

@@ -1,5 +1,5 @@
-import type Dependency from './types/Dependency';
-import type ReactivityAdapter from './types/ReactivityAdapter';
+import { default as Dependency } from './types/Dependency';
+import { default as ReactivityAdapter } from './types/ReactivityAdapter';
 /**
  * Creates an ReactivityAdapter based on the given definition.
  * @param definition - The definition of the ReactivityAdapter.

package/dist/createStorageAdapter.d.ts

@@ -1,4 +1,4 @@
-import type StorageAdapter from './types/StorageAdapter';
+import { default as StorageAdapter } from './types/StorageAdapter';
 /**
  * Creates an StorageAdapter based on the given definition.
  * @param definition - The definition of the StorageAdapter.

package/dist/getIndexInfo.d.ts

@@ -1,7 +1,6 @@
-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';
+import { AsynchronousQueryFunction, SynchronousQueryFunction } from './types/IndexProvider';
+import { FlatSelector, default as Selector } from './types/Selector';
+import { BaseItem } from './Collection/types';
 type IndexInfo<T extends BaseItem<I> = BaseItem, I = any> = {
     matched: boolean;
     ids: I[];

package/dist/index.cjs.js

@@ -1,32 +1,34 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Cursor = require("./index.cjs2.js");
-const index = require("./index.cjs3.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.createStorageAdapter = createStorageAdapter;
-exports.createReactivityAdapter = createReactivityAdapter;
-exports.isEqual = isEqual;
-exports.modify = modify;
-exports.randomId = randomId;
-exports.EventEmitter = EventEmitter;
-exports.get = get;
-exports.serializeValue = serializeValue;
-exports.DefaultDataAdapter = DefaultDataAdapter;
-exports.AsyncDataAdapter = AsyncDataAdapter;
-exports.WorkerDataAdapter = WorkerDataAdapter;
-exports.WorkerDataAdapterHost = WorkerDataAdapterHost;
-exports.AutoFetchDataAdapter = AutoFetchDataAdapter;
+const require_isEqual = require("./index2.cjs.js");
+const require_Cursor = require("./index6.cjs.js");
+const require_EventEmitter = require("./index7.cjs.js");
+const require_randomId = require("./index9.cjs.js");
+const require_get = require("./index11.cjs.js");
+const require_serializeValue = require("./index13.cjs.js");
+const require_modify = require("./index20.cjs.js");
+const require_DefaultDataAdapter = require("./index28.cjs.js");
+const require_index = require("./index29.cjs.js");
+const require_createStorageAdapter = require("./index30.cjs.js");
+const require_createReactivityAdapter = require("./index31.cjs.js");
+const require_reactiveOrAsync = require("./index32.cjs.js");
+const require_AsyncDataAdapter = require("./index34.cjs.js");
+const require_WorkerDataAdapter = require("./index36.cjs.js");
+const require_WorkerDataAdapterHost = require("./index38.cjs.js");
+const require_AutoFetchDataAdapter = require("./index39.cjs.js");
+exports.AsyncDataAdapter = require_AsyncDataAdapter.default;
+exports.AutoFetchDataAdapter = require_AutoFetchDataAdapter.default;
+exports.Collection = require_index.default;
+exports.Cursor = require_Cursor.default;
+exports.DefaultDataAdapter = require_DefaultDataAdapter.default;
+exports.EventEmitter = require_EventEmitter.default;
+exports.WorkerDataAdapter = require_WorkerDataAdapter.default;
+exports.WorkerDataAdapterHost = require_WorkerDataAdapterHost.default;
+exports.createReactivityAdapter = require_createReactivityAdapter.default;
+exports.createStorageAdapter = require_createStorageAdapter.default;
+exports.get = require_get.default;
+exports.isEqual = require_isEqual.default;
+exports.modify = require_modify.default;
+exports.randomId = require_randomId.default;
+exports.reactiveOrAsync = require_reactiveOrAsync.default;
+exports.serializeValue = require_serializeValue.default;
+exports.unwrap = require_reactiveOrAsync.unwrap;

package/dist/index.d.ts

@@ -2,8 +2,10 @@ 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, FindOptions, CollectionOptions, } from './Collection';
+export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, CollectionOptions, QueryStateAccessor, } from './Collection';
 export type { default as DataAdapter } from './DataAdapter';
+export type { CollectionBackend, QueryOptions, StateChangeCallback, } from './DataAdapter';
+export type { QueryDelta } from './utils/queryDelta';
 export { default as Cursor } from './Collection/Cursor';
 export { default as Collection } from './Collection';
 export { default as createStorageAdapter } from './createStorageAdapter';
@@ -14,8 +16,11 @@ 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 type { WorkerDataAdapterEndpoint } from './WorkerDataAdapter';
+export type { WorkerDataAdapterHostEndpoint } from './WorkerDataAdapterHost';
 export { default as AutoFetchDataAdapter } from './AutoFetchDataAdapter';

package/dist/index.mjs

@@ -1,32 +1,17 @@
-import { default as default2 } from "./index2.mjs";
-import { default as default3 } from "./index3.mjs";
-import { default as default4 } from "./index4.mjs";
-import { default as default5 } from "./index5.mjs";
-import { default as default6 } from "./index6.mjs";
-import { default as default7 } from "./index7.mjs";
-import { default as default8 } from "./index8.mjs";
-import { default as default9 } from "./index9.mjs";
-import { default as default10 } from "./index10.mjs";
-import { default as default11 } from "./index11.mjs";
-import { default as default12 } from "./index12.mjs";
-import { default as default13 } from "./index13.mjs";
-import { default as default14 } from "./index14.mjs";
-import { default as default15 } from "./index15.mjs";
-import { default as default16 } from "./index16.mjs";
-export {
-  default13 as AsyncDataAdapter,
-  default16 as AutoFetchDataAdapter,
-  default3 as Collection,
-  default2 as Cursor,
-  default12 as DefaultDataAdapter,
-  default9 as EventEmitter,
-  default14 as WorkerDataAdapter,
-  default15 as WorkerDataAdapterHost,
-  default5 as createReactivityAdapter,
-  default4 as createStorageAdapter,
-  default10 as get,
-  default6 as isEqual,
-  default7 as modify,
-  default8 as randomId,
-  default11 as serializeValue
-};
+import isEqual from "./index2.mjs";
+import Cursor from "./index6.mjs";
+import EventEmitter from "./index7.mjs";
+import randomId from "./index9.mjs";
+import get from "./index11.mjs";
+import serializeValue from "./index13.mjs";
+import modify from "./index20.mjs";
+import DefaultDataAdapter from "./index28.mjs";
+import Collection from "./index29.mjs";
+import createStorageAdapter from "./index30.mjs";
+import createReactivityAdapter from "./index31.mjs";
+import reactiveOrAsync, { unwrap } from "./index32.mjs";
+import AsyncDataAdapter from "./index34.mjs";
+import WorkerDataAdapter from "./index36.mjs";
+import WorkerDataAdapterHost from "./index38.mjs";
+import AutoFetchDataAdapter from "./index39.mjs";
+export { AsyncDataAdapter, AutoFetchDataAdapter, Collection, Cursor, DefaultDataAdapter, EventEmitter, WorkerDataAdapter, WorkerDataAdapterHost, createReactivityAdapter, createStorageAdapter, get, isEqual, modify, randomId, reactiveOrAsync, serializeValue, unwrap };

package/dist/index10.cjs.js

@@ -0,0 +1,11 @@
+//#region src/createIndexProvider.ts
+/**
+* Creates an IndexProvider based on the given definition.
+* @param definition - The definition of the IndexProvider.
+* @returns The created IndexProvider.
+*/
+function createIndexProvider(definition) {
+	return definition;
+}
+//#endregion
+exports.default = createIndexProvider;