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

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/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/intersection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Computes the intersection of multiple arrays, returning an array of unique elements
+ * that are present in all the input arrays.
+ * @template T - The type of elements in the arrays.
+ * @param arrays - A variable number of arrays to compute the intersection of.
+ * @returns An array containing the unique elements found in all the input arrays.
+ *   - If no arrays are provided, returns an empty array.
+ */
+export default function intersection<T>(...arrays: T[][]): T[];

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = intersection;
+/**
+ * Computes the intersection of multiple arrays, returning an array of unique elements
+ * that are present in all the input arrays.
+ * @template T - The type of elements in the arrays.
+ * @param arrays - A variable number of arrays to compute the intersection of.
+ * @returns An array containing the unique elements found in all the input arrays.
+ *   - If no arrays are provided, returns an empty array.
+ */
+function intersection(...arrays) {
+    if (arrays.length === 0)
+        return [];
+    return [...new Set(arrays.reduce((a, b) => a.filter(c => b.includes(c))))];
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Compares two values for deep equality.
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns - Returns `true` if the two values are deeply equal, otherwise `false`.
+ * @example
+ * isEqual({ a: 1 }, { a: 1 }); // true
+ * isEqual([1, 2], [1, 2]);     // true
+ * isEqual(new Date(0), new Date(0)); // true
+ * isEqual(/abc/, /abc/);       // true
+ * isEqual({ a: 1 }, { a: 2 }); // false
+ * isEqual(null, null);         // true
+ */
+export default function isEqual<T, K>(a: T, b: K): boolean;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isEqual;
+/**
+ * Compares two values for deep equality.
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns - Returns `true` if the two values are deeply equal, otherwise `false`.
+ * @example
+ * isEqual({ a: 1 }, { a: 1 }); // true
+ * isEqual([1, 2], [1, 2]);     // true
+ * isEqual(new Date(0), new Date(0)); // true
+ * isEqual(/abc/, /abc/);       // true
+ * isEqual({ a: 1 }, { a: 2 }); // false
+ * isEqual(null, null);         // true
+ */
+function isEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (a instanceof RegExp && b instanceof RegExp)
+        return a.toString() === b.toString();
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (typeof a !== 'object')
+        return false;
+    if (typeof b !== 'object')
+        return false;
+    if (a === null)
+        return false;
+    if (b === null)
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!bKeys.includes(key))
+            return false;
+        if (!isEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,11 @@
+import type { FieldExpression } from '../types/Selector';
+/**
+ * Determines whether a given object is a valid field expression.
+ * A field expression is an object containing query operators supported by MongoDB-style queries.
+ * @template T - The type of the field expression.
+ * @param expression - The object to test.
+ * @returns A boolean indicating whether the object is a valid field expression.
+ *   - `true` if the object contains only recognized query operators.
+ *   - `false` otherwise.
+ */
+export default function isFieldExpression<T>(expression: any): expression is FieldExpression<T>;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isFieldExpression;
+const expressionKeys = new Set([
+    '$eq',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$in',
+    '$nin',
+    '$ne',
+    '$exists',
+    '$not',
+    '$expr',
+    '$jsonSchema',
+    '$mod',
+    '$regex',
+    '$options',
+    '$text',
+    '$where',
+    '$all',
+    '$elemMatch',
+    '$size',
+    '$bitsAllClear',
+    '$bitsAllSet',
+    '$bitsAnyClear',
+    '$bitsAnySet',
+]);
+/**
+ * Determines whether a given object is a valid field expression.
+ * A field expression is an object containing query operators supported by MongoDB-style queries.
+ * @template T - The type of the field expression.
+ * @param expression - The object to test.
+ * @returns A boolean indicating whether the object is a valid field expression.
+ *   - `true` if the object contains only recognized query operators.
+ *   - `false` otherwise.
+ */
+function isFieldExpression(expression) {
+    if (typeof expression !== 'object' || expression == null) {
+        return false;
+    }
+    const keys = Object.keys(expression);
+    if (keys.length === 0) {
+        return false;
+    }
+    const hasInvalidKeys = keys.some(key => !expressionKeys.has(key));
+    if (hasInvalidKeys)
+        return false;
+    const hasValidKeys = keys.every(key => expressionKeys.has(key));
+    return hasValidKeys;
+}