@signaldb/core 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/Collection/index.d.ts

@@ -1,17 +1,16 @@
-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 } from './types';
-export type { BaseItem, Transform, SortSpecifier, FieldSpecifier, FindOptions } from './types';
+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 } from './Cursor';
 export type { ObserveCallbacks } from './Observer';
 export { default as createIndex } from '../createIndex';
-export interface CollectionOptions<T extends BaseItem<I>, I, U = T> {
+export interface CollectionOptions<T extends BaseItem<I>, I, E extends BaseItem = T, U = E> {
     /**
      * @deprecated Use new constructor parameters instead.
      */
@@ -22,19 +21,26 @@ export interface CollectionOptions<T extends BaseItem<I>, I, U = T> {
     persistence?: StorageAdapter<T, I>;
     primaryKeyGenerator?: (item: Omit<T, 'id'>) => I;
     reactivity?: ReactivityAdapter;
-    transform?: Transform<T, U>;
+    transform?: Transform<E, U>;
+    transformAll?: TransformAll<T, E>;
     indices?: string[];
     enableDebugMode?: boolean;
     fieldTracking?: boolean;
 }
-interface CollectionEvents<T extends BaseItem, U = T> {
+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;
+    /**
+     * 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<T, 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;
@@ -44,8 +50,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, 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.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;
@@ -61,14 +67,14 @@ interface CollectionEvents<T extends BaseItem, U = T> {
  * @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, U = T> extends EventEmitter<CollectionEvents<T, U>> {
+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>[];
+    static getCollections(): Collection<any, any, any, any>[];
     static onCreation(callback: (collection: Collection<any>) => void): void;
     static onDispose(callback: (collection: Collection<any>) => void): void;
     /**
@@ -120,9 +126,10 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
      * @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, U>);
-    constructor(name: string, dataAdapter: DataAdapter, options?: CollectionOptions<T, I, U>);
+    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
@@ -184,6 +191,7 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
     private profile;
     private executeInDebugMode;
     private transform;
+    private transformAll;
     private getItem;
     private getItems;
     private withPushState;
@@ -197,23 +205,24 @@ export default class Collection<T extends BaseItem<I> = BaseItem, I = any, U = T
     /**
      * 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<T, 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,9 +1,10 @@
-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>;
 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>;
@@ -18,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,6 @@
-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';
 export interface QueryOptions<T extends BaseItem> {
     /** Sort order (default: natural order) */
     sort?: SortSpecifier<T> | undefined;
@@ -12,6 +11,7 @@ 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;
 export interface CollectionBackend<T extends BaseItem<I>, I> {
     insert(item: T): Promise<T>;
     updateOne(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
@@ -21,14 +21,20 @@ 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: (state: 'active' | 'complete' | 'error') => void): () => void;
+    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, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+    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/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;
@@ -28,6 +27,7 @@ export default class DefaultDataAdapter implements DataAdapter {
     private flushQueuedQueryUpdates;
     private executeAndCacheQuery;
     private updateQueries;
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices: string[]): CollectionBackend<T, I>;
+    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,10 +20,10 @@ export default class WorkerDataAdapter implements DataAdapter {
     private collectionReady;
     private batchExecutionHelpers;
     private queries;
-    constructor(worker: Worker, options: WorkerDataAdapterOptions);
+    constructor(worker: WorkerDataAdapterEndpoint, options: WorkerDataAdapterOptions);
     private exec;
     private enqueueBatched;
     private updateQuery;
-    createCollectionBackend<T extends BaseItem<I>, I = any, U = T>(collection: Collection<T, I, U>, indices?: string[]): CollectionBackend<T, I>;
+    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/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,7 +37,7 @@ 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;

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("./index5.cjs.js");
+const require_EventEmitter = require("./index6.cjs.js");
+const require_randomId = require("./index8.cjs.js");
+const require_get = require("./index10.cjs.js");
+const require_serializeValue = require("./index12.cjs.js");
+const require_modify = require("./index19.cjs.js");
+const require_DefaultDataAdapter = require("./index24.cjs.js");
+const require_index = require("./index25.cjs.js");
+const require_createStorageAdapter = require("./index26.cjs.js");
+const require_createReactivityAdapter = require("./index27.cjs.js");
+const require_reactiveOrAsync = require("./index28.cjs.js");
+const require_AsyncDataAdapter = require("./index29.cjs.js");
+const require_WorkerDataAdapter = require("./index31.cjs.js");
+const require_WorkerDataAdapterHost = require("./index33.cjs.js");
+const require_AutoFetchDataAdapter = require("./index34.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,7 +2,7 @@ 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, SortSpecifier, FieldSpecifier, FindOptions, CollectionOptions, } from './Collection';
+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';
@@ -14,8 +14,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 "./index5.mjs";
+import EventEmitter from "./index6.mjs";
+import randomId from "./index8.mjs";
+import get from "./index10.mjs";
+import serializeValue from "./index12.mjs";
+import modify from "./index19.mjs";
+import DefaultDataAdapter from "./index24.mjs";
+import Collection from "./index25.mjs";
+import createStorageAdapter from "./index26.mjs";
+import createReactivityAdapter from "./index27.mjs";
+import reactiveOrAsync, { unwrap } from "./index28.mjs";
+import AsyncDataAdapter from "./index29.mjs";
+import WorkerDataAdapter from "./index31.mjs";
+import WorkerDataAdapterHost from "./index33.mjs";
+import AutoFetchDataAdapter from "./index34.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,23 @@
+//#region src/utils/get.ts
+/**
+* Retrieves the value at a specified path within an object.
+* Supports dot and bracket notation for navigating nested properties.
+* @template T - The type of the object to retrieve the value from.
+* @param value - The object to navigate.
+* @param path - The path (dot or bracket notation) to the desired value.
+* @returns The value at the specified path, or `undefined` if the path does not exist.
+*/
+function get(value, path) {
+	const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+	if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) return;
+	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;
+}
+//#endregion
+exports.default = get;

package/dist/index10.mjs

@@ -1,19 +1,23 @@
+//#region src/utils/get.ts
+/**
+* Retrieves the value at a specified path within an object.
+* Supports dot and bracket notation for navigating nested properties.
+* @template T - The type of the object to retrieve the value from.
+* @param value - The object to navigate.
+* @param path - The path (dot or bracket notation) to the desired value.
+* @returns The value at the specified path, or `undefined` if the path does not exist.
+*/
 function get(value, path) {
-  const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
-  if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) {
-    return;
-  }
-  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;
+	const normalized = path.replaceAll(/\[(\w+)\]/g, ".$1");
+	if (normalized.includes("..") || normalized.startsWith(".") || normalized.endsWith(".")) return;
+	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;
 }
-export {
-  get as default
-};
+//#endregion
+export { get as default };

package/dist/index11.cjs.js

@@ -0,0 +1,45 @@
+//#region src/utils/isFieldExpression.ts
+var expressionKeys = new Set([
+	"$eq",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte",
+	"$in",
+	"$nin",
+	"$ne",
+	"$exists",
+	"$not",
+	"$expr",
+	"$jsonSchema",
+	"$mod",
+	"$regex",
+	"$options",
+	"$text",
+	"$where",
+	"$all",
+	"$elemMatch",
+	"$size",
+	"$bitsAllClear",
+	"$bitsAllSet",
+	"$bitsAnyClear",
+	"$bitsAnySet"
+]);
+/**
+* Determines whether a given object is a valid field expression.
+* A field expression is an object containing query operators supported by MongoDB-style queries.
+* @template T - The type of the field expression.
+* @param expression - The object to test.
+* @returns A boolean indicating whether the object is a valid field expression.
+*   - `true` if the object contains only recognized query operators.
+*   - `false` otherwise.
+*/
+function isFieldExpression(expression) {
+	if (typeof expression !== "object" || expression == null) return false;
+	const keys = Object.keys(expression);
+	if (keys.length === 0) return false;
+	if (keys.some((key) => !expressionKeys.has(key))) return false;
+	return keys.every((key) => expressionKeys.has(key));
+}
+//#endregion
+exports.default = isFieldExpression;