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

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

@@ -0,0 +1,580 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndex = void 0;
+const EventEmitter_1 = __importDefault(require("../utils/EventEmitter"));
+const createSignal_1 = __importDefault(require("../utils/createSignal"));
+const randomId_1 = __importDefault(require("../utils/randomId"));
+const DefaultDataAdapter_1 = __importDefault(require("../DefaultDataAdapter"));
+const modify_1 = __importDefault(require("../utils/modify"));
+const deepClone_1 = __importDefault(require("../utils/deepClone"));
+const queryId_1 = __importDefault(require("../utils/queryId"));
+const Cursor_1 = __importDefault(require("./Cursor"));
+var createIndex_1 = require("../createIndex");
+Object.defineProperty(exports, "createIndex", { enumerable: true, get: function () { return __importDefault(createIndex_1).default; } });
+/**
+ * Represents a collection of data items with support for in-memory operations,
+ * persistence, reactivity, and event-based notifications. The collection provides
+ * CRUD operations, observer patterns, and batch operations.
+ * @template T - The type of the items stored in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @template U - The transformed item type after applying transformations (default is T).
+ */
+class Collection extends EventEmitter_1.default {
+    static collections = [];
+    static debugMode = false;
+    static batchOperationInProgress = false;
+    static fieldTracking = false;
+    static onCreationCallbacks = [];
+    static onDisposeCallbacks = [];
+    static getCollections() {
+        return Collection.collections;
+    }
+    static onCreation(callback) {
+        Collection.onCreationCallbacks.push(callback);
+    }
+    static onDispose(callback) {
+        Collection.onDisposeCallbacks.push(callback);
+    }
+    /**
+     * Enables debug mode for all collections.
+     */
+    static enableDebugMode = () => {
+        Collection.debugMode = true;
+        Collection.collections.forEach((collection) => {
+            collection.setDebugMode(true);
+        });
+    };
+    /**
+     * Enables field tracking for all collections.
+     * @param enable - A boolean indicating whether to enable field tracking.
+     */
+    static setFieldTracking = (enable) => {
+        Collection.fieldTracking = enable;
+        Collection.collections.forEach((collection) => {
+            collection.setFieldTracking(enable);
+        });
+    };
+    static batch(callback) {
+        Collection.batchOperationInProgress = true;
+        const execute = () => Collection.collections.reduce((memo, collection) => () => {
+            return collection.batch(memo);
+        }, callback)();
+        const maybePromise = execute();
+        const afterBatch = () => {
+            Collection.batchOperationInProgress = false;
+        };
+        if (maybePromise && typeof maybePromise.then === 'function') {
+            return maybePromise
+                .then(() => afterBatch());
+        }
+        else {
+            afterBatch();
+        }
+    }
+    name;
+    backend;
+    options;
+    isPullingSignal;
+    isPushingSignal;
+    readySignal;
+    debugMode;
+    batchOperationInProgress = false;
+    isDisposed = false;
+    postBatchCallbacks = new Set();
+    fieldTracking = false;
+    queryListenersMap = new Map();
+    constructor(nameOrOptions, maybeDataAdapter, maybeOptions) {
+        super();
+        const name = typeof nameOrOptions === 'string'
+            ? nameOrOptions
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            : nameOrOptions?.name || `${this.constructor.name}-${(0, randomId_1.default)()}`;
+        const options = typeof nameOrOptions === 'string'
+            ? maybeOptions || {}
+            : nameOrOptions || {};
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        const persistence = options.persistence;
+        const dataAdapter = maybeDataAdapter || new DefaultDataAdapter_1.default({
+            ...persistence ? { storage: () => persistence } : {},
+        });
+        Collection.collections.push(this);
+        this.name = name;
+        this.options = { ...options };
+        this.fieldTracking = this.options.fieldTracking ?? Collection.fieldTracking;
+        this.debugMode = this.options.enableDebugMode ?? Collection.debugMode;
+        this.isPullingSignal = (0, createSignal_1.default)(this.options.reactivity, false);
+        this.isPushingSignal = (0, createSignal_1.default)(this.options.reactivity, false);
+        this.readySignal = (0, createSignal_1.default)(this.options.reactivity, false);
+        this.backend = dataAdapter.createCollectionBackend(this, this.options.indices ?? []);
+        void this.backend.isReady()
+            .then(() => {
+            this.readySignal.set(true);
+        })
+            .catch(() => { });
+        Collection.onCreationCallbacks.forEach(callback => callback(this));
+    }
+    isBatchOperationInProgress() {
+        return Collection.batchOperationInProgress || this.batchOperationInProgress;
+    }
+    /**
+     * Checks whether the collection is currently performing a pull operation
+     * ⚡️ this function is reactive!
+     * (loading data from the persistence adapter).
+     * @returns A boolean indicating if the collection is in the process of pulling data.
+     */
+    isPulling() {
+        return this.isPullingSignal.get() ?? false;
+    }
+    /**
+     * Checks whether the collection is currently performing a push operation
+     * ⚡️ this function is reactive!
+     * (saving data to the persistence adapter).
+     * @returns A boolean indicating if the collection is in the process of pushing data.
+     */
+    isPushing() {
+        return this.isPushingSignal.get() ?? false;
+    }
+    /**
+     * Checks whether the collection is currently performing either a pull or push operation,
+     * ⚡️ this function is reactive!
+     * indicating that it is loading or saving data.
+     * @returns A boolean indicating if the collection is in the process of loading or saving data.
+     */
+    isLoading() {
+        const isPulling = this.isPulling();
+        const isPushing = this.isPushing();
+        return isPulling || isPushing;
+    }
+    /**
+     * Retrieves the current debug mode status of the collection.
+     * @returns A boolean indicating whether debug mode is enabled for the collection.
+     */
+    getDebugMode() {
+        return this.debugMode;
+    }
+    /**
+     * Enables or disables debug mode for the collection.
+     * When debug mode is enabled, additional debugging information and events are emitted.
+     * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) debug mode.
+     */
+    setDebugMode(enable) {
+        this.debugMode = enable;
+    }
+    /**
+     * Enables or disables field tracking for the collection.
+     * @param enable - A boolean indicating whether to enable (`true`) or disable (`false`) field tracking.
+     */
+    setFieldTracking(enable) {
+        this.fieldTracking = enable;
+    }
+    /**
+     * Resolves when the persistence adapter finished initializing
+     * and the collection is ready to be used.
+     * @returns A promise that resolves when the collection is ready.
+     * @example
+     * ```ts
+     * const collection = new Collection({
+     *   persistence: // ...
+     * })
+     * await collection.isReady()
+     *
+     * collection.insert({ name: 'Item 1' })
+     */
+    async ready() {
+        return this.backend.isReady();
+    }
+    /**
+     * Checks if the collection is ready.
+     * ⚡️ this function is reactive!
+     * @returns A boolean indicating whether the collection is ready.
+     */
+    isReady() {
+        return this.readySignal.get() ?? false;
+    }
+    profile(fn, measureFunction) {
+        if (!this.debugMode)
+            return fn();
+        const startTime = performance.now();
+        const handleProfileEnd = (result) => {
+            const endTime = performance.now();
+            measureFunction(endTime - startTime);
+            return result;
+        };
+        const maybePromise = fn();
+        return maybePromise instanceof Promise
+            ? maybePromise.then(handleProfileEnd)
+            : handleProfileEnd(maybePromise);
+    }
+    executeInDebugMode(fn) {
+        if (!this.debugMode)
+            return;
+        // eslint-disable-next-line unicorn/error-message
+        const callstack = new Error().stack || '';
+        fn(callstack);
+    }
+    transform(item) {
+        if (!this.options.transform)
+            return item;
+        return this.options.transform(item);
+    }
+    transformAll(items, fields) {
+        if (!this.options.transformAll)
+            return items;
+        return this.options.transformAll((0, deepClone_1.default)(items), fields);
+    }
+    getItem(selector, options) {
+        const itemsOrPromise = this.getItems(selector, { ...options, limit: 1 });
+        if (itemsOrPromise instanceof Promise) {
+            return itemsOrPromise.then((items) => {
+                return items[0] || undefined;
+            });
+        }
+        return itemsOrPromise[0];
+    }
+    getItems(selector, options) {
+        this.emit('getItems', selector);
+        return this.profile(() => {
+            if (!options?.async)
+                return this.backend.getQueryResult(selector, options);
+            this.isPullingSignal.set(true);
+            return this.backend.executeQuery(selector, options)
+                .finally(() => {
+                this.isPullingSignal.set(false);
+            });
+        }, measuredTime => this.executeInDebugMode(callstack => this.emit('_debug.getItems', callstack, selector, measuredTime)));
+    }
+    async withPushState(asyncFunction) {
+        this.isPushingSignal.set(true);
+        try {
+            return await asyncFunction();
+        }
+        finally {
+            this.isPushingSignal.set(false);
+        }
+    }
+    queryListeners(query, listeners) {
+        const id = (0, queryId_1.default)(query.selector, query.options);
+        if (listeners != null) {
+            return this.queryListenersMap.set(id, listeners);
+        }
+        return this.queryListenersMap.get(id) ?? 0;
+    }
+    /**
+     * Disposes the collection, unregisters persistence adapters, clears memory, and
+     * cleans up all resources used by the collection.
+     * @returns A promise that resolves when the collection is disposed.
+     */
+    async dispose() {
+        await this.backend.dispose();
+        this.isDisposed = true;
+        this.removeAllListeners();
+        Collection.collections = Collection.collections.filter(collection => collection !== this);
+        Collection.onDisposeCallbacks.forEach(callback => callback(this));
+    }
+    find(selector = {}, options) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (selector !== undefined && (!selector || typeof selector !== 'object'))
+            throw new Error('Invalid selector');
+        const getTransformedItems = () => {
+            const itemsOrPromise = this.getItems(selector, options || {});
+            if (itemsOrPromise instanceof Promise) {
+                return itemsOrPromise.then((items) => {
+                    return this.transformAll(items, options?.fields);
+                });
+            }
+            const items = itemsOrPromise;
+            return this.transformAll(items, options?.fields);
+        };
+        const cursor = new Cursor_1.default(getTransformedItems, {
+            reactive: this.options.reactivity,
+            fieldTracking: this.fieldTracking,
+            ...options,
+            transform: this.transform.bind(this),
+            bindEvents: (requery) => {
+                const handleRequery = () => {
+                    if (this.batchOperationInProgress) {
+                        this.postBatchCallbacks.add(requery);
+                        return;
+                    }
+                    requery();
+                };
+                // register query if not yet registered
+                const listeners = this.queryListeners({ selector, options });
+                const didRegister = listeners === 0;
+                if (didRegister)
+                    this.backend.registerQuery(selector, options || {});
+                this.queryListeners({ selector, options }, listeners + 1);
+                const queryStateChangeCleanup = this.backend.onQueryStateChange(selector, options || {}, (state) => {
+                    if (state !== 'complete')
+                        return;
+                    handleRequery();
+                });
+                this.emit('observer.created', selector, options);
+                return () => {
+                    // Use queueMicrotask instead of setTimeout to avoid race conditions
+                    // while still allowing batching of quick register/unregister calls
+                    queueMicrotask(() => {
+                        // unregister query if no more listeners
+                        const newListeners = Math.max(0, this.queryListeners({ selector, options }) - 1);
+                        // Only unregister if this observer was the one that registered
+                        // This prevents race conditions where a new observer registers
+                        // before the old one's cleanup runs
+                        if (newListeners === 0 && didRegister)
+                            this.backend.unregisterQuery(selector, options || {});
+                        this.queryListeners({ selector, options }, newListeners);
+                        queryStateChangeCleanup();
+                        this.emit('observer.disposed', selector, options);
+                    });
+                };
+            },
+        });
+        this.emit('find', selector, options, cursor);
+        this.executeInDebugMode(callstack => this.emit('_debug.find', callstack, selector, options, cursor));
+        return cursor;
+    }
+    findOne(selector, options) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        const cursor = this.find(selector, {
+            limit: 1,
+            ...options,
+        });
+        const handleItems = (items) => {
+            const returnValue = items[0] || undefined;
+            this.emit('findOne', selector, options, returnValue);
+            this.executeInDebugMode(callstack => this.emit('_debug.findOne', callstack, selector, options, returnValue));
+            return returnValue;
+        };
+        const maybePromise = cursor.fetch();
+        return (maybePromise instanceof Promise
+            ? maybePromise.then(handleItems)
+            : handleItems(maybePromise));
+    }
+    batch(callback) {
+        if (this.batchOperationInProgress)
+            return callback();
+        this.batchOperationInProgress = true;
+        const maybePromise = callback();
+        const afterBatch = () => {
+            this.batchOperationInProgress = false;
+            this.postBatchCallbacks.forEach(callback_ => callback_());
+            this.postBatchCallbacks.clear();
+        };
+        if (maybePromise && typeof maybePromise.then === 'function') {
+            return maybePromise.then(() => afterBatch());
+        }
+        else {
+            afterBatch();
+        }
+    }
+    onPostBatch(callback) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (this.batchOperationInProgress) {
+            this.postBatchCallbacks.add(callback);
+            return;
+        }
+        return callback();
+    }
+    /**
+     * Inserts a single item into the collection. Generates a unique ID if not provided.
+     * @param item - The item to insert.
+     * @returns The ID of the inserted item.
+     * @throws {Error} If the collection is disposed or the item has an invalid ID.
+     */
+    async insert(item) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!item)
+            throw new Error('Invalid item');
+        const primaryKeyGenerator = this.options.primaryKeyGenerator ?? randomId_1.default;
+        const itemWithId = {
+            id: primaryKeyGenerator(item),
+            ...item,
+        };
+        this.emit('validate', itemWithId);
+        const newItem = await this.withPushState(() => this.backend.insert(itemWithId));
+        this.emit('added', newItem);
+        this.emit('insert', newItem);
+        this.executeInDebugMode(callstack => this.emit('_debug.insert', callstack, newItem));
+        return newItem.id;
+    }
+    /**
+     * Inserts multiple items into the collection. Generates unique IDs for items if not provided.
+     * @param items - The items to insert.
+     * @returns An array of IDs of the inserted items.
+     * @throws {Error} If the collection is disposed or the items are invalid.
+     */
+    async insertMany(items) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!items)
+            throw new Error('Invalid items');
+        if (items.length === 0)
+            return [];
+        const ids = [];
+        await this.batch(async () => {
+            await Promise.all(items.map(async (item) => {
+                ids.push(await this.insert(item));
+            }));
+        });
+        return ids;
+    }
+    /**
+     * Updates a single item in the collection that matches the given selector.
+     * @param selector - The criteria to select the item to update.
+     * @param modifier - The modifications to apply to the item.
+     * @param [options] - Optional settings for the update operation.
+     * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
+     * @returns The number of items updated (0 or 1).
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    async updateOne(selector, modifier, options) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!selector)
+            throw new Error('Invalid selector');
+        if (!modifier)
+            throw new Error('Invalid modifier');
+        const { $setOnInsert, ...restModifier } = modifier;
+        const item = await this.getItem(selector, { async: true });
+        if (item == null) {
+            if (options?.upsert) {
+                // if upsert is enabled, insert a new item
+                const newItem = (0, modify_1.default)({}, {
+                    ...restModifier,
+                    $set: {
+                        ...$setOnInsert,
+                        ...restModifier.$set,
+                    },
+                });
+                await this.insert(newItem);
+                return 1;
+            }
+            return 0; // no item found, and upsert is not enabled
+        }
+        const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+        this.emit('validate', modifiedItem);
+        const changes = await this.withPushState(() => this.backend.updateOne(selector, modifier));
+        this.emit('changed', modifiedItem, restModifier);
+        this.emit('updateOne', selector, modifier);
+        this.executeInDebugMode(callstack => this.emit('_debug.updateOne', callstack, selector, modifier));
+        return changes.length;
+    }
+    /**
+     * Updates multiple items in the collection that match the given selector.
+     * @param selector - The criteria to select the items to update.
+     * @param modifier - The modifications to apply to the items.
+     * @param [options] - Optional settings for the update operation.
+     * @param [options.upsert] - If `true`, creates new items if no items match the selector.
+     * @returns The number of items updated.
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    async updateMany(selector, modifier, options) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!selector)
+            throw new Error('Invalid selector');
+        if (!modifier)
+            throw new Error('Invalid modifier');
+        const { $setOnInsert, ...restModifier } = modifier;
+        const items = await this.getItems(selector, { async: true });
+        if (items.length === 0) {
+            if (options?.upsert) {
+                // if upsert is enabled, insert a new item
+                const newItem = (0, modify_1.default)({}, {
+                    ...restModifier,
+                    $set: {
+                        ...$setOnInsert,
+                        ...restModifier.$set,
+                    },
+                });
+                await this.insert(newItem);
+                return 1;
+            }
+            return 0; // no items found, and upsert is not enabled
+        }
+        items.forEach((item) => {
+            const modifiedItem = (0, modify_1.default)((0, deepClone_1.default)(item), restModifier);
+            this.emit('validate', modifiedItem);
+        });
+        const changes = await this.withPushState(() => this.backend.updateMany(selector, modifier));
+        changes.forEach((item) => {
+            this.emit('changed', item, restModifier);
+        });
+        this.emit('updateMany', selector, modifier);
+        this.executeInDebugMode(callstack => this.emit('_debug.updateMany', callstack, selector, modifier));
+        return changes.length;
+    }
+    /**
+     * Replaces a single item in the collection that matches the given selector.
+     * @param selector - The criteria to select the item to replace.
+     * @param replacement - The item to replace the selected item with.
+     * @param [options] - Optional settings for the replace operation.
+     * @param [options.upsert] - If `true`, creates a new item if no item matches the selector.
+     * @returns The number of items replaced (0 or 1).
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    async replaceOne(selector, replacement, options) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!selector)
+            throw new Error('Invalid selector');
+        const item = await this.getItem(selector, { async: true });
+        if (item == null) {
+            if (options?.upsert) {
+                await this.insert(replacement);
+                return 1;
+            }
+            return 0; // no item found, and upsert is not enabled
+        }
+        const modifiedItem = { id: item.id, ...replacement };
+        this.emit('validate', modifiedItem);
+        const changes = await this.withPushState(() => this.backend.replaceOne(selector, replacement));
+        this.emit('changed', modifiedItem, replacement);
+        this.emit('replaceOne', selector, replacement);
+        this.executeInDebugMode(callstack => this.emit('_debug.replaceOne', callstack, selector, replacement));
+        return changes.length;
+    }
+    /**
+     * Removes a single item from the collection that matches the given selector.
+     * @param selector - The criteria to select the item to remove.
+     * @returns The number of items removed (0 or 1).
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    async removeOne(selector) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!selector)
+            throw new Error('Invalid selector');
+        const removedItems = await this.withPushState(() => this.backend.removeOne(selector));
+        this.emit('removed', removedItems[0]);
+        this.emit('removeOne', selector);
+        this.executeInDebugMode(callstack => this.emit('_debug.removeOne', callstack, selector));
+        return removedItems.length;
+    }
+    /**
+     * Removes multiple items from the collection that match the given selector.
+     * @param selector - The criteria to select the items to remove.
+     * @returns The number of items removed.
+     * @throws {Error} If the collection is disposed or invalid arguments are provided.
+     */
+    async removeMany(selector) {
+        if (this.isDisposed)
+            throw new Error('Collection is disposed');
+        if (!selector)
+            throw new Error('Invalid selector');
+        const removedItems = await this.withPushState(() => this.backend.removeMany(selector));
+        removedItems.forEach((item) => {
+            this.emit('removed', item);
+        });
+        this.emit('removeMany', selector);
+        this.executeInDebugMode(callstack => this.emit('_debug.removeMany', callstack, selector));
+        return removedItems.length;
+    }
+}
+exports.default = Collection;

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

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

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

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

@@ -0,0 +1,35 @@
+import type { BaseItem, FieldSpecifier, SortSpecifier } from './Collection';
+import type Collection from './Collection';
+import type Modifier from './types/Modifier';
+import type Selector from './types/Selector';
+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;
+}
+export type StateChangeCallback = (state: 'active' | 'complete' | 'error') => 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;
+    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): () => 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

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

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

@@ -0,0 +1,35 @@
+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 {};