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

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

@@ -0,0 +1,62 @@
+import type { BaseItem } from './Collection';
+import type { QueryOptions } from './DataAdapter';
+import type Modifier from './types/Modifier';
+import type StorageAdapter from './types/StorageAdapter';
+import type Selector from './types/Selector';
+interface WorkerContext {
+    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: WorkerContext, options: WorkerDataAdapterHostOptions);
+    private respond;
+    private handleMessage;
+    private getIndexInfo;
+    private queryItems;
+    private executeQuery;
+    private ensureQuery;
+    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

@@ -0,0 +1,409 @@
+"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 getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
+const sortItems_1 = __importDefault(require("./utils/sortItems"));
+const project_1 = __importDefault(require("./utils/project"));
+const compact_1 = __importDefault(require("./utils/compact"));
+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;
+        if (typeof addEventListener === 'undefined' || typeof postMessage === 'undefined') {
+            throw new TypeError('WorkerDataAdapterHost can only be used in a Web Worker context');
+        }
+        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}`);
+        if (selector != null
+            && Object.keys(selector).length === 1
+            && 'id' in selector
+            && typeof selector.id !== 'object') {
+            return {
+                matched: true,
+                ids: (0, compact_1.default)([selector.id]),
+                optimizedSelector: {},
+            };
+        }
+        if (selector == null) {
+            return {
+                matched: false,
+                ids: [],
+                optimizedSelector: {},
+            };
+        }
+        const indices = this.collectionIndices.get(collectionName) ?? [];
+        return (0, getIndexInfo_1.default)(indices.map(field => async (flatSelector) => {
+            if (!Object.hasOwnProperty.call(flatSelector, field)) {
+                // If the field is not present in the selector, we can't optimize
+                return { matched: false };
+            }
+            const index = await storageAdapter.readIndex(field);
+            const fieldSelector = flatSelector[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, flatSelector);
+            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 idSet = index.get(key);
+                    if (idSet) {
+                        for (const id of idSet) {
+                            includedIds.push(id);
+                        }
+                    }
+                }
+            }
+            // 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 idSet = index.get(key);
+                    if (idSet) {
+                        for (const id of idSet) {
+                            excludeIds.add(id);
+                        }
+                    }
+                }
+                // 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,
+            };
+        }), 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;
+        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),
+            };
+        });
+    }
+    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 };
+            this.queries.get(collectionName)?.set(id, query);
+        }
+        return query;
+    }
+    emitQueryUpdate(collectionName, selector, options, state, error, items) {
+        const id = (0, queryId_1.default)(selector, options);
+        const collectionQueries = this.queries.get(collectionName);
+        if (!collectionQueries)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        this.respond(id, { collectionName, selector, options, state, error, items }, 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, items) {
+        const queries = this.queries.get(collectionName);
+        if (!queries)
+            throw new Error(`Collection ${collectionName} not initialized!`);
+        const affectedQueries = [...queries.values()].filter(({ selector }) => items.some(item => (0, match_1.default)(item, selector))) ?? [];
+        if (affectedQueries.length === 0)
+            return; // no active queries affected
+        affectedQueries.forEach(({ selector, options }) => {
+            this.emitQueryUpdate(collectionName, selector, options, 'active', null);
+        });
+        await Promise.all(affectedQueries.map(async ({ selector, options }) => {
+            const queryItems = await this.executeQuery(collectionName, selector, options);
+            this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
+        }));
+    }
+    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) => {
+        this.ensureQuery(collectionName, selector, options);
+        const queryItems = await this.executeQuery(collectionName, selector, options);
+        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, newItems);
+        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, [...modifiedItems, ...previousItems]);
+        }
+        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, [...modifiedItems, ...previousItems]);
+        }
+        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, [...modifiedItems, ...previousItems]);
+        }
+        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, items);
+        }
+        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, items);
+        }
+        return result;
+    };
+    isReady = async (collectionName) => {
+        return this.storageAdapterReady.get(collectionName);
+    };
+}
+exports.default = WorkerDataAdapterHost;

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,120 @@
+"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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+"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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+"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;
+}

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

@@ -0,0 +1,9 @@
+import type StorageAdapter from './types/StorageAdapter';
+/**
+ * Creates an StorageAdapter based on the given definition.
+ * @param definition - The definition of the StorageAdapter.
+ * @returns The created StorageAdapter.
+ */
+export default function createStorageAdapter<T extends {
+    id: I;
+} & Record<string, any>, I>(definition: StorageAdapter<T, I>): StorageAdapter<T, I>;

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

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