@signaldb/core 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/.vite/manifest.json

@@ -17,7 +17,7 @@
     ]
   },
   "src/AutoFetchDataAdapter.ts": {
-    "file": "index34.cjs.js",
+    "file": "index35.cjs.js",
     "name": "AutoFetchDataAdapter",
     "src": "src/AutoFetchDataAdapter.ts",
     "isDynamicEntry": true,
@@ -89,18 +89,22 @@
     ]
   },
   "src/WorkerDataAdapter.ts": {
-    "file": "index31.cjs.js",
+    "file": "index32.cjs.js",
     "name": "WorkerDataAdapter",
     "src": "src/WorkerDataAdapter.ts",
     "isDynamicEntry": true,
     "imports": [
+      "src/utils/applyQueryOptions.ts",
       "src/utils/batchOnNextTick.ts",
+      "src/utils/deepClone.ts",
+      "src/utils/match.ts",
+      "src/utils/modify.ts",
       "src/utils/queryId.ts",
       "src/utils/randomId.ts"
     ]
   },
   "src/WorkerDataAdapterHost.ts": {
-    "file": "index33.cjs.js",
+    "file": "index34.cjs.js",
     "name": "WorkerDataAdapterHost",
     "src": "src/WorkerDataAdapterHost.ts",
     "isDynamicEntry": true,
@@ -186,6 +190,17 @@
     "src": "src/utils/EventEmitter.ts",
     "isDynamicEntry": true
   },
+  "src/utils/applyQueryOptions.ts": {
+    "file": "index31.cjs.js",
+    "name": "utils/applyQueryOptions",
+    "src": "src/utils/applyQueryOptions.ts",
+    "isDynamicEntry": true,
+    "imports": [
+      "src/utils/match.ts",
+      "src/utils/project.ts",
+      "src/utils/sortItems.ts"
+    ]
+  },
   "src/utils/batchOnNextTick.ts": {
     "file": "index30.cjs.js",
     "name": "utils/batchOnNextTick",
@@ -193,7 +208,7 @@
     "isDynamicEntry": true
   },
   "src/utils/compact.ts": {
-    "file": "index32.cjs.js",
+    "file": "index33.cjs.js",
     "name": "utils/compact",
     "src": "src/utils/compact.ts",
     "isDynamicEntry": true

package/dist/Collection/Cursor.d.ts

@@ -7,9 +7,26 @@ import { ObserveCallbacks } from './Observer';
  * @returns A boolean indicating if the current scope is reactive.
  */
 export declare function isInReactiveScope(reactivity: ReactivityAdapter | undefined | false): boolean;
+/**
+ * Reports whether the query a cursor stands for has produced an outcome yet.
+ * Supplied by the collection, which owns the query registration; a cursor
+ * built without one simply never reports itself as loading.
+ */
+export interface QueryStateAccessor {
+    /**
+     * Whether the query has settled — completed or failed — at least once
+     * since it was registered.
+     */
+    hasSettled: () => boolean;
+    /**
+     * Subscribes to the query settling. Returns a cleanup function.
+     */
+    onSettled: (callback: () => void) => () => void;
+}
 export interface CursorOptions<T extends BaseItem, U = T, Async extends boolean = false> extends FindOptions<T, Async> {
     transform?: Transform<T, U>;
     bindEvents?: (requery: () => void) => () => void;
+    queryState?: QueryStateAccessor;
 }
 /**
  * Represents a cursor for querying and observing a filtered, sorted, and transformed
@@ -90,6 +107,31 @@ export default class Cursor<T extends BaseItem, U = T, Async extends boolean = f
      * @returns The total number of items in the result set.
      */
     count(): Async extends true ? Promise<number> : number;
+    /**
+     * Whether this cursor's query has yet to deliver a first result.
+     * ⚡️ this function is reactive!
+     *
+     * An asynchronous data adapter answers a newly registered query only after a
+     * round trip, and serves a neutral empty result until it does — which a
+     * consumer cannot otherwise tell apart from "there is nothing to show". This
+     * is that distinction, per query rather than per collection, so one screen
+     * waiting on its own data says nothing about any other query.
+     *
+     * Follows the usual `isLoading`/`isFetching` split: it reports "no result
+     * yet", not "an execution is in flight". A write that re-runs an
+     * already-settled query drives it through `'active'` again while this stays
+     * `false`, so a list does not fall back to a loading state every time one of
+     * its rows changes.
+     *
+     * A query that fails counts as settled — the `query.error` event on the
+     * collection is what surfaces the failure, and a loading state that never
+     * ends is the worse answer. Reading this registers the query if nothing else
+     * has, so it cannot wait on something nobody asked for. It is always `false`
+     * for an `{ async: true }` cursor, whose `fetch()` awaits the real result
+     * anyway, and for a data adapter that answers synchronously.
+     * @returns A boolean indicating whether the first result is still pending.
+     */
+    isLoading(): boolean;
     /**
      * Observes changes to the cursor's result set and triggers the specified callbacks
      * when items are added, removed, or updated. Supports reactivity and transformation.

package/dist/Collection/index.d.ts

@@ -7,7 +7,7 @@ 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 { 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> {
@@ -109,6 +109,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.

package/dist/WorkerDataAdapter.d.ts

@@ -4,6 +4,12 @@ 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;
@@ -14,8 +20,28 @@ export default class WorkerDataAdapter implements DataAdapter {
     private collectionReady;
     private batchExecutionHelpers;
     private queries;
-    constructor(worker: Worker, options: WorkerDataAdapterOptions);
+    private pendingWrites;
+    private pendingWriteSeq;
+    constructor(worker: WorkerDataAdapterEndpoint, options: WorkerDataAdapterOptions);
     private exec;
+    private observableItems;
+    private mergePendingWrites;
+    /**
+     * 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 notifyAffectedQueries;
+    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

@@ -3,7 +3,7 @@ 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';
-interface WorkerContext {
+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/index.cjs.js

@@ -12,9 +12,9 @@ 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");
+const require_WorkerDataAdapter = require("./index32.cjs.js");
+const require_WorkerDataAdapterHost = require("./index34.cjs.js");
+const require_AutoFetchDataAdapter = require("./index35.cjs.js");
 exports.AsyncDataAdapter = require_AsyncDataAdapter.default;
 exports.AutoFetchDataAdapter = require_AutoFetchDataAdapter.default;
 exports.Collection = require_index.default;

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, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, 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 { default as Cursor } from './Collection/Cursor';
 export { default as Collection } from './Collection';
@@ -19,4 +19,6 @@ 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

@@ -11,7 +11,7 @@ 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";
+import WorkerDataAdapter from "./index32.mjs";
+import WorkerDataAdapterHost from "./index34.mjs";
+import AutoFetchDataAdapter from "./index35.mjs";
 export { AsyncDataAdapter, AutoFetchDataAdapter, Collection, Cursor, DefaultDataAdapter, EventEmitter, WorkerDataAdapter, WorkerDataAdapterHost, createReactivityAdapter, createStorageAdapter, get, isEqual, modify, randomId, reactiveOrAsync, serializeValue, unwrap };

package/dist/index25.cjs.js

@@ -84,6 +84,7 @@ var Collection = class Collection extends require_EventEmitter.default {
 	postBatchCallbacks = /* @__PURE__ */ new Set();
 	fieldTracking = false;
 	queryListenersMap = /* @__PURE__ */ new Map();
+	settledQueriesSet = /* @__PURE__ */ new Set();
 	constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
 		super();
 		const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${require_randomId.default()}`;
@@ -265,6 +266,18 @@ var Collection = class Collection extends require_EventEmitter.default {
 			fieldTracking: this.fieldTracking,
 			...options,
 			transform: this.transform.bind(this),
+			queryState: {
+				hasSettled: () => {
+					if (this.settledQueriesSet.has(require_queryId.default(selector, options))) return true;
+					const state = this.backend.getQueryState(selector, options || {});
+					return state === "complete" || state === "error";
+				},
+				onSettled: (callback) => this.backend.onQueryStateChange(selector, options || {}, (state) => {
+					if (state !== "complete" && state !== "error") return;
+					this.settledQueriesSet.add(require_queryId.default(selector, options));
+					callback();
+				})
+			},
 			bindEvents: (requery) => {
 				const handleRequery = () => {
 					if (this.batchOperationInProgress) {
@@ -299,7 +312,10 @@ var Collection = class Collection extends require_EventEmitter.default {
 							selector,
 							options
 						}) - 1);
-						if (newListeners === 0 && didRegister) this.backend.unregisterQuery(selector, options || {});
+						if (newListeners === 0 && didRegister) {
+							this.backend.unregisterQuery(selector, options || {});
+							this.settledQueriesSet.delete(require_queryId.default(selector, options));
+						}
 						this.queryListeners({
 							selector,
 							options

package/dist/index25.mjs

@@ -84,6 +84,7 @@ var Collection = class Collection extends EventEmitter {
 	postBatchCallbacks = /* @__PURE__ */ new Set();
 	fieldTracking = false;
 	queryListenersMap = /* @__PURE__ */ new Map();
+	settledQueriesSet = /* @__PURE__ */ new Set();
 	constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
 		super();
 		const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name || `${this.constructor.name}-${randomId()}`;
@@ -265,6 +266,18 @@ var Collection = class Collection extends EventEmitter {
 			fieldTracking: this.fieldTracking,
 			...options,
 			transform: this.transform.bind(this),
+			queryState: {
+				hasSettled: () => {
+					if (this.settledQueriesSet.has(queryId(selector, options))) return true;
+					const state = this.backend.getQueryState(selector, options || {});
+					return state === "complete" || state === "error";
+				},
+				onSettled: (callback) => this.backend.onQueryStateChange(selector, options || {}, (state) => {
+					if (state !== "complete" && state !== "error") return;
+					this.settledQueriesSet.add(queryId(selector, options));
+					callback();
+				})
+			},
 			bindEvents: (requery) => {
 				const handleRequery = () => {
 					if (this.batchOperationInProgress) {
@@ -299,7 +312,10 @@ var Collection = class Collection extends EventEmitter {
 							selector,
 							options
 						}) - 1);
-						if (newListeners === 0 && didRegister) this.backend.unregisterQuery(selector, options || {});
+						if (newListeners === 0 && didRegister) {
+							this.backend.unregisterQuery(selector, options || {});
+							this.settledQueriesSet.delete(queryId(selector, options));
+						}
 						this.queryListeners({
 							selector,
 							options

package/dist/index29.cjs.js

@@ -239,7 +239,8 @@ var AsyncDataAdapter = class {
 		if (!rec) return;
 		rec.state = state;
 		rec.error = error;
-		for (const callback of rec.listeners) try {
+		const subscribers = [...rec.listeners];
+		for (const callback of subscribers) try {
 			callback(state);
 		} catch (error_) {
 			this.onError(error_);

package/dist/index29.mjs

@@ -239,7 +239,8 @@ var AsyncDataAdapter = class {
 		if (!rec) return;
 		rec.state = state;
 		rec.error = error;
-		for (const callback of rec.listeners) try {
+		const subscribers = [...rec.listeners];
+		for (const callback of subscribers) try {
 			callback(state);
 		} catch (error_) {
 			this.onError(error_);

package/dist/index31.cjs.js

@@ -1,191 +1,32 @@
-const require_randomId = require("./index8.cjs.js");
-const require_queryId = require("./index22.cjs.js");
-const require_batchOnNextTick = require("./index30.cjs.js");
-//#region src/WorkerDataAdapter.ts
-var WorkerDataAdapter = class {
-	worker;
-	options;
-	id;
-	isDisposed = false;
-	workerReady;
-	log = () => {};
-	collectionReady = /* @__PURE__ */ new Map();
-	batchExecutionHelpers = /* @__PURE__ */ new Map();
-	queries = {};
-	constructor(worker, options) {
-		this.worker = worker;
-		this.options = options;
-		this.id = this.options.id || "default-worker-data-adapter";
-		if (this.options.log) this.log = this.options.log;
-		this.workerReady = new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				reject(/* @__PURE__ */ new Error("WorkerDataAdapter initialization timed out"));
-			}, 5e3);
-			const handleMessage = (event) => {
-				const { type, workerId } = event.data;
-				if (workerId !== this.id) return;
-				if (type === "ready") {
-					resolve();
-					clearTimeout(timeoutId);
-					this.worker.removeEventListener("message", handleMessage);
-				}
-			};
-			this.worker.addEventListener("message", handleMessage);
-		});
-	}
-	async exec(method, collectionName, ...args) {
-		await this.workerReady;
-		if (method !== "isReady") {
-			const collectionReady = this.collectionReady.get(collectionName);
-			if (!collectionReady) throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
-			await collectionReady;
-		}
-		if (this.isDisposed) throw new Error("WorkerDataAdapter is disposed");
-		return new Promise((resolve, reject) => {
-			const messageId = require_randomId.default();
-			const handleMessage = (event) => {
-				const { id, workerId, type, data, error } = event.data;
-				if (workerId !== this.id) return;
-				if (type !== "response") return;
-				if (id !== messageId) return;
-				this.log(method, "result", data ?? error);
-				if (error) reject(error);
-				else resolve(data);
-				this.worker.removeEventListener("message", handleMessage);
-			};
-			this.worker.addEventListener("message", handleMessage);
-			this.worker.postMessage({
-				id: messageId,
-				workerId: this.id,
-				method,
-				args: [collectionName, ...args]
-			});
-		});
-	}
-	enqueueBatched(collectionName, method, args) {
-		const helper = this.batchExecutionHelpers.get(collectionName);
-		if (!helper) throw new Error(`Collection "${collectionName}" is not registered in WorkerDataAdapter`);
-		return helper.enqueue(method, args);
-	}
-	updateQuery(collectionName, query, update) {
-		const id = require_queryId.default(query.selector, query.options);
-		const collectionQueries = this.queries[collectionName];
-		if (!collectionQueries) return;
-		const existing = collectionQueries.get(id);
-		const newState = {
-			state: "active",
-			error: null,
-			items: [],
-			stateChangeCallbacks: [],
-			eventHandler: existing?.eventHandler,
-			...existing,
-			...update
-		};
-		collectionQueries.set(id, newState);
-		this.queries[collectionName] = collectionQueries;
-	}
-	createCollectionBackend(collection, indices) {
-		this.queries[collection.name] = /* @__PURE__ */ new Map();
-		this.exec("registerCollection", collection.name, indices);
-		this.collectionReady.set(collection.name, this.exec("isReady", collection.name));
-		this.batchExecutionHelpers.set(collection.name, require_batchOnNextTick.default(async (method, args) => this.exec(method, collection.name, args)));
+const require_match = require("./index18.cjs.js");
+const require_project = require("./index21.cjs.js");
+const require_sortItems = require("./index23.cjs.js");
+//#region src/utils/applyQueryOptions.ts
+/**
+* Filters, sorts, paginates and projects a plain in-memory array the same way
+* DefaultDataAdapter and WorkerDataAdapterHost apply a selector/QueryOptions
+* pair to their stored items. Used to re-derive a query's result locally after
+* a write, without asking the backing store again.
+* @template T - The type of the items.
+* @param items - The items to filter, sort, paginate and project.
+* @param selector - The selector to match items against.
+* @param options - Sort, skip, limit and field projection options.
+* @returns The resulting items.
+*/
+function applyQueryOptions(items, selector, options) {
+	const matched = selector == null ? [] : items.filter((item) => require_match.default(item, selector));
+	const { sort, skip, limit, fields } = options || {};
+	const sorted = sort ? require_sortItems.default(matched, sort) : matched;
+	const skipped = skip ? sorted.slice(skip) : sorted;
+	const limited = limit ? skipped.slice(0, limit) : skipped;
+	const idExcluded = fields && fields.id === 0;
+	return limited.map((item) => {
+		if (!fields) return item;
 		return {
-			insert: async (item) => {
-				return this.enqueueBatched(collection.name, "insert", [item]);
-			},
-			updateOne: async (selector, modifier) => {
-				return this.enqueueBatched(collection.name, "updateOne", [selector, modifier]);
-			},
-			updateMany: async (selector, modifier) => {
-				return this.enqueueBatched(collection.name, "updateMany", [selector, modifier]);
-			},
-			replaceOne: async (selector, replacement) => {
-				return this.enqueueBatched(collection.name, "replaceOne", [selector, replacement]);
-			},
-			removeOne: async (selector) => {
-				return this.enqueueBatched(collection.name, "removeOne", [selector]);
-			},
-			removeMany: async (selector) => {
-				return this.enqueueBatched(collection.name, "removeMany", [selector]);
-			},
-			registerQuery: (selector, options) => {
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, {
-					state: "active",
-					error: null,
-					items: []
-				});
-				this.exec("registerQuery", collection.name, selector, options);
-				const handler = (event) => {
-					const { type, data, workerId, error } = event.data;
-					if (type !== "queryUpdate") return;
-					if (data == null) return;
-					const { collectionName, selector: responseSelector, options: responseOptions, state, items } = data;
-					if (workerId !== this.id) return;
-					if (collectionName !== collection.name) return;
-					if (require_queryId.default(responseSelector, responseOptions) !== require_queryId.default(selector, options)) return;
-					this.log("queryUpdate", responseSelector, responseOptions, state, data ?? error);
-					this.updateQuery(collection.name, {
-						selector: responseSelector,
-						options: responseOptions
-					}, {
-						state,
-						error,
-						items
-					});
-					const query = this.queries[collection.name]?.get(require_queryId.default(selector, options));
-					if (!query) return;
-					query.stateChangeCallbacks.forEach((callback) => callback(state));
-				};
-				this.worker.addEventListener("message", handler);
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, { eventHandler: handler });
-			},
-			unregisterQuery: (selector, options) => {
-				const qid = require_queryId.default(selector, options);
-				const query = this.queries[collection.name]?.get(qid);
-				if (query?.eventHandler) this.worker.removeEventListener("message", query.eventHandler);
-				this.queries[collection.name]?.delete(qid);
-				this.exec("unregisterQuery", collection.name, selector, options);
-			},
-			getQueryState: (selector, options) => {
-				return (this.queries[collection.name]?.get(require_queryId.default(selector, options)))?.state || "active";
-			},
-			getQueryError: (selector, options) => {
-				return (this.queries[collection.name]?.get(require_queryId.default(selector, options)))?.error || null;
-			},
-			getQueryResult: (selector, options) => {
-				return (this.queries[collection.name]?.get(require_queryId.default(selector, options)))?.items || [];
-			},
-			onQueryStateChange: (selector, options, callback) => {
-				this.updateQuery(collection.name, {
-					selector,
-					options
-				}, { stateChangeCallbacks: [...this.queries[collection.name]?.get(require_queryId.default(selector, options))?.stateChangeCallbacks || [], callback] });
-				return () => {
-					const currentCallbacks = this.queries[collection.name]?.get(require_queryId.default(selector, options))?.stateChangeCallbacks;
-					if (!currentCallbacks) throw new Error("State change callbacks are not defined!");
-					this.updateQuery(collection.name, {
-						selector,
-						options
-					}, { stateChangeCallbacks: currentCallbacks.filter((existingCallback) => existingCallback !== callback) });
-				};
-			},
-			executeQuery: (selector, options) => this.exec("executeQuery", collection.name, selector, options),
-			dispose: async () => {
-				await this.exec("unregisterCollection", collection.name);
-				this.isDisposed = true;
-				this.worker.terminate();
-			},
-			isReady: async () => {
-				await this.exec("isReady", collection.name);
-			}
+			...idExcluded ? {} : { id: item.id },
+			...require_project.default(item, fields)
 		};
-	}
-};
+	});
+}
 //#endregion
-exports.default = WorkerDataAdapter;
+exports.default = applyQueryOptions;