@signaldb/svelte 2.0.0-beta.6 → 2.0.0-beta.7

package/dist/base/core/src/DefaultDataAdapter.js

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createIndex_1 = __importDefault(require("./createIndex"));
+const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
+const deepClone_1 = __importDefault(require("./utils/deepClone"));
+const EventEmitter_1 = __importDefault(require("./utils/EventEmitter"));
+const isEqual_1 = __importDefault(require("./utils/isEqual"));
+const match_1 = __importDefault(require("./utils/match"));
+const modify_1 = __importDefault(require("./utils/modify"));
+const project_1 = __importDefault(require("./utils/project"));
+const queryId_1 = __importDefault(require("./utils/queryId"));
+const serializeValue_1 = __importDefault(require("./utils/serializeValue"));
+const sortItems_1 = __importDefault(require("./utils/sortItems"));
+/**
+ * Checks if there are any pending updates in the given changeset.
+ * @template T - The type of the items in the changeset.
+ * @param pendingUpdates - The changeset to check for pending updates.
+ * @returns `true` if there are pending updates, otherwise `false`.
+ */
+function hasPendingUpdates(pendingUpdates) {
+    return pendingUpdates.added.length > 0
+        || pendingUpdates.modified.length > 0
+        || pendingUpdates.removed.length > 0;
+}
+class DefaultDataAdapter {
+    items = new Map();
+    options;
+    storageAdapters = new Map();
+    collections = new Set();
+    indices = new Map();
+    activeQueries = new Map();
+    queryEmitters = new Map();
+    queuedQueryUpdates = new Map();
+    cachedQueryResults = new Map();
+    constructor(options) {
+        this.options = options || {};
+    }
+    ensureStorageAdapter(name) {
+        if (this.storageAdapters.get(name))
+            return; // already created
+        if (!this.options.storage)
+            return; // no storage function provided
+        const adapter = this.options.storage(name);
+        if (!adapter)
+            return; // no adapter returned
+        this.storageAdapters.set(name, adapter);
+    }
+    rebuildIndices(collection) {
+        const items = this.items.get(collection.name);
+        if (!items)
+            throw new Error(`Items not found for collection ${collection.name}`);
+        const indices = this.indices.get(collection.name);
+        if (!indices)
+            throw new Error(`Indices not found for collection ${collection.name}`);
+        indices.forEach(index => index.rebuild([...items.values()]));
+    }
+    async setupStorageAdapter(collection) {
+        const storageAdapter = this.storageAdapters.get(collection.name);
+        if (!storageAdapter)
+            return; // no persistence adapter available
+        return storageAdapter.setup()
+            .then(async () => {
+            await this.fetchItemsFromStorage(collection);
+        })
+            .catch((error) => {
+            if (!this.options.onError) {
+                // eslint-disable-next-line no-console
+                console.error(`Error during data persistence operation in collection ${collection.name}`, error);
+                return;
+            }
+            this.options.onError(collection.name, error instanceof Error ? error : new Error(error));
+        });
+    }
+    getIndexInfo(collection, selector) {
+        if (selector != null
+            && Object.keys(selector).length === 1
+            && 'id' in selector
+            && typeof selector.id !== 'object') {
+            return {
+                matched: true,
+                ids: [(0, serializeValue_1.default)(selector.id)],
+                optimizedSelector: {},
+            };
+        }
+        if (selector == null) {
+            return {
+                matched: false,
+                ids: [],
+                optimizedSelector: {},
+            };
+        }
+        return (0, getIndexInfo_1.default)((this.indices.get(collection.name) ?? []).map(i => i.query.bind(i)), selector);
+    }
+    applyIndexDeltas(collection, changes) {
+        const indices = this.indices.get(collection.name) ?? [];
+        for (const index of indices) {
+            if (changes.modified)
+                index.update(changes.modified);
+            if (changes.added && changes.added.length > 0)
+                index.insert(changes.added);
+            if (changes.removed && changes.removed.length > 0)
+                index.remove(changes.removed);
+        }
+    }
+    getItem(collection, selector) {
+        const memory = this.items.get(collection.name) ?? new Map();
+        const indexInfo = this.getIndexInfo(collection, selector);
+        const items = indexInfo.matched
+            ? indexInfo.ids.map(id => memory.get((0, serializeValue_1.default)(id))).filter(i => i != null)
+            : [...memory.values()];
+        const item = items.find(document => (0, match_1.default)(document, selector));
+        return item;
+    }
+    queryItems(collection, selector) {
+        const indexInfo = this.getIndexInfo(collection, selector);
+        const matchItems = (item) => {
+            if (indexInfo.optimizedSelector == null)
+                return true; // if no selector is given, return all items
+            if (Object.keys(indexInfo.optimizedSelector).length <= 0)
+                return true; // if selector is empty, return all items
+            const matches = (0, match_1.default)(item, indexInfo.optimizedSelector);
+            return matches;
+        };
+        const items = this.items.get(collection.name);
+        // no index available, use complete memory
+        if (!indexInfo.matched) {
+            if ((0, isEqual_1.default)(selector, {}))
+                return [...items.values()];
+            return [...items.values()].filter(matchItems);
+        }
+        const foundItems = indexInfo.ids.map(ids => items.get((0, serializeValue_1.default)(ids))).filter(i => i != null);
+        if ((0, isEqual_1.default)(indexInfo.optimizedSelector, {}))
+            return foundItems;
+        return foundItems.filter(matchItems);
+    }
+    executeQuery(collection, selector, options) {
+        const items = this.queryItems(collection, selector || {});
+        const { sort, skip, limit, fields } = options || {};
+        const sorted = sort ? (0, sortItems_1.default)(items, sort) : items;
+        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 {
+                ...idExcluded ? {} : { id: item.id },
+                ...(0, project_1.default)(item, fields),
+            };
+        });
+    }
+    flushQueuedQueryUpdates(collection) {
+        if (!this.queuedQueryUpdates.get(collection.name))
+            return;
+        const changes = this.queuedQueryUpdates.get(collection.name);
+        if (!changes || !hasPendingUpdates(changes))
+            return;
+        this.queuedQueryUpdates.set(collection.name, { added: [], modified: [], removed: [] });
+        const flatItems = [...changes.added, ...changes.modified, ...changes.removed];
+        const itemIds = new Set(flatItems.map(i => i.id));
+        const queries = [
+            ...this.activeQueries.get(collection.name)?.values() ?? [],
+        ].filter(({ selector, options }) => {
+            const idsInQuery = this.cachedQueryResults.get(collection.name)
+                ?.get((0, queryId_1.default)(selector, options))
+                ?.map(i => i.id) ?? [];
+            // update queries that contained changed items previously
+            if (idsInQuery.some(id => itemIds.has(id)))
+                return true;
+            return flatItems.some(item => (0, match_1.default)(item, selector));
+        });
+        queries.forEach(({ selector, options }) => {
+            this.executeAndCacheQuery(collection, selector, options);
+        });
+    }
+    executeAndCacheQuery(collection, selector, options) {
+        const result = this.executeQuery(collection, selector, options);
+        this.cachedQueryResults.set(collection.name, this.cachedQueryResults.get(collection.name) || new Map());
+        this.cachedQueryResults.get(collection.name)?.set((0, queryId_1.default)(selector, options), result);
+        const emitter = this.queryEmitters.get(collection.name);
+        if (!emitter)
+            return;
+        emitter.emit('change', selector, options, 'complete');
+    }
+    updateQueries(collection, changes) {
+        this.queuedQueryUpdates.set(collection.name, this.queuedQueryUpdates.get(collection.name) || { added: [], modified: [], removed: [] });
+        this.queuedQueryUpdates.get(collection.name)?.added.push(...changes.added);
+        this.queuedQueryUpdates.get(collection.name)?.modified.push(...changes.modified);
+        this.queuedQueryUpdates.get(collection.name)?.removed.push(...changes.removed);
+        this.flushQueuedQueryUpdates(collection);
+    }
+    createCollectionBackend(collection, indices) {
+        this.collections.add(collection);
+        this.ensureStorageAdapter(collection.name);
+        this.items.set(collection.name, this.items.get(collection.name) ?? new Map());
+        this.queryEmitters.set(collection.name, this.queryEmitters.get(collection.name) ?? new EventEmitter_1.default());
+        // we might have many active queries
+        this.queryEmitters.get(collection.name)?.setMaxListeners(Infinity);
+        this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || new Map());
+        this.indices.set(collection.name, indices.map(field => (0, createIndex_1.default)(field)));
+        this.rebuildIndices(collection);
+        const persistenceReadyPromise = this.setupStorageAdapter(collection);
+        const backend = {
+            // CRUD operations
+            insert: async (newItem) => {
+                const items = this.items.get(collection.name);
+                if (!items)
+                    throw new Error(`Items not found for collection ${collection.name}`);
+                if (items.has((0, serializeValue_1.default)(newItem.id))) {
+                    throw new Error(`Item with id '${newItem.id}' already exists`);
+                }
+                this.items.get(collection.name)?.set((0, serializeValue_1.default)(newItem.id), newItem);
+                await this.storageAdapters.get(collection.name)?.insert([newItem]);
+                this.applyIndexDeltas(collection, { added: [newItem] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [newItem],
+                    removed: [],
+                });
+                return newItem;
+            },
+            updateOne: async (selector, modifier) => {
+                const { $setOnInsert, ...restModifier } = modifier;
+                const item = this.getItem(collection, selector);
+                if (item == null)
+                    return []; // no item found
+                const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+                const hasItemWithSameId = item.id !== modifiedItem.id
+                    && this.getItem(collection, { id: modifiedItem.id }) != null;
+                if (hasItemWithSameId) {
+                    throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+                }
+                this.items.get(collection.name)?.set((0, serializeValue_1.default)(modifiedItem.id), modifiedItem);
+                await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+                this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [modifiedItem],
+                    removed: [],
+                });
+                return [modifiedItem];
+            },
+            updateMany: async (selector, modifier) => {
+                const { $setOnInsert, ...restModifier } = modifier;
+                const items = this.executeQuery(collection, selector, {});
+                const changedItems = items.map((item) => {
+                    const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+                    const hasItemWithSameId = item.id !== modifiedItem.id
+                        && this.getItem(collection, { id: modifiedItem.id }) != null;
+                    if (hasItemWithSameId) {
+                        throw new Error(`Item with id '${modifiedItem.id}' already exists`);
+                    }
+                    return modifiedItem;
+                });
+                changedItems.forEach((item) => {
+                    this.items.get(collection.name)?.set((0, serializeValue_1.default)(item.id), item);
+                });
+                await this.storageAdapters.get(collection.name)?.replace(changedItems);
+                const pairs = items.map((oldItem, index) => ({ oldItem, newItem: changedItems[index] }));
+                this.applyIndexDeltas(collection, { modified: pairs });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: changedItems,
+                    removed: [],
+                });
+                return changedItems;
+            },
+            replaceOne: async (selector, replacement) => {
+                const item = this.getItem(collection, selector);
+                if (item == null)
+                    return []; // no item found
+                const hasItemWithSameId = item.id !== replacement.id
+                    && replacement.id != null
+                    && this.getItem(collection, { id: replacement.id }) != null;
+                if (hasItemWithSameId) {
+                    throw new Error(`Item with id '${replacement.id}' already exists`);
+                }
+                const modifiedItem = { id: item.id, ...replacement };
+                this.items.get(collection.name)?.set((0, serializeValue_1.default)(modifiedItem.id), modifiedItem);
+                await this.storageAdapters.get(collection.name)?.replace([modifiedItem]);
+                this.applyIndexDeltas(collection, { modified: [{ oldItem: item, newItem: modifiedItem }] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [modifiedItem],
+                    removed: [],
+                });
+                return [modifiedItem];
+            },
+            removeOne: async (selector) => {
+                const item = this.getItem(collection, selector);
+                if (item == null)
+                    return []; // no item found
+                this.items.get(collection.name)?.delete((0, serializeValue_1.default)(item.id));
+                await this.storageAdapters.get(collection.name)?.remove([item]);
+                this.applyIndexDeltas(collection, { removed: [item] });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [],
+                    removed: [item],
+                });
+                return [item];
+            },
+            removeMany: async (selector) => {
+                const items = backend.getQueryResult(selector, {});
+                items.forEach((item) => {
+                    this.items.get(collection.name)?.delete((0, serializeValue_1.default)(item.id));
+                });
+                await this.storageAdapters.get(collection.name)?.remove(items);
+                this.applyIndexDeltas(collection, { removed: items });
+                this.updateQueries(collection, {
+                    added: [],
+                    modified: [],
+                    removed: items,
+                });
+                return items;
+            },
+            // methods for registering and unregistering queries that will be called from the collection during find/findOne
+            registerQuery: (selector, options) => {
+                this.activeQueries.set(collection.name, this.activeQueries.get(collection.name) || new Map());
+                this.activeQueries.get(collection.name)?.set((0, queryId_1.default)(selector, options), {
+                    selector,
+                    options,
+                });
+                this.executeAndCacheQuery(collection, selector, options);
+            },
+            unregisterQuery: (selector, options) => {
+                if (!this.activeQueries.get(collection.name))
+                    return;
+                this.activeQueries.get(collection.name)?.delete((0, queryId_1.default)(selector, options));
+            },
+            getQueryState: () => 'complete',
+            onQueryStateChange: (selector, options, callback) => {
+                const emitter = this.queryEmitters.get(collection.name);
+                if (!emitter)
+                    throw new Error(`Query emitter not found for collection ${collection.name}`);
+                const handler = (querySelector, queryOptions, state) => {
+                    if ((0, queryId_1.default)(querySelector, queryOptions) !== (0, queryId_1.default)(selector, options))
+                        return;
+                    callback(state);
+                };
+                emitter.on('change', handler);
+                return () => {
+                    emitter.off('change', handler);
+                };
+            },
+            getQueryError: () => null,
+            getQueryResult: (selector, options) => {
+                const isQueryActive = this.activeQueries.get(collection.name)
+                    ?.has((0, queryId_1.default)(selector, options));
+                if (isQueryActive) {
+                    const results = this.cachedQueryResults
+                        .get(collection.name)
+                        ?.get((0, queryId_1.default)(selector, options));
+                    if (!results)
+                        throw new Error('Cached query results are not defined!');
+                    return results;
+                }
+                return this.executeQuery(collection, selector, options);
+            },
+            executeQuery: (selector, options) => Promise.resolve(this.executeQuery(collection, selector, options)),
+            // lifecycle methods
+            dispose: async () => {
+                const adapter = this.storageAdapters.get(collection.name);
+                if (adapter?.teardown)
+                    await adapter.teardown();
+                this.storageAdapters.delete(collection.name);
+                this.items.delete(collection.name);
+                this.indices.delete(collection.name);
+                this.activeQueries.delete(collection.name);
+                this.queryEmitters.delete(collection.name);
+                this.queuedQueryUpdates.delete(collection.name);
+                this.cachedQueryResults.delete(collection.name);
+            },
+            isReady: () => persistenceReadyPromise,
+        };
+        return backend;
+    }
+    async fetchItemsFromStorage(collection) {
+        if (!collection) {
+            await Promise.all([...this.collections]
+                .map(currentCollection => this.fetchItemsFromStorage(currentCollection)));
+            return;
+        }
+        const storageAdapter = this.storageAdapters.get(collection.name);
+        if (!storageAdapter)
+            return; // no persistence adapter available
+        const items = await storageAdapter.readAll();
+        this.items.set(collection.name, items.reduce((map, item) => {
+            map.set((0, serializeValue_1.default)(item.id), item);
+            return map;
+        }, new Map()));
+        this.rebuildIndices(collection);
+    }
+}
+exports.default = DefaultDataAdapter;

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

@@ -0,0 +1,25 @@
+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/base/core/src/WorkerDataAdapter.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const queryId_1 = __importDefault(require("./utils/queryId"));
+const randomId_1 = __importDefault(require("./utils/randomId"));
+const batchOnNextTick_1 = __importDefault(require("./utils/batchOnNextTick"));
+class WorkerDataAdapter {
+    worker;
+    options;
+    id;
+    isDisposed = false;
+    workerReady;
+    log = () => { };
+    collectionReady = new Map();
+    batchExecutionHelpers = 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(new Error('WorkerDataAdapter initialization timed out'));
+            }, 5000);
+            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 = (0, randomId_1.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);
+    }
+    // ---------- end batching integration ----------
+    updateQuery(collectionName, query, update) {
+        const id = (0, queryId_1.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] = new Map();
+        void this.exec('registerCollection', collection.name, indices);
+        this.collectionReady.set(collection.name, this.exec('isReady', collection.name));
+        this.batchExecutionHelpers.set(collection.name, (0, batchOnNextTick_1.default)(async (method, args) => this.exec(method, collection.name, args)));
+        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]);
+            },
+            // methods for registering and unregistering queries that will be called from the collection during find/findOne
+            registerQuery: (selector, options) => {
+                this.updateQuery(collection.name, { selector, options }, { state: 'active', error: null, items: [] });
+                void 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 ((0, queryId_1.default)(responseSelector, responseOptions) !== (0, queryId_1.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((0, queryId_1.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 = (0, queryId_1.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);
+                void this.exec('unregisterQuery', collection.name, selector, options);
+            },
+            getQueryState: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.state || 'active';
+            },
+            getQueryError: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.error || null;
+            },
+            getQueryResult: (selector, options) => {
+                const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
+                return query?.items || [];
+            },
+            onQueryStateChange: (selector, options, callback) => {
+                this.updateQuery(collection.name, { selector, options }, {
+                    stateChangeCallbacks: [
+                        ...this.queries[collection.name]?.get((0, queryId_1.default)(selector, options))?.stateChangeCallbacks || [],
+                        callback,
+                    ],
+                });
+                return () => {
+                    const currentCallbacks = this.queries[collection.name]?.get((0, queryId_1.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),
+            // lifecycle methods
+            dispose: async () => {
+                await this.exec('unregisterCollection', collection.name);
+                this.isDisposed = true;
+                this.worker.terminate();
+            },
+            isReady: async () => {
+                await this.exec('isReady', collection.name);
+            },
+        };
+    }
+}
+exports.default = WorkerDataAdapter;