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

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

@@ -1,64 +0,0 @@
-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';
-export interface WorkerDataAdapterHostEndpoint {
-    addEventListener: (type: 'message', listener: (event: MessageEvent) => any) => void;
-    postMessage: (message: any) => void;
-}
-interface WorkerDataAdapterHostOptions {
-    id?: string;
-    storage: (name: string) => StorageAdapter<any, any>;
-    onError?: (error: Error) => void;
-    log?: (message: string, ...args: any[]) => void;
-}
-type CollectionMethods<T extends BaseItem<I>, I = any> = {
-    registerCollection: (collectionName: string, indices: string[]) => Promise<void>;
-    unregisterCollection: (collectionName: string) => Promise<void>;
-    registerQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
-    unregisterQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<void>;
-    executeQuery: <O extends QueryOptions<T>>(collectionName: string, selector: Selector<T>, options?: O) => Promise<T[]>;
-    insert: (collectionName: string, items: [T][]) => Promise<(T | Error)[]>;
-    updateOne: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
-    updateMany: (collectionName: string, args: [Selector<T>, Modifier<T>][]) => Promise<(T[] | Error)[]>;
-    replaceOne: (collectionName: string, args: [Selector<T>, Omit<T, 'id'> & Partial<Pick<T, 'id'>>][]) => Promise<(T[] | Error)[]>;
-    removeOne: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
-    removeMany: (collectionName: string, selectors: [Selector<T>][]) => Promise<(T[] | Error)[]>;
-    isReady: (collectionName: string) => Promise<void>;
-};
-export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
-    private workerContext;
-    private options;
-    private id;
-    private log;
-    private storageAdapters;
-    private storageAdapterReady;
-    private collectionIndices;
-    private queries;
-    private onError;
-    constructor(workerContext: WorkerDataAdapterHostEndpoint, options: WorkerDataAdapterHostOptions);
-    private respond;
-    private handleMessage;
-    private getIndexInfo;
-    private queryItems;
-    private executeQuery;
-    private ensureQuery;
-    private setQueryItems;
-    private queryItemIds;
-    private emitQueryUpdate;
-    private ensureStorageAdapter;
-    private checkQueryUpdates;
-    protected registerCollection: CollectionMethods<T, I>['registerCollection'];
-    protected unregisterCollection: CollectionMethods<T, I>['unregisterCollection'];
-    protected registerQuery: CollectionMethods<T, I>['registerQuery'];
-    protected unregisterQuery: CollectionMethods<T, I>['unregisterQuery'];
-    protected insert: CollectionMethods<T, I>['insert'];
-    protected updateOne: CollectionMethods<T, I>['updateOne'];
-    protected updateMany: CollectionMethods<T, I>['updateMany'];
-    protected replaceOne: CollectionMethods<T, I>['replaceOne'];
-    protected removeOne: CollectionMethods<T, I>['removeOne'];
-    protected removeMany: CollectionMethods<T, I>['removeMany'];
-    protected isReady: CollectionMethods<T, I>['isReady'];
-}
-export {};

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

@@ -1,430 +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 deepClone_1 = __importDefault(require("./utils/deepClone"));
-const match_1 = __importDefault(require("./utils/match"));
-const modify_1 = __importDefault(require("./utils/modify"));
-const queryId_1 = __importDefault(require("./utils/queryId"));
-const isEqual_1 = __importDefault(require("./utils/isEqual"));
-const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
-const idIndexQuery_1 = __importDefault(require("./utils/idIndexQuery"));
-const storageIndexQuery_1 = __importDefault(require("./utils/storageIndexQuery"));
-const sortItems_1 = __importDefault(require("./utils/sortItems"));
-const projectItems_1 = __importDefault(require("./utils/projectItems"));
-const compact_1 = __importDefault(require("./utils/compact"));
-const incrementalQueryUpdate_1 = __importDefault(require("./utils/incrementalQueryUpdate"));
-const queryDelta_1 = require("./utils/queryDelta");
-/**
- * Turns the item states a write produced into the upsert/delete split a query update needs.
- *
- * The two lists are not symmetric: an item that is still there after the write is described by
- * its new state, while an item that is gone — removed, or given a new id — is described by the id
- * it used to have and nothing else. Mixing the states from before and after a write into one list
- * loses exactly that distinction.
- * @template T - The type of the items.
- * @param previousItems - The items as they were before the write.
- * @param modifiedItems - The items as they are after it.
- * @returns The changeset describing the write.
- */
-function toChangeset(previousItems, modifiedItems) {
-    const modifiedIds = new Set(modifiedItems.map(item => item.id));
-    return {
-        upserts: modifiedItems,
-        deletes: previousItems
-            .map(item => item.id)
-            .filter(id => !modifiedIds.has(id)),
-    };
-}
-class WorkerDataAdapterHost {
-    workerContext;
-    options;
-    id;
-    log = () => { };
-    storageAdapters = new Map();
-    storageAdapterReady = new Map();
-    collectionIndices = new Map();
-    queries = new Map();
-    onError = (error) => {
-        // eslint-disable-next-line no-console
-        console.error(error);
-    };
-    constructor(workerContext, options) {
-        this.workerContext = workerContext;
-        this.options = options;
-        this.id = this.options.id || 'default-worker-data-adapter';
-        if (this.options.onError) {
-            this.onError = this.options.onError;
-        }
-        if (this.options.log)
-            this.log = this.options.log;
-        this.workerContext.addEventListener('message', async (event) => {
-            try {
-                const { workerId, id, method, args } = event.data;
-                await this.handleMessage(workerId, id, method, args);
-            }
-            catch (error) {
-                this.onError(error);
-            }
-        });
-        this.respond('ready', null, null, 'ready');
-    }
-    respond(id, data, error = null, type = 'response') {
-        this.workerContext.postMessage({ id, workerId: this.id, type, data, error });
-    }
-    async handleMessage(workerId, id, method, args) {
-        if (workerId !== this.id)
-            return;
-        const fn = this[method];
-        if (typeof fn !== 'function') {
-            this.respond(id, null, new Error(`Method ${method} not found`));
-            return;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        this.log(method, ...args);
-        // wait for the storage adapter to be ready
-        await this.isReady(args[0]);
-        try {
-            const result = await fn.apply(this, args);
-            this.respond(id, result);
-        }
-        catch (error) {
-            this.respond(id, null, error);
-        }
-    }
-    async getIndexInfo(collectionName, selector) {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        // `id` needs no declared index: `readIds` is exactly the lookup it
-        // describes, so every inclusive form of it is answered here rather than by
-        // reading the whole collection (utils/idIndexQuery.ts).
-        if (selector != null && Object.keys(selector).length === 1 && 'id' in selector) {
-            const idResult = (0, idIndexQuery_1.default)(selector);
-            if (idResult.matched) {
-                return {
-                    matched: true,
-                    ids: (0, compact_1.default)(idResult.ids),
-                    optimizedSelector: {},
-                };
-            }
-        }
-        if (selector == null) {
-            return {
-                matched: false,
-                ids: [],
-                optimizedSelector: {},
-            };
-        }
-        const indices = this.collectionIndices.get(collectionName) ?? [];
-        // `id` first, and always present: it needs no declared index, because
-        // `readIds` is exactly the lookup it describes (utils/idIndexQuery.ts).
-        return (0, getIndexInfo_1.default)(indices.map(field => (0, storageIndexQuery_1.default)(storageAdapter, field)), selector);
-    }
-    async queryItems(collectionName, selector) {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const indexInfo = await this.getIndexInfo(collectionName, 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;
-        };
-        if (indexInfo.matched) {
-            const items = await storageAdapter.readIds(indexInfo.ids);
-            if ((0, isEqual_1.default)(indexInfo.optimizedSelector, {}))
-                return items;
-            return items.filter(matchItems);
-        }
-        else {
-            const allItems = await storageAdapter.readAll();
-            if ((0, isEqual_1.default)(selector, {}))
-                return allItems;
-            return allItems.filter(matchItems);
-        }
-    }
-    async executeQuery(collectionName, selector, options) {
-        // null selector means no matches
-        if (selector === null)
-            return [];
-        const items = await this.queryItems(collectionName, 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);
-    }
-    ensureQuery(collectionName, selector, options) {
-        const id = (0, queryId_1.default)(selector, options);
-        if (!this.queries.get(collectionName)) {
-            throw new Error(`Collection ${collectionName} not initialized!`);
-        }
-        let query = this.queries.get(collectionName)?.get(id);
-        if (!query) {
-            query = { selector, options, items: null };
-            this.queries.get(collectionName)?.set(id, query);
-        }
-        return query;
-    }
-    setQueryItems(query, items) {
-        query.items = items;
-        query.itemIds = undefined;
-    }
-    queryItemIds(query) {
-        if (!query.itemIds)
-            query.itemIds = new Set((query.items ?? []).map(item => item.id));
-        return query.itemIds;
-    }
-    emitQueryUpdate(collectionName, selector, options, state, error, items, delta) {
-        const id = (0, queryId_1.default)(selector, options);
-        const collectionQueries = this.queries.get(collectionName);
-        if (!collectionQueries)
-            throw new Error(`Collection ${collectionName} not initialized!`);
-        // `qid` is what the adapter routes on. It is derived from the same selector/options pair the
-        // adapter registered the query with, so sending it saves every recipient from re-deriving it.
-        //
-        // `items` and `delta` are alternatives: the first answer to a query carries the whole result
-        // because the recipient holds nothing yet, every answer after it carries only what changed.
-        // Everything in this message is structurally cloned on its way out of the worker, which is why
-        // it matters that editing one field of one row no longer costs a copy of the entire result.
-        this.respond(id, { collectionName, qid: id, selector, options, state, error, items, delta }, null, 'queryUpdate');
-    }
-    ensureStorageAdapter(name) {
-        if (this.storageAdapters.has(name))
-            return; // already created
-        const adapter = this.options.storage(name);
-        if (!adapter)
-            return; // no adapter returned
-        this.storageAdapters.set(name, adapter);
-    }
-    async checkQueryUpdates(collectionName, changes) {
-        const queries = this.queries.get(collectionName);
-        if (!queries)
-            throw new Error(`Collection ${collectionName} not initialized!`);
-        if (changes.upserts.length === 0 && changes.deletes.length === 0)
-            return;
-        // A query is affected when the write produces something it should hold, or takes away
-        // something it already holds. The second half is what the write itself cannot tell us: an
-        // item that no longer matches, or that was removed outright, is invisible to the matcher.
-        const affectedQueries = [...queries.values()].filter((query) => {
-            const ids = this.queryItemIds(query);
-            if (changes.deletes.some(id => ids.has(id)))
-                return true;
-            return changes.upserts.some(item => ids.has(item.id) || (0, match_1.default)(item, query.selector));
-        });
-        if (affectedQueries.length === 0)
-            return; // no active queries affected
-        await Promise.all(affectedQueries.map(async (query) => {
-            const { selector, options } = query;
-            const previous = query.items;
-            const incremental = previous == null
-                ? null
-                : (0, incrementalQueryUpdate_1.default)(previous, selector, options, changes);
-            if (incremental != null) {
-                // Answered from the previous result, without touching the store — so there is no window in
-                // which the query is stale, and nothing to announce with an `'active'` state either.
-                const delta = (0, queryDelta_1.diffQueryResults)(previous, incremental);
-                if ((0, queryDelta_1.isEmptyQueryDelta)(delta))
-                    return;
-                this.setQueryItems(query, incremental);
-                this.emitQueryUpdate(collectionName, selector, options, 'complete', null, undefined, delta);
-                return;
-            }
-            this.emitQueryUpdate(collectionName, selector, options, 'active', null);
-            const queryItems = await this.executeQuery(collectionName, selector, options);
-            if (previous == null) {
-                this.setQueryItems(query, queryItems);
-                this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
-                return;
-            }
-            const delta = (0, queryDelta_1.diffQueryResults)(previous, queryItems);
-            this.setQueryItems(query, queryItems);
-            this.emitQueryUpdate(collectionName, selector, options, 'complete', null, undefined, delta);
-        }));
-    }
-    registerCollection = async (collectionName, indices) => {
-        this.collectionIndices.set(collectionName, indices);
-        this.queries.set(collectionName, new Map());
-        this.ensureStorageAdapter(collectionName);
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const setupPromise = (async () => {
-            await storageAdapter.setup();
-            await Promise.all(indices.map(index => storageAdapter.createIndex(index)));
-        })();
-        this.storageAdapterReady.set(collectionName, setupPromise);
-        await setupPromise;
-    };
-    unregisterCollection = async (collectionName) => {
-        this.storageAdapters.delete(collectionName);
-        this.queries.delete(collectionName);
-    };
-    registerQuery = async (collectionName, selector, options) => {
-        const query = this.ensureQuery(collectionName, selector, options);
-        const queryItems = await this.executeQuery(collectionName, selector, options);
-        // Always the full result, even for a query that is already registered: whoever is registering
-        // holds nothing for it yet, and a delta would be relative to a result only the host has seen.
-        this.setQueryItems(query, queryItems);
-        this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
-    };
-    unregisterQuery = async (collectionName, selector, options) => {
-        const id = (0, queryId_1.default)(selector, options);
-        if (!this.queries.get(collectionName))
-            throw new Error(`Collection ${collectionName} not initialized!`);
-        this.queries.get(collectionName)?.delete(id);
-    };
-    insert = async (collectionName, input) => {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const existingItems = await this.executeQuery(collectionName, { id: { $in: input.map(i => i[0].id) } });
-        const result = input.map(([item]) => {
-            if (item.id == null)
-                return new Error('Item must have an id');
-            if (existingItems.some(existing => existing.id === item.id)) {
-                return new Error(`Item with id ${item.id} already exists`);
-            }
-            return item;
-        });
-        const newItems = result.filter(item => !(item instanceof Error));
-        await storageAdapter.insert(newItems);
-        await this.checkQueryUpdates(collectionName, { upserts: newItems, deletes: [] });
-        return result;
-    };
-    updateOne = async (collectionName, parameters) => {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const previousItems = [];
-        const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
-            const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then(items => items[0] ?? null);
-            const { $setOnInsert, ...restModifier } = modifier;
-            if (item == null)
-                return [];
-            previousItems.push(item);
-            const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
-            if (item.id !== modifiedItem.id) {
-                const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-                if (existingItems.length > 0) {
-                    return new Error(`Item with id ${modifiedItem.id} already exists`);
-                }
-            }
-            return [modifiedItem];
-        }));
-        const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
-        if (modifiedItems.length > 0) {
-            await storageAdapter.replace(modifiedItems);
-            await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
-        }
-        return result;
-    };
-    updateMany = async (collectionName, parameters) => {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const previousItems = [];
-        const result = await Promise.all(parameters.map(async ([selector, modifier]) => {
-            const items = await this.executeQuery(collectionName, selector);
-            if (items.length === 0)
-                return []; // no items found, nothing to update
-            const { $setOnInsert, ...restModifier } = modifier;
-            try {
-                const changedItems = await Promise.all(items.map(async (item) => {
-                    const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
-                    if (item.id !== modifiedItem.id) {
-                        const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-                        if (existingItems.length > 0) {
-                            throw new Error(`Item with id ${modifiedItem.id} already exists`);
-                        }
-                    }
-                    previousItems.push(item);
-                    return modifiedItem;
-                }));
-                return changedItems;
-            }
-            catch (error) {
-                return error;
-            }
-        }));
-        const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
-        if (modifiedItems.length > 0) {
-            await storageAdapter.replace(modifiedItems);
-            await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
-        }
-        return result;
-    };
-    replaceOne = async (collectionName, parameters) => {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const previousItems = [];
-        const result = await Promise.all(parameters.map(async ([selector, replacement,]) => {
-            const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then(items => items[0] ?? null);
-            if (item == null)
-                return []; // no item found, nothing to update
-            previousItems.push(item);
-            const modifiedItem = {
-                ...replacement,
-                id: replacement.id ?? item.id,
-            };
-            if (item.id !== modifiedItem.id) {
-                const existingItems = await this.executeQuery(collectionName, { id: modifiedItem.id }, { limit: 1 });
-                if (existingItems.length > 0) {
-                    return new Error(`Item with id ${modifiedItem.id} already exists`);
-                }
-            }
-            return [modifiedItem];
-        }));
-        const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
-        if (modifiedItems.length > 0) {
-            await storageAdapter.replace(modifiedItems);
-            await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
-        }
-        return result;
-    };
-    removeOne = async (collectionName, selectors) => {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const result = await Promise.all(selectors.map(async ([selector]) => {
-            const item = await this.executeQuery(collectionName, selector, { limit: 1 }).then(items => items[0] ?? null);
-            if (item == null)
-                return []; // no item found, nothing to remove
-            return [item];
-        }));
-        const items = result.flat();
-        if (items.length > 0) {
-            await storageAdapter.remove(items);
-            await this.checkQueryUpdates(collectionName, {
-                upserts: [],
-                deletes: items.map(item => item.id),
-            });
-        }
-        return result;
-    };
-    removeMany = async (collectionName, selectors) => {
-        const storageAdapter = this.storageAdapters.get(collectionName);
-        if (!storageAdapter)
-            throw new Error(`No persistence adapter for collection ${collectionName}`);
-        const result = await Promise.all(selectors.map(async ([selector]) => this.executeQuery(collectionName, selector)));
-        const items = result.flat();
-        if (items.length > 0) {
-            await storageAdapter.remove(items);
-            await this.checkQueryUpdates(collectionName, {
-                upserts: [],
-                deletes: items.map(item => item.id),
-            });
-        }
-        return result;
-    };
-    isReady = async (collectionName) => {
-        return this.storageAdapterReady.get(collectionName);
-    };
-}
-exports.default = WorkerDataAdapterHost;

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

@@ -1,7 +0,0 @@
-import type { 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>;

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

@@ -1,120 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createIndex;
-const createIndexProvider_1 = __importDefault(require("./createIndexProvider"));
-const get_1 = __importDefault(require("./utils/get"));
-const getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
-const serializeValue_1 = __importDefault(require("./utils/serializeValue"));
-/**
- * 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
- */
-function createIndex(field) {
-    const index = new Map();
-    const ensureSet = (key) => {
-        let set = index.get(key);
-        if (!set) {
-            set = new Set();
-            index.set(key, set);
-        }
-        return set;
-    };
-    return (0, createIndexProvider_1.default)({
-        query(selector) {
-            if (!Object.hasOwnProperty.call(selector, field)) {
-                // If the field is not present in the selector, we can't optimize
-                return { matched: false };
-            }
-            const fieldSelector = selector[field];
-            const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
-            const keys = filteresForNull
-                ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
-                : (0, getMatchingKeys_1.default)(field, selector);
-            if (keys.include == null && keys.exclude == null)
-                return { matched: false };
-            // Accumulate included positions
-            let includedIds = [];
-            if (keys.include == null) {
-                for (const set of index.values()) {
-                    for (const pos of set) {
-                        includedIds.push(pos);
-                    }
-                }
-            }
-            else {
-                for (const key of keys.include) {
-                    const posSet = index.get(key);
-                    if (posSet) {
-                        for (const pos of posSet) {
-                            includedIds.push(pos);
-                        }
-                    }
-                }
-            }
-            // If exclusion is specified, build a single set of all positions to exclude.
-            if (keys.exclude != null) {
-                const excludeIds = new Set();
-                for (const key of keys.exclude) {
-                    const posSet = index.get(key);
-                    if (posSet) {
-                        for (const pos of posSet) {
-                            excludeIds.add(pos);
-                        }
-                    }
-                }
-                // Filter out any position that exists in the exclude set.
-                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
-            }
-            return {
-                matched: true,
-                ids: includedIds,
-                fields: [field],
-                keepSelector: filteresForNull,
-            };
-        },
-        rebuild(items) {
-            index.clear();
-            items.forEach((item) => {
-                const value = (0, serializeValue_1.default)((0, get_1.default)(item, field));
-                ensureSet(value).add(item.id);
-            });
-        },
-        // NEW: delta methods
-        insert(items) {
-            for (const item of items) {
-                const value = (0, serializeValue_1.default)((0, get_1.default)(item, field));
-                ensureSet(value).add(item.id);
-            }
-        },
-        remove(items) {
-            for (const item of items) {
-                const value = (0, serializeValue_1.default)((0, get_1.default)(item, field));
-                const set = index.get(value);
-                if (!set)
-                    continue;
-                set.delete(item.id);
-                if (set.size === 0)
-                    index.delete(value);
-            }
-        },
-        update(pairs) {
-            for (const { oldItem, newItem } of pairs) {
-                const oldValue = (0, serializeValue_1.default)((0, get_1.default)(oldItem, field));
-                const newValue = (0, serializeValue_1.default)((0, get_1.default)(newItem, field));
-                if (oldValue === newValue)
-                    continue;
-                const oldSet = index.get(oldValue);
-                if (oldSet) {
-                    oldSet.delete(oldItem.id);
-                    if (oldSet.size === 0)
-                        index.delete(oldValue);
-                }
-                ensureSet(newValue).add(newItem.id);
-            }
-        },
-    });
-}

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

@@ -1,8 +0,0 @@
-import type { BaseItem } from './Collection';
-import type IndexProvider from './types/IndexProvider';
-/**
- * Creates an IndexProvider based on the given definition.
- * @param definition - The definition of the IndexProvider.
- * @returns The created IndexProvider.
- */
-export default function createIndexProvider<T extends BaseItem<I> = BaseItem, I = any>(definition: IndexProvider<T, I>): IndexProvider<T, I>;

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createIndexProvider;
-/**
- * Creates an IndexProvider based on the given definition.
- * @param definition - The definition of the IndexProvider.
- * @returns The created IndexProvider.
- */
-function createIndexProvider(definition) {
-    return definition;
-}

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

@@ -1,8 +0,0 @@
-import type Dependency from './types/Dependency';
-import type ReactivityAdapter from './types/ReactivityAdapter';
-/**
- * Creates an ReactivityAdapter based on the given definition.
- * @param definition - The definition of the ReactivityAdapter.
- * @returns The created ReactivityAdapter.
- */
-export default function createReactivityAdapter<T extends Dependency = Dependency>(definition: ReactivityAdapter<T>): ReactivityAdapter<T>;

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createReactivityAdapter;
-/**
- * Creates an ReactivityAdapter based on the given definition.
- * @param definition - The definition of the ReactivityAdapter.
- * @returns The created ReactivityAdapter.
- */
-function createReactivityAdapter(definition) {
-    return definition;
-}