@signaldb/svelte 2.0.0-beta.21 → 2.0.0-beta.22

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

@@ -1,28 +0,0 @@
-import type { QueryOptions } from '../DataAdapter';
-import type ReactivityAdapter from '../types/ReactivityAdapter';
-export type BaseItem<I = any> = {
-    id: I;
-} & Record<string, any>;
-export type Transform<T, U = T> = ((document: T) => U) | null | undefined;
-export type TransformAll<T extends BaseItem, O extends BaseItem = T> = ((items: T[], fields: FieldSpecifier<O> | undefined) => O[]) | null | undefined;
-export type SortSpecifier<T> = {
-    [P in keyof T]?: -1 | 1;
-} & Record<string, -1 | 1>;
-export type FieldSpecifier<T> = {
-    [P in keyof T]?: 0 | 1;
-} & Record<string, 0 | 1>;
-export interface FindOptions<T extends BaseItem, Async extends boolean> extends QueryOptions<T> {
-    /** pass `false` to disable reactivity */
-    reactive?: ReactivityAdapter | false;
-    /** pass `true` to enable automatic field-level reactitivy */
-    fieldTracking?: boolean;
-    /** pass `true` to execute the query asynchronously */
-    async?: Async;
-}
-export type AsyncFindOptions<T extends BaseItem> = Omit<FindOptions<T, true>, 'async'> & {
-    async: true;
-};
-export type SyncFindOptions<T extends BaseItem> = Omit<FindOptions<T, false>, 'async'> & {
-    async?: false;
-};
-export type AnyFindOptions<T extends BaseItem> = AsyncFindOptions<T> | SyncFindOptions<T>;

package/dist/base/core/src/Collection/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,54 +0,0 @@
-import type { BaseItem, FieldSpecifier, SortSpecifier } from './Collection';
-import type Collection from './Collection';
-import type Modifier from './types/Modifier';
-import type Selector from './types/Selector';
-import type { QueryDelta } from './utils/queryDelta';
-export interface QueryOptions<T extends BaseItem> {
-    /** Sort order (default: natural order) */
-    sort?: SortSpecifier<T> | undefined;
-    /** Number of results to skip at the beginning */
-    skip?: number | undefined;
-    /** Maximum number of results to return */
-    limit?: number | undefined;
-    /** Dictionary of fields to return or exclude. */
-    fields?: FieldSpecifier<T> | undefined;
-}
-/**
- * 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[]>;
-    updateMany(selector: Selector<T>, modifier: Modifier<T>): Promise<T[]>;
-    replaceOne(selector: Selector<T>, replacement: Omit<T, 'id'> & Partial<Pick<T, 'id'>>): Promise<T[]>;
-    removeOne(selector: Selector<T>): Promise<T[]>;
-    removeMany(selector: Selector<T>): Promise<T[]>;
-    registerQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
-    unregisterQuery<O extends QueryOptions<T>>(selector: Selector<T>, options: O): void;
-    /**
-     * 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<T>): () => void;
-    dispose(): Promise<void>;
-    isReady(): Promise<void>;
-}
-export default interface DataAdapter {
-    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
-}

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,35 +0,0 @@
-import type { BaseItem } from './Collection';
-import type Collection from './Collection';
-import type DataAdapter from './DataAdapter';
-import type { CollectionBackend } from './DataAdapter';
-import type StorageAdapter from './types/StorageAdapter';
-interface DefaultDataAdapterOptions {
-    storage?: (name: string) => StorageAdapter<any, any> | undefined;
-    onError?: (name: string, error: Error) => void;
-}
-export default class DefaultDataAdapter implements DataAdapter {
-    private items;
-    private options;
-    private storageAdapters;
-    private collections;
-    private indices;
-    private activeQueries;
-    private queryEmitters;
-    private queuedQueryUpdates;
-    private cachedQueryResults;
-    constructor(options?: DefaultDataAdapterOptions);
-    private ensureStorageAdapter;
-    private rebuildIndices;
-    private setupStorageAdapter;
-    private getIndexInfo;
-    private applyIndexDeltas;
-    private getItem;
-    private queryItems;
-    private executeQuery;
-    private flushQueuedQueryUpdates;
-    private executeAndCacheQuery;
-    private updateQueries;
-    createCollectionBackend<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection: Collection<T, I, E, U>, indices: string[]): CollectionBackend<T, I>;
-    fetchItemsFromStorage<T extends BaseItem<I>, I = any, E extends BaseItem = T, U = E>(collection?: Collection<T, I, E, U>): Promise<void>;
-}
-export {};

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

@@ -1,408 +0,0 @@
-"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 projectItems_1 = __importDefault(require("./utils/projectItems"));
-const incrementalQueryUpdate_1 = __importDefault(require("./utils/incrementalQueryUpdate"));
-const queryDelta_1 = require("./utils/queryDelta");
-const queryId_1 = __importDefault(require("./utils/queryId"));
-const serializeValue_1 = __importDefault(require("./utils/serializeValue"));
-const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
-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) {
-            const idResult = (0, idIndexQuery_1.default)(selector);
-            if (idResult.matched) {
-                return {
-                    // This adapter keys its in-memory map by `serializeValue(id)`.
-                    matched: true,
-                    ids: idResult.ids.map(id => (0, serializeValue_1.default)(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;
-        return (0, projectItems_1.default)(limited, 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 changeset = {
-            upserts: [...changes.added, ...changes.modified],
-            deletes: changes.removed.map(item => item.id),
-        };
-        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, changeset);
-        });
-    }
-    executeAndCacheQuery(collection, selector, options, changes) {
-        const cached = this.cachedQueryResults.get(collection.name)?.get((0, queryId_1.default)(selector, options));
-        // With the change in hand and the previous result cached, the query can be brought up to date
-        // without walking every item this collection holds — and the listeners can be told what
-        // changed instead of being left to compare the two results themselves.
-        const incremental = changes && cached
-            ? (0, incrementalQueryUpdate_1.default)(cached, selector, options, changes)
-            : null;
-        const result = incremental ?? this.executeQuery(collection, selector, options);
-        const delta = cached ? (0, queryDelta_1.diffQueryResults)(cached, result) : undefined;
-        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;
-        if (delta && (0, queryDelta_1.isEmptyQueryDelta)(delta))
-            return;
-        emitter.emit('change', selector, options, 'complete', delta);
-    }
-    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, delta) => {
-                    if ((0, queryId_1.default)(querySelector, queryOptions) !== (0, queryId_1.default)(selector, options))
-                        return;
-                    (0, queryDelta_1.callWithDelta)(callback, state, delta);
-                };
-                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

@@ -1,79 +0,0 @@
-import type { BaseItem } from './Collection';
-import type Collection from './Collection';
-import type DataAdapter from './DataAdapter';
-import type { CollectionBackend } from './DataAdapter';
-interface WorkerDataAdapterOptions {
-    id?: string;
-    log?: (message: string, ...args: any[]) => void;
-}
-export 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;
-    private id;
-    private isDisposed;
-    private workerReady;
-    private log;
-    private collectionReady;
-    private batchExecutionHelpers;
-    private queries;
-    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>;
-}
-export {};