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

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;
+}

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

@@ -0,0 +1,39 @@
+import type { AsynchronousQueryFunction, SynchronousQueryFunction } from './types/IndexProvider';
+import type { FlatSelector } from './types/Selector';
+import type Selector from './types/Selector';
+import type { BaseItem } from './Collection/types';
+type IndexInfo<T extends BaseItem<I> = BaseItem, I = any> = {
+    matched: boolean;
+    ids: I[];
+    optimizedSelector: FlatSelector<T>;
+};
+/**
+ * Retrieves merged index information for a given flat selector by querying multiple
+ * index providers. Combines results from all index providers to determine matched ids
+ * and an optimized selector.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param queryFunctions - An array of index providers to query.
+ * @param selector - The flat selector used to filter items.
+ * @returns An object containing:
+ *   - `matched`: A boolean indicating if the selector matched any items.
+ *   - `ids`: An array of matched item ids.
+ *   - `optimizedSelector`: A flat selector optimized based on the index results.
+ */
+export declare function getMergedIndexInfo<T extends BaseItem<I> = BaseItem, I = any>(queryFunctions: (SynchronousQueryFunction<T, I> | AsynchronousQueryFunction<T, I>)[], selector: FlatSelector<T>): IndexInfo<T, I> | Promise<IndexInfo<T, I>>;
+/**
+ * Retrieves index information for a given complex selector by querying multiple
+ * index providers. Handles nested `$and` and `$or` conditions in the selector and
+ * optimizes the selector to minimize processing overhead.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param queryFunctions - An array of index providers to query.
+ * @param selector - The complex selector used to filter items.
+ * @returns An object containing:
+ *   - `matched`: A boolean indicating if the selector matched any items.
+ *   - `ids`: An array of matched item ids.
+ *   - `optimizedSelector`: A selector optimized based on the index results, with unused
+ *     conditions removed.
+ */
+export default function getIndexInfo<QueryFunction extends SynchronousQueryFunction<T, I> | AsynchronousQueryFunction<T, I>, T extends BaseItem<I> = BaseItem, I = any>(queryFunctions: QueryFunction[], selector: Selector<T>): QueryFunction extends AsynchronousQueryFunction<T, I> ? Promise<IndexInfo<T, I>> : IndexInfo<T, I>;
+export {};

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

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMergedIndexInfo = getMergedIndexInfo;
+exports.default = getIndexInfo;
+const intersection_1 = __importDefault(require("./utils/intersection"));
+/**
+ * Retrieves merged index information for a given flat selector by querying multiple
+ * index providers. Combines results from all index providers to determine matched ids
+ * and an optimized selector.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param queryFunctions - An array of index providers to query.
+ * @param selector - The flat selector used to filter items.
+ * @returns An object containing:
+ *   - `matched`: A boolean indicating if the selector matched any items.
+ *   - `ids`: An array of matched item ids.
+ *   - `optimizedSelector`: A flat selector optimized based on the index results.
+ */
+function getMergedIndexInfo(queryFunctions, selector) {
+    return queryFunctions.reduce((memoOrPromise, queryFunction) => {
+        const resultOrPromise = queryFunction(selector);
+        const processResult = (memo, result) => {
+            if (!result.matched)
+                return memo;
+            const optimizedSelector = result.keepSelector
+                ? memo.optimizedSelector
+                : Object.fromEntries(Object.entries(memo.optimizedSelector)
+                    .filter(([key]) => !result.fields.includes(key)));
+            return {
+                matched: true,
+                ids: [...new Set(memo.matched
+                        ? (0, intersection_1.default)(memo.ids, result.ids)
+                        : result.ids)],
+                optimizedSelector,
+            };
+        };
+        if (resultOrPromise instanceof Promise) {
+            return resultOrPromise.then(async (result) => {
+                const memo = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+                return processResult(memo, result);
+            });
+        }
+        const memo = memoOrPromise;
+        if (memo instanceof Promise)
+            throw new Error('Mixing async and sync index providers is not supported');
+        return processResult(memo, resultOrPromise);
+    }, {
+        matched: false,
+        ids: [],
+        optimizedSelector: { ...selector },
+    });
+}
+/**
+ * Optimizes a logic gate ($and/$or) of selectors by querying multiple index providers.
+ * @param queryFunctions - An array of index providers to query.
+ * @param logicGate - An array of selectors representing the logic gate.
+ * @param idsCallback - A callback function called with matched ids.
+ * @returns An array of optimized selectors or a promise that resolves to such an array.
+ */
+function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
+    return logicGate.reduce((memoOrPromise, sel) => {
+        const getSelector = (indexInfo) => {
+            const { matched: selMatched, ids: selIds, optimizedSelector, } = indexInfo;
+            if (selMatched) {
+                idsCallback(true, selIds);
+                if (Object.keys(optimizedSelector).length > 0) {
+                    return optimizedSelector;
+                }
+            }
+            else {
+                idsCallback(false, []);
+                return sel;
+            }
+        };
+        const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
+        if (indexInfoOrPromise instanceof Promise) {
+            return indexInfoOrPromise.then(async (indexInfo) => {
+                const memo = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
+                const optimizedSelector = getSelector(indexInfo);
+                if (optimizedSelector)
+                    memo.push(optimizedSelector);
+                return memo;
+            });
+        }
+        const memo = memoOrPromise;
+        if (memo instanceof Promise)
+            throw new Error('Mixing async and sync index providers is not supported');
+        const optimizedSelector = getSelector(indexInfoOrPromise);
+        if (optimizedSelector)
+            memo.push(optimizedSelector);
+        return memo;
+    }, []);
+}
+/**
+ * Retrieves index information for a given complex selector by querying multiple
+ * index providers. Handles nested `$and` and `$or` conditions in the selector and
+ * optimizes the selector to minimize processing overhead.
+ * @template T - The type of the items in the collection.
+ * @template I - The type of the unique identifier for the items.
+ * @param queryFunctions - An array of index providers to query.
+ * @param selector - The complex selector used to filter items.
+ * @returns An object containing:
+ *   - `matched`: A boolean indicating if the selector matched any items.
+ *   - `ids`: An array of matched item ids.
+ *   - `optimizedSelector`: A selector optimized based on the index results, with unused
+ *     conditions removed.
+ */
+function getIndexInfo(queryFunctions, selector) {
+    if (selector == null || Object.keys(selector).length <= 0) {
+        return {
+            matched: false,
+            ids: [],
+            optimizedSelector: selector,
+        };
+    }
+    const { $and, $or, ...rest } = selector;
+    const flatInfoOrPromise = getMergedIndexInfo(queryFunctions, rest);
+    const processFlatInfo = (flatInfo) => {
+        let { matched, ids } = flatInfo;
+        const newSelector = flatInfo.optimizedSelector;
+        const $andNewOrPromise = Array.isArray($and)
+            ? optimizeLogicGate(queryFunctions, $and, (match, selIds) => {
+                if (!match)
+                    return;
+                ids = matched ? (0, intersection_1.default)(ids, selIds) : selIds;
+                matched = true;
+            })
+            : undefined;
+        const process$and = ($andNew) => {
+            if ($andNew && $andNew.length > 0)
+                newSelector.$and = $andNew;
+            let hasNonIndexField = false;
+            const matchedBefore = matched;
+            const idsBefore = ids;
+            // The branches of an $or union with each other, but the $or as a whole
+            // *intersects* with what the flat fields and $and already narrowed down
+            // to. Collecting the branches separately is what keeps those two apart —
+            // folding them into `ids` turns `{ a: 1, $or: [...] }` into a union and
+            // returns items matching neither half of the selector, with an empty
+            // optimized selector that leaves nothing to filter them out again.
+            let orIds = [];
+            let orMatched = false;
+            const process$or = ($orNew) => {
+                if (hasNonIndexField || ($orNew && $orNew.length > 0)) {
+                    newSelector.$or = $or;
+                    matched = matchedBefore;
+                    ids = idsBefore;
+                }
+                else if (orMatched) {
+                    ids = matchedBefore ? (0, intersection_1.default)(idsBefore, orIds) : orIds;
+                    matched = true;
+                }
+                return {
+                    matched,
+                    ids: ids || [],
+                    optimizedSelector: newSelector,
+                };
+            };
+            const $orNewOrPromise = Array.isArray($or)
+                ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
+                    if (match) {
+                        orIds = [...new Set([...orIds, ...selIds])];
+                        orMatched = true;
+                    }
+                    else {
+                        hasNonIndexField = true;
+                    }
+                })
+                : undefined;
+            if ($orNewOrPromise instanceof Promise) {
+                return $orNewOrPromise.then($orNew => process$or($orNew));
+            }
+            return process$or($orNewOrPromise);
+        };
+        if ($andNewOrPromise instanceof Promise) {
+            return $andNewOrPromise.then($andNew => process$and($andNew));
+        }
+        return process$and($andNewOrPromise);
+    };
+    if (flatInfoOrPromise instanceof Promise) {
+        return flatInfoOrPromise
+            .then(processFlatInfo);
+    }
+    return processFlatInfo(flatInfoOrPromise);
+}

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

@@ -0,0 +1,26 @@
+export type { default as ReactivityAdapter } from './types/ReactivityAdapter';
+export type { default as StorageAdapter, Changeset, } from './types/StorageAdapter';
+export type { default as Selector } from './types/Selector';
+export type { default as Modifier } from './types/Modifier';
+export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, CollectionOptions, QueryStateAccessor, } from './Collection';
+export type { default as DataAdapter } from './DataAdapter';
+export type { CollectionBackend, QueryOptions, StateChangeCallback, } from './DataAdapter';
+export type { QueryDelta } from './utils/queryDelta';
+export { default as Cursor } from './Collection/Cursor';
+export { default as Collection } from './Collection';
+export { default as createStorageAdapter } from './createStorageAdapter';
+export { default as createReactivityAdapter } from './createReactivityAdapter';
+export { default as isEqual } from './utils/isEqual';
+export { default as modify } from './utils/modify';
+export { default as randomId } from './utils/randomId';
+export { default as EventEmitter } from './utils/EventEmitter';
+export { default as get } from './utils/get';
+export { default as serializeValue } from './utils/serializeValue';
+export { default as reactiveOrAsync, unwrap } from './utils/reactiveOrAsync';
+export { default as DefaultDataAdapter } from './DefaultDataAdapter';
+export { default as AsyncDataAdapter } from './AsyncDataAdapter';
+export { default as WorkerDataAdapter } from './WorkerDataAdapter';
+export { default as WorkerDataAdapterHost } from './WorkerDataAdapterHost';
+export type { WorkerDataAdapterEndpoint } from './WorkerDataAdapter';
+export type { WorkerDataAdapterHostEndpoint } from './WorkerDataAdapterHost';
+export { default as AutoFetchDataAdapter } from './AutoFetchDataAdapter';

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoFetchDataAdapter = exports.WorkerDataAdapterHost = exports.WorkerDataAdapter = exports.AsyncDataAdapter = exports.DefaultDataAdapter = exports.unwrap = exports.reactiveOrAsync = exports.serializeValue = exports.get = exports.EventEmitter = exports.randomId = exports.modify = exports.isEqual = exports.createReactivityAdapter = exports.createStorageAdapter = exports.Collection = exports.Cursor = void 0;
+var Cursor_1 = require("./Collection/Cursor");
+Object.defineProperty(exports, "Cursor", { enumerable: true, get: function () { return __importDefault(Cursor_1).default; } });
+var Collection_1 = require("./Collection");
+Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return __importDefault(Collection_1).default; } });
+var createStorageAdapter_1 = require("./createStorageAdapter");
+Object.defineProperty(exports, "createStorageAdapter", { enumerable: true, get: function () { return __importDefault(createStorageAdapter_1).default; } });
+var createReactivityAdapter_1 = require("./createReactivityAdapter");
+Object.defineProperty(exports, "createReactivityAdapter", { enumerable: true, get: function () { return __importDefault(createReactivityAdapter_1).default; } });
+var isEqual_1 = require("./utils/isEqual");
+Object.defineProperty(exports, "isEqual", { enumerable: true, get: function () { return __importDefault(isEqual_1).default; } });
+var modify_1 = require("./utils/modify");
+Object.defineProperty(exports, "modify", { enumerable: true, get: function () { return __importDefault(modify_1).default; } });
+var randomId_1 = require("./utils/randomId");
+Object.defineProperty(exports, "randomId", { enumerable: true, get: function () { return __importDefault(randomId_1).default; } });
+var EventEmitter_1 = require("./utils/EventEmitter");
+Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return __importDefault(EventEmitter_1).default; } });
+var get_1 = require("./utils/get");
+Object.defineProperty(exports, "get", { enumerable: true, get: function () { return __importDefault(get_1).default; } });
+var serializeValue_1 = require("./utils/serializeValue");
+Object.defineProperty(exports, "serializeValue", { enumerable: true, get: function () { return __importDefault(serializeValue_1).default; } });
+var reactiveOrAsync_1 = require("./utils/reactiveOrAsync");
+Object.defineProperty(exports, "reactiveOrAsync", { enumerable: true, get: function () { return __importDefault(reactiveOrAsync_1).default; } });
+Object.defineProperty(exports, "unwrap", { enumerable: true, get: function () { return reactiveOrAsync_1.unwrap; } });
+var DefaultDataAdapter_1 = require("./DefaultDataAdapter");
+Object.defineProperty(exports, "DefaultDataAdapter", { enumerable: true, get: function () { return __importDefault(DefaultDataAdapter_1).default; } });
+var AsyncDataAdapter_1 = require("./AsyncDataAdapter");
+Object.defineProperty(exports, "AsyncDataAdapter", { enumerable: true, get: function () { return __importDefault(AsyncDataAdapter_1).default; } });
+var WorkerDataAdapter_1 = require("./WorkerDataAdapter");
+Object.defineProperty(exports, "WorkerDataAdapter", { enumerable: true, get: function () { return __importDefault(WorkerDataAdapter_1).default; } });
+var WorkerDataAdapterHost_1 = require("./WorkerDataAdapterHost");
+Object.defineProperty(exports, "WorkerDataAdapterHost", { enumerable: true, get: function () { return __importDefault(WorkerDataAdapterHost_1).default; } });
+var AutoFetchDataAdapter_1 = require("./AutoFetchDataAdapter");
+Object.defineProperty(exports, "AutoFetchDataAdapter", { enumerable: true, get: function () { return __importDefault(AutoFetchDataAdapter_1).default; } });

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

@@ -0,0 +1,4 @@
+export default interface Dependency {
+    depend(): void;
+    notify(): void;
+}

package/dist/base/core/src/types/Dependency.js

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

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

@@ -0,0 +1,26 @@
+import type { BaseItem } from '../Collection';
+import type { FlatSelector } from './Selector';
+export type IndexResult<IdType> = {
+    ids: IdType[];
+    fields: string[];
+    keepSelector?: boolean;
+    matched: true;
+} | {
+    ids?: never;
+    fields?: never;
+    keepSelector?: never;
+    matched: false;
+};
+export type SynchronousQueryFunction<T extends BaseItem<I> = BaseItem, I = any> = (selector: FlatSelector<T>) => IndexResult<I>;
+export type AsynchronousQueryFunction<T extends BaseItem<I> = BaseItem, I = any> = (selector: FlatSelector<T>) => Promise<IndexResult<I>>;
+interface IndexProvider<T extends BaseItem<I> = BaseItem, I = any> {
+    query: SynchronousQueryFunction<T, I>;
+    rebuild(items: T[]): void;
+    insert(items: T[]): void;
+    remove(items: T[]): void;
+    update(pairs: {
+        oldItem: T;
+        newItem: T;
+    }[]): void;
+}
+export default IndexProvider;

package/dist/base/core/src/types/IndexProvider.js

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

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

@@ -0,0 +1,46 @@
+import type { DotNotation, GetType } from './Selector';
+type Dictionary<T> = Record<string, T>;
+type PartialMapTo<T, M> = Partial<Record<DotNotation<T>, M>> & Dictionary<M>;
+type OnlyElementsOfArrays<T> = T extends any[] ? Partial<T[0]> : never;
+type ElementsOf<T> = {
+    [P in DotNotation<T>]?: OnlyElementsOfArrays<GetType<T, P>>;
+};
+type PushModifier<T> = {
+    [P in DotNotation<T>]?: OnlyElementsOfArrays<GetType<T, P>> | {
+        $each?: GetType<T, P> | undefined;
+        $position?: number | undefined;
+        $slice?: number | undefined;
+        $sort?: 1 | -1 | Dictionary<number> | undefined;
+    };
+};
+type ArraysOrEach<T> = {
+    [P in DotNotation<T>]?: OnlyElementsOfArrays<GetType<T, P>> | {
+        $each: GetType<T, P>;
+    };
+};
+type CurrentDateModifier = {
+    $type: 'timestamp' | 'date';
+} | true;
+type Modifier<T extends Dictionary<any> = Dictionary<any>> = {
+    $currentDate?: (Partial<Record<DotNotation<T>, CurrentDateModifier>> & Dictionary<CurrentDateModifier>) | undefined;
+    $inc?: (PartialMapTo<T, number> & Dictionary<number>) | undefined;
+    $min?: (PartialMapTo<T, Date | number> & Dictionary<Date | number>) | undefined;
+    $max?: (PartialMapTo<T, Date | number> & Dictionary<Date | number>) | undefined;
+    $mul?: (PartialMapTo<T, number> & Dictionary<number>) | undefined;
+    $rename?: (PartialMapTo<T, string> & Dictionary<string>) | undefined;
+    $set?: ({
+        [P in DotNotation<T>]?: GetType<T, P>;
+    } & Dictionary<any>) | undefined;
+    $setOnInsert?: ({
+        [P in DotNotation<T>]?: GetType<T, P>;
+    } & Dictionary<any>) | undefined;
+    $unset?: (PartialMapTo<T, string | boolean | 1 | 0> & Dictionary<any>) | undefined;
+    $addToSet?: (ArraysOrEach<T> & Dictionary<any>) | undefined;
+    $push?: (PushModifier<T> & Dictionary<any>) | undefined;
+    $pull?: (ElementsOf<T> & Dictionary<any>) | undefined;
+    $pullAll?: ({
+        [P in DotNotation<T>]?: GetType<T, P>;
+    } & Dictionary<any>) | undefined;
+    $pop?: (PartialMapTo<T, 1 | -1> & Dictionary<1 | -1>) | undefined;
+};
+export default Modifier;

package/dist/base/core/src/types/Modifier.js

@@ -0,0 +1,3 @@
+"use strict";
+// borrowed from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/meteor/mongo.d.ts
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,6 @@
+import type Dependency from './Dependency';
+export default interface ReactivityAdapter<T extends Dependency = Dependency> {
+    create(): T;
+    onDispose?(callback: () => void, Dependency: T): void;
+    isInScope?(): boolean;
+}

package/dist/base/core/src/types/ReactivityAdapter.js

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

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

@@ -0,0 +1,46 @@
+export interface FieldExpression<T> {
+    $eq?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[] | undefined;
+    $nin?: T[];
+    $ne?: T;
+    $exists?: boolean;
+    $not?: FieldExpression<T>;
+    $expr?: FieldExpression<T>;
+    $jsonSchema?: any;
+    $mod?: number[];
+    $regex?: RegExp | string;
+    $options?: string;
+    $where?: string | ((this: T) => boolean);
+    $all?: T[];
+    $elemMatch?: T extends object ? Query<T> : FieldExpression<T>;
+    $size?: number;
+    $bitsAllClear?: any;
+    $bitsAllSet?: any;
+    $bitsAnyClear?: any;
+    $bitsAnySet?: any;
+}
+export type DotNotation<T> = {
+    [K in keyof T & string]: T[K] extends Array<infer U> ? `${K}` | `${K}.$` | `${K}.${DotNotation<U>}` : T[K] extends object ? `${K}` | `${K}.${DotNotation<T[K]>}` : `${K}`;
+}[keyof T & string];
+export type GetType<T, P extends string> = P extends `${infer H}.${infer R}` ? H extends keyof T ? T[H] extends Array<infer U> ? GetType<U, R> : GetType<T[H], R> : H extends '$' ? T extends Array<infer U> ? GetType<U, R> : never : never : P extends keyof T ? T[P] : never;
+type FlatQuery<T> = {
+    [P in DotNotation<T>]?: FlatQueryValue<T, P>;
+};
+type FieldValue<U> = U extends string ? string | RegExp | FieldExpression<string> : U | FieldExpression<U>;
+type FlatQueryValue<T, P extends string> = GetType<T, P> extends never ? never : GetType<T, P> extends Array<infer U> ? FieldValue<U> | FieldValue<U[]> : FieldValue<GetType<T, P>>;
+type Query<T> = FlatQuery<T> & {
+    $or?: Query<T>[];
+    $and?: Query<T>[];
+    $nor?: Query<T>[];
+};
+export type FlatSelector<T extends Record<string, any>> = FlatQuery<T> & {
+    $or?: never;
+    $and?: never;
+    $nor?: never;
+};
+type Selector<T extends Record<string, any>> = Query<T>;
+export default Selector;

package/dist/base/core/src/types/Selector.js

@@ -0,0 +1,3 @@
+"use strict";
+// original from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/meteor/mongo.d.ts
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+export default interface Signal<T> {
+    get(): T;
+    set(value: T): void;
+}

package/dist/base/core/src/types/Signal.js

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

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

@@ -0,0 +1,28 @@
+export interface Changeset<T> {
+    added: T[];
+    modified: T[];
+    removed: T[];
+}
+export default interface StorageAdapter<T extends {
+    id: I;
+} & Record<string, any>, I> {
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    readAll(): Promise<T[]>;
+    readIds(positions: I[]): Promise<T[]>;
+    createIndex(field: string): Promise<void>;
+    dropIndex(field: string): Promise<void>;
+    /**
+     * The index, keyed by `serializeValue(value)` — not by the raw field value.
+     *
+     * SignalDB looks an index up with the serialized form, because that is what
+     * makes `3`, `'3'` and `new Date(...)` comparable as map keys at all. An
+     * adapter that stores its backend's own keys instead answers nothing for
+     * every non-string field, and everything for a `$ne` on one.
+     */
+    readIndex(field: string): Promise<Map<string | null, Set<I>>>;
+    insert(items: T[]): Promise<void>;
+    replace(items: T[]): Promise<void>;
+    remove(items: T[]): Promise<void>;
+    removeAll(): Promise<void>;
+}

package/dist/base/core/src/types/StorageAdapter.js

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

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

@@ -0,0 +1,71 @@
+/**
+ * A strongly‑typed EventEmitter.
+ */
+export default class EventEmitter<Events extends Record<string | symbol, any>> {
+    private _maxListeners;
+    /**
+     * We store a set of the listeners for each event.
+     */
+    private _listenerStore;
+    setMaxListeners(max: number): 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<K extends keyof Events>(eventName: K, listener: Events[K]): 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<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * 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<K extends keyof Events>(eventName: K, listener: Events[K]): 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).
+     */
+    off<K extends keyof Events>(eventName: K, listener: Events[K]): 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<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * 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<K extends keyof Events>(eventName: K, ...args: Parameters<Events[K]>): void;
+    /**
+     * 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<K extends keyof Events>(eventName: K): Array<(...args: Parameters<Events[K]>) => void>;
+    /**
+     * Returns the number of listeners for a given event.
+     * @param eventName The event name (key of E).
+     * @returns         The number of listeners.
+     */
+    listenerCount<K extends keyof Events>(eventName: K): number;
+    /**
+     * 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<K extends keyof Events>(eventName?: K): this;
+}