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

package/dist/base/core/src/utils/EventEmitter.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A strongly‑typed EventEmitter.
+ */
+class EventEmitter {
+    _maxListeners = 100;
+    /**
+     * We store a set of the listeners for each event.
+     */
+    _listenerStore = new Map();
+    setMaxListeners(max) {
+        this._maxListeners = max;
+        return this;
+    }
+    /**
+     * Subscribe to an event with a listener function.
+     * @param eventName The event name (key of E).
+     * @param listener  A function that receives the emitted arguments.
+     * @returns         The emitter instance (for chaining).
+     */
+    on(eventName, listener) {
+        // Get or create the Map for this particular event name.
+        let listenersSet = this._listenerStore.get(eventName);
+        if (!listenersSet) {
+            listenersSet = new Set();
+            this._listenerStore.set(eventName, listenersSet);
+        }
+        listenersSet.add(listener);
+        if (listenersSet.size > this._maxListeners) {
+            // eslint-disable-next-line no-console
+            console.warn(`Possible EventEmitter memory leak detected. ${listenersSet.size} ${String(eventName)} listeners added. Use emitter.setMaxListeners() to increase limit.`);
+        }
+        return this;
+    }
+    /**
+     * Subscribe to an event with a listener function.
+     * @param eventName The event name (key of E).
+     * @param listener  A function that receives the emitted arguments.
+     * @returns         The emitter instance (for chaining).
+     */
+    addListener(eventName, listener) {
+        return this.on(eventName, listener);
+    }
+    /**
+     * Subscribe to an event, handling it only once. Automatically removes
+     * the listener after it fires the first time.
+     * @param eventName The event name (key of E).
+     * @param listener  A function that receives the emitted arguments.
+     * @returns         The emitter instance (for chaining).
+     */
+    once(eventName, listener) {
+        // We define a wrapper that calls the listener once, then unsubscribes itself.
+        const onceWrapper = ((...args) => {
+            listener(...args);
+            this.off(eventName, onceWrapper);
+        });
+        // Important: explicitly specify <K> to ensure TS sees the same type param
+        return this.on(eventName, onceWrapper);
+    }
+    /**
+     * Unsubscribe a previously subscribed listener.
+     * @param eventName The event name (key of E).
+     * @param listener  The original function passed to `on` or `once`.
+     * @returns         The emitter instance (for chaining).
+     */
+    off(eventName, listener) {
+        const listenersSet = this._listenerStore.get(eventName);
+        if (!listenersSet)
+            return this;
+        listenersSet.delete(listener);
+        // Clean up if there are no more listeners for that event.
+        if (listenersSet.size === 0) {
+            this._listenerStore.delete(eventName);
+        }
+        return this;
+    }
+    /**
+     * Unsubscribe a previously subscribed listener.
+     * @param eventName The event name (key of E).
+     * @param listener  The original function passed to `on` or `once`.
+     * @returns         The emitter instance (for chaining).
+     */
+    removeListener(eventName, listener) {
+        return this.off(eventName, listener);
+    }
+    /**
+     * Emit (dispatch) an event with a variable number of arguments.
+     * @param eventName The event name (key of E).
+     * @param args      The arguments to pass to subscribed listeners.
+     */
+    emit(eventName, ...args) {
+        this.listeners(eventName).forEach((listener) => {
+            listener(...args);
+        });
+    }
+    /**
+     * Returns the array of listener functions currently registered for a given event.
+     * @param eventName The event name (key of E).
+     * @returns         An array of listener functions.
+     */
+    listeners(eventName) {
+        const listenersSet = this._listenerStore.get(eventName);
+        if (!listenersSet)
+            return [];
+        return [...listenersSet.values()];
+    }
+    /**
+     * Returns the number of listeners for a given event.
+     * @param eventName The event name (key of E).
+     * @returns         The number of listeners.
+     */
+    listenerCount(eventName) {
+        const listenersSet = this._listenerStore.get(eventName);
+        return listenersSet ? listenersSet.size : 0;
+    }
+    /**
+     * Removes all listeners for a given event, or all events if none is specified.
+     * @param eventName Optional. If omitted, clears all events’ listeners.
+     * @returns         The emitter instance (for chaining).
+     */
+    removeAllListeners(eventName) {
+        if (eventName === undefined) {
+            // Remove listeners for all events
+            for (const [eventName_, listenersSet] of this._listenerStore.entries()) {
+                for (const listener of listenersSet.values()) {
+                    this.off(eventName_, listener);
+                }
+            }
+            this._listenerStore.clear();
+        }
+        else {
+            const listenersSet = this._listenerStore.get(eventName);
+            if (listenersSet) {
+                for (const listener of listenersSet.values()) {
+                    this.off(eventName, listener);
+                }
+                this._listenerStore.delete(eventName);
+            }
+        }
+        return this;
+    }
+}
+exports.default = EventEmitter;

package/dist/base/core/src/utils/applyQueryOptions.d.ts

@@ -0,0 +1,15 @@
+import type { QueryOptions } from '../DataAdapter';
+import type Selector from '../types/Selector';
+import type { BaseItem } from '../Collection/types';
+/**
+ * Filters, sorts, paginates and projects a plain in-memory array the same way
+ * DefaultDataAdapter and WorkerDataAdapterHost apply a selector/QueryOptions
+ * pair to their stored items. Used to re-derive a query's result locally after
+ * a write, without asking the backing store again.
+ * @template T - The type of the items.
+ * @param items - The items to filter, sort, paginate and project.
+ * @param selector - The selector to match items against.
+ * @param options - Sort, skip, limit and field projection options.
+ * @returns The resulting items.
+ */
+export default function applyQueryOptions<T extends BaseItem>(items: T[], selector: Selector<T>, options?: QueryOptions<T>): T[];

package/dist/base/core/src/utils/applyQueryOptions.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = applyQueryOptions;
+const match_1 = __importDefault(require("./match"));
+const sortItems_1 = __importDefault(require("./sortItems"));
+const project_1 = __importDefault(require("./project"));
+/**
+ * Filters, sorts, paginates and projects a plain in-memory array the same way
+ * DefaultDataAdapter and WorkerDataAdapterHost apply a selector/QueryOptions
+ * pair to their stored items. Used to re-derive a query's result locally after
+ * a write, without asking the backing store again.
+ * @template T - The type of the items.
+ * @param items - The items to filter, sort, paginate and project.
+ * @param selector - The selector to match items against.
+ * @param options - Sort, skip, limit and field projection options.
+ * @returns The resulting items.
+ */
+function applyQueryOptions(items, selector, options) {
+    const matched = selector == null ? [] : items.filter(item => (0, match_1.default)(item, selector));
+    const { sort, skip, limit, fields } = options || {};
+    const sorted = sort ? (0, sortItems_1.default)(matched, sort) : matched;
+    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),
+        };
+    });
+}

package/dist/base/core/src/utils/batchOnNextTick.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Groups multiple calls by key and flushes them on the next tick (macrotask).
+ * @param onFlush - Function that will be called with the key and all queued items when flushing.
+ * @returns An object with `enqueue` and `flush` methods.
+ * @example
+ *   const batcher = batchOnNextTick<string>(async (key, items) => {
+ *     // items is an array of { args, resolve, reject }
+ *     // do something once with all args...
+ *   })
+ *
+ *   batcher.enqueue("my-key", [arg1, arg2])
+ */
+export default function batchOnNextTick<TKey>(onFlush: (key: TKey, items: any[][]) => Promise<any[]>): {
+    enqueue: (key: TKey, args: any[]) => Promise<any>;
+    flush: (key: TKey) => Promise<void>;
+};

package/dist/base/core/src/utils/batchOnNextTick.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = batchOnNextTick;
+/**
+ * Groups multiple calls by key and flushes them on the next tick (macrotask).
+ * @param onFlush - Function that will be called with the key and all queued items when flushing.
+ * @returns An object with `enqueue` and `flush` methods.
+ * @example
+ *   const batcher = batchOnNextTick<string>(async (key, items) => {
+ *     // items is an array of { args, resolve, reject }
+ *     // do something once with all args...
+ *   })
+ *
+ *   batcher.enqueue("my-key", [arg1, arg2])
+ */
+function batchOnNextTick(onFlush) {
+    const queues = new Map();
+    /**
+     * Enqueue a call with the given key and arguments.
+     * @param key key to group calls
+     * @param args arguments for the call
+     * @returns A promise that resolves or rejects when the call is flushed.
+     */
+    function enqueue(key, args) {
+        return new Promise((resolve, reject) => {
+            let q = queues.get(key);
+            if (!q) {
+                q = {
+                    timer: null,
+                    items: [],
+                    flush: () => flush(key),
+                };
+                queues.set(key, q);
+            }
+            q.items.push({ args, resolve, reject });
+            if (q.timer == null) {
+                q.timer = setTimeout(() => {
+                    q.timer = null;
+                    void q.flush();
+                }, 0);
+            }
+        });
+    }
+    /**
+     * Flush the queue for the given key immediately.
+     * @param key key to flush
+     * @returns A promise that resolves when the flush is complete.
+     */
+    async function flush(key) {
+        const q = queues.get(key);
+        if (!q || q.items.length === 0)
+            return;
+        if (q.timer != null) {
+            clearTimeout(q.timer);
+            q.timer = null;
+        }
+        const items = q.items.splice(0);
+        onFlush(key, items.map(i => i.args))
+            .then((results) => {
+            for (const [index, result] of results.entries()) {
+                const { resolve } = items[index];
+                resolve(result);
+            }
+        })
+            .catch((error) => {
+            for (const { reject } of items) {
+                reject(error);
+            }
+        });
+    }
+    return { enqueue, flush };
+}

package/dist/base/core/src/utils/compact.d.ts

@@ -0,0 +1,9 @@
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+/**
+ * Filters out falsy values (`false`, `''`, `0`, `null`, `undefined`) from an array.
+ * @template T - The type of the elements in the array.
+ * @param array - The array to filter.
+ * @returns A new array containing only the truthy values from the input array.
+ */
+export default function compact<T>(array: T[]): Truthy<T>[];
+export {};

package/dist/base/core/src/utils/compact.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = compact;
+/**
+ * Checks if a value is truthy.
+ * @template T - The type of the value.
+ * @param value - The value to check.
+ * @returns A boolean indicating if the value is truthy.
+ */
+function truthy(value) {
+    return !!value;
+}
+/**
+ * Filters out falsy values (`false`, `''`, `0`, `null`, `undefined`) from an array.
+ * @template T - The type of the elements in the array.
+ * @param array - The array to filter.
+ * @returns A new array containing only the truthy values from the input array.
+ */
+function compact(array) {
+    return array.filter(truthy);
+}

package/dist/base/core/src/utils/createSignal.d.ts

@@ -0,0 +1,14 @@
+import type ReactivityAdapter from '../types/ReactivityAdapter';
+import type Signal from '../types/Signal';
+/**
+ * Creates a reactive signal for managing state and triggering dependencies.
+ * The signal holds a value and provides methods to get and set the value,
+ * with optional equality checks and dependency tracking.
+ * @template T - The type of the value held by the signal.
+ * @param reactivityAdapter - An optional reactivity adapter for managing dependencies.
+ * @param initialValue - The initial value of the signal.
+ * @param isEqual - A custom equality function to determine if the new value is different
+ *   from the current value (default is `Object.is`).
+ * @returns A signal object with `get` and `set` methods to manage the value.
+ */
+export default function createSignal<T>(reactivityAdapter: ReactivityAdapter | undefined, initialValue: T, isEqual?: (a: T, b: T) => boolean): Signal<T>;

package/dist/base/core/src/utils/createSignal.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createSignal;
+/**
+ * Creates a reactive signal for managing state and triggering dependencies.
+ * The signal holds a value and provides methods to get and set the value,
+ * with optional equality checks and dependency tracking.
+ * @template T - The type of the value held by the signal.
+ * @param reactivityAdapter - An optional reactivity adapter for managing dependencies.
+ * @param initialValue - The initial value of the signal.
+ * @param isEqual - A custom equality function to determine if the new value is different
+ *   from the current value (default is `Object.is`).
+ * @returns A signal object with `get` and `set` methods to manage the value.
+ */
+function createSignal(reactivityAdapter, initialValue, isEqual = Object.is) {
+    let value = initialValue;
+    const dependency = reactivityAdapter?.create();
+    const isInReactiveScope = () => {
+        if (!reactivityAdapter?.isInScope)
+            return true;
+        return reactivityAdapter.isInScope();
+    };
+    const signal = {
+        get() {
+            if (dependency && isInReactiveScope())
+                dependency.depend();
+            return value;
+        },
+        set(newValue) {
+            if (isEqual(value, newValue))
+                return;
+            value = newValue;
+            if (dependency)
+                dependency.notify();
+        },
+    };
+    return signal;
+}

package/dist/base/core/src/utils/deepClone.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Performs a deep clone of a value, supporting various types including arrays, objects,
+ * Maps, Sets, Dates, and RegExps. Functions are not supported and will throw an error.
+ * @template T - The type of the value to clone.
+ * @param value - The value to deep clone.
+ * @returns A deep copy of the provided value.
+ * @throws {Error} An error if the value is a function, as cloning functions is not supported.
+ */
+export declare function clone<T>(value: T): T;
+/**
+ * Creates a deep clone of an object. Uses the `structuredClone` function if available,
+ * otherwise falls back to a manual deep clone implementation.
+ * @template T - The type of the object to clone.
+ * @param object - The object to deep clone.
+ * @returns A deep copy of the provided object.
+ */
+export default function deepClone<T>(object: T): T;

package/dist/base/core/src/utils/deepClone.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = clone;
+exports.default = deepClone;
+/**
+ * Performs a deep clone of a value, supporting various types including arrays, objects,
+ * Maps, Sets, Dates, and RegExps. Functions are not supported and will throw an error.
+ * @template T - The type of the value to clone.
+ * @param value - The value to deep clone.
+ * @returns A deep copy of the provided value.
+ * @throws {Error} An error if the value is a function, as cloning functions is not supported.
+ */
+function clone(value) {
+    // Functions
+    if (typeof value === 'function')
+        throw new Error('Cloning functions is not supported');
+    // Check for null or primitive types (string, number, boolean, etc.)
+    if (value === null || typeof value !== 'object')
+        return value;
+    // Dates
+    if (value instanceof Date)
+        return new Date(value);
+    // Arrays
+    if (Array.isArray(value))
+        return value.map(item => clone(item));
+    // Maps
+    if (value instanceof Map) {
+        const result = new Map();
+        value.forEach((currentValue, key) => {
+            result.set(key, clone(currentValue));
+        });
+        return result;
+    }
+    // Sets
+    if (value instanceof Set) {
+        const result = new Set();
+        value.forEach((currentValue) => {
+            result.add(clone(currentValue));
+        });
+        return result;
+    }
+    // RegExp
+    if (value instanceof RegExp)
+        return new RegExp(value);
+    // plain objects
+    const result = {};
+    for (const key in value) {
+        if (Object.hasOwnProperty.call(value, key)) {
+            result[key] = clone(value[key]);
+        }
+    }
+    return result;
+}
+/**
+ * Creates a deep clone of an object. Uses the `structuredClone` function if available,
+ * otherwise falls back to a manual deep clone implementation.
+ * @template T - The type of the object to clone.
+ * @param object - The object to deep clone.
+ * @returns A deep copy of the provided object.
+ */
+function deepClone(object) {
+    // If structuredClone is available, use it
+    if (typeof structuredClone === 'function')
+        return structuredClone(object);
+    // Otherwise, perform a manual deep clone
+    /* istanbul ignore next -- @preserve */
+    return clone(object);
+}

package/dist/base/core/src/utils/get.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Retrieves the value at a specified path within an object.
+ * Supports dot and bracket notation for navigating nested properties.
+ * @template T - The type of the object to retrieve the value from.
+ * @param value - The object to navigate.
+ * @param path - The path (dot or bracket notation) to the desired value.
+ * @returns The value at the specified path, or `undefined` if the path does not exist.
+ */
+export default function get<T extends Record<string, any>>(value: T, path: string): any;

package/dist/base/core/src/utils/get.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = get;
+/**
+ * Retrieves the value at a specified path within an object.
+ * Supports dot and bracket notation for navigating nested properties.
+ * @template T - The type of the object to retrieve the value from.
+ * @param value - The object to navigate.
+ * @param path - The path (dot or bracket notation) to the desired value.
+ * @returns The value at the specified path, or `undefined` if the path does not exist.
+ */
+function get(value, path) {
+    const normalized = path.replaceAll(/\[(\w+)\]/g, '.$1');
+    if (normalized.includes('..') || normalized.startsWith('.') || normalized.endsWith('.')) {
+        return;
+    }
+    const segments = normalized.split('.');
+    let current = value;
+    for (const key of segments) {
+        if (current == null)
+            return;
+        current = current[key];
+    }
+    if (current === undefined)
+        return;
+    return current;
+}

package/dist/base/core/src/utils/getMatchingKeys.d.ts

@@ -0,0 +1,19 @@
+import type { BaseItem } from '../Collection/types';
+import type { FlatSelector } from '../types/Selector';
+type KeyResult = {
+    include: (string | null)[] | null;
+    exclude: (string | null)[] | null;
+};
+/**
+ * Extracts the matching and excluded keys for a given field in a selector.
+ * Supports serialized values and `$in`/`$nin` field expressions for optimization.
+ * Returns `null` for include/exclude if the field cannot be optimized.
+ * @template T - The type of the items in the selector.
+ * @template I - The type of the unique identifier for the items.
+ * @param field - The name of the field to extract matching keys for.
+ * @param selector - The selector object containing query criteria.
+ * @returns An object containing arrays of serialized included and excluded keys,
+ *   or `null` if the field cannot be optimized.
+ */
+export default function getMatchingKeys<T extends BaseItem<I> = BaseItem, I = any>(field: string, selector: FlatSelector<T>): KeyResult;
+export {};

package/dist/base/core/src/utils/getMatchingKeys.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getMatchingKeys;
+const isFieldExpression_1 = __importDefault(require("./isFieldExpression"));
+const serializeValue_1 = __importDefault(require("./serializeValue"));
+/**
+ * Extracts the matching and excluded keys for a given field in a selector.
+ * Supports serialized values and `$in`/`$nin` field expressions for optimization.
+ * Returns `null` for include/exclude if the field cannot be optimized.
+ * @template T - The type of the items in the selector.
+ * @template I - The type of the unique identifier for the items.
+ * @param field - The name of the field to extract matching keys for.
+ * @param selector - The selector object containing query criteria.
+ * @returns An object containing arrays of serialized included and excluded keys,
+ *   or `null` if the field cannot be optimized.
+ */
+function getMatchingKeys(field, selector) {
+    const result = { include: null, exclude: null };
+    const fieldSelector = selector[field];
+    if (fieldSelector instanceof RegExp)
+        return result;
+    if (fieldSelector == null)
+        return result;
+    if ((0, isFieldExpression_1.default)(fieldSelector)) {
+        // Handle $ne operator
+        if (fieldSelector.$ne != null) {
+            result.exclude = [(0, serializeValue_1.default)(fieldSelector.$ne)];
+            return result;
+        }
+        // Handle $in operator
+        if (Array.isArray(fieldSelector.$in) && fieldSelector.$in.length > 0) {
+            result.include = fieldSelector.$in.map(serializeValue_1.default);
+            return result;
+        }
+        // Handle $nin operator
+        if (Array.isArray(fieldSelector.$nin) && fieldSelector.$nin.length > 0) {
+            result.exclude = fieldSelector.$nin.map(serializeValue_1.default);
+            return result;
+        }
+        // If there are other operators, we can't optimize
+        return { include: null, exclude: null };
+    }
+    // Direct value match
+    result.include = [(0, serializeValue_1.default)(fieldSelector)];
+    return result;
+}

package/dist/base/core/src/utils/idIndexQuery.d.ts

@@ -0,0 +1,20 @@
+import type { BaseItem } from '../Collection/types';
+import type { IndexResult } from '../types/IndexProvider';
+import type { FlatSelector } from '../types/Selector';
+/**
+ * Resolves a selector on `id` into the ids it names, without consulting an index.
+ *
+ * `id` is the one field every storage adapter can look up directly — that is what
+ * `readIds` is — so a query on it never needs an index to be declared and never
+ * needs the whole collection to be read. This behaves like an index provider that
+ * happens to need no stored index, because the ids are already in the selector.
+ *
+ * Only inclusive forms can be answered this way. `$ne`/`$nin` describe everything
+ * except* something, which cannot be enumerated without knowing every id, so they
+ * report no match and take the ordinary path.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param selector - The flat selector to resolve.
+ * @returns An index result naming the matched ids, or `{ matched: false }`.
+ */
+export default function idIndexQuery<T extends BaseItem<I> = BaseItem, I = any>(selector: FlatSelector<T>): IndexResult<I>;

package/dist/base/core/src/utils/idIndexQuery.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = idIndexQuery;
+const isFieldExpression_1 = __importDefault(require("./isFieldExpression"));
+/**
+ * Resolves a selector on `id` into the ids it names, without consulting an index.
+ *
+ * `id` is the one field every storage adapter can look up directly — that is what
+ * `readIds` is — so a query on it never needs an index to be declared and never
+ * needs the whole collection to be read. This behaves like an index provider that
+ * happens to need no stored index, because the ids are already in the selector.
+ *
+ * Only inclusive forms can be answered this way. `$ne`/`$nin` describe everything
+ * except* something, which cannot be enumerated without knowing every id, so they
+ * report no match and take the ordinary path.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param selector - The flat selector to resolve.
+ * @returns An index result naming the matched ids, or `{ matched: false }`.
+ */
+function idIndexQuery(selector) {
+    if (selector == null || !Object.hasOwnProperty.call(selector, 'id'))
+        return { matched: false };
+    const fieldSelector = selector.id;
+    if (fieldSelector == null || fieldSelector instanceof RegExp)
+        return { matched: false };
+    if ((0, isFieldExpression_1.default)(fieldSelector)) {
+        const values = fieldSelector.$in;
+        if (!Array.isArray(values) || values.length <= 0)
+            return { matched: false };
+        return {
+            matched: true,
+            ids: values,
+            fields: ['id'],
+            keepSelector: false,
+        };
+    }
+    if (typeof fieldSelector === 'object')
+        return { matched: false };
+    return {
+        matched: true,
+        ids: [fieldSelector],
+        fields: ['id'],
+        keepSelector: false,
+    };
+}