@signaldb/svelte 1.1.1 → 2.0.0-beta.10

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

@@ -0,0 +1,7 @@
+import type { BaseItem } from './Collection/types';
+/**
+ * creates an index for a specific field
+ * @param field name of the field
+ * @returns an index provider to pass to the `indices` option of the collection constructor
+ */
+export default function createIndex<T extends BaseItem<I> = BaseItem, I = any>(field: string): import("./types/IndexProvider").default<T, I>;

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

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createIndex;
+const createIndexProvider_1 = __importDefault(require("./createIndexProvider"));
+const get_1 = __importDefault(require("./utils/get"));
+const getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
+const serializeValue_1 = __importDefault(require("./utils/serializeValue"));
+/**
+ * creates an index for a specific field
+ * @param field name of the field
+ * @returns an index provider to pass to the `indices` option of the collection constructor
+ */
+function createIndex(field) {
+    const index = new Map();
+    const ensureSet = (key) => {
+        let set = index.get(key);
+        if (!set) {
+            set = new Set();
+            index.set(key, set);
+        }
+        return set;
+    };
+    return (0, createIndexProvider_1.default)({
+        query(selector) {
+            if (!Object.hasOwnProperty.call(selector, field)) {
+                // If the field is not present in the selector, we can't optimize
+                return { matched: false };
+            }
+            const fieldSelector = selector[field];
+            const filteresForNull = fieldSelector == null || fieldSelector.$exists === false;
+            const keys = filteresForNull
+                ? { include: null, exclude: [...index.keys()].filter(key => key != null) }
+                : (0, getMatchingKeys_1.default)(field, selector);
+            if (keys.include == null && keys.exclude == null)
+                return { matched: false };
+            // Accumulate included positions
+            let includedIds = [];
+            if (keys.include == null) {
+                for (const set of index.values()) {
+                    for (const pos of set) {
+                        includedIds.push(pos);
+                    }
+                }
+            }
+            else {
+                for (const key of keys.include) {
+                    const posSet = index.get(key);
+                    if (posSet) {
+                        for (const pos of posSet) {
+                            includedIds.push(pos);
+                        }
+                    }
+                }
+            }
+            // If exclusion is specified, build a single set of all positions to exclude.
+            if (keys.exclude != null) {
+                const excludeIds = new Set();
+                for (const key of keys.exclude) {
+                    const posSet = index.get(key);
+                    if (posSet) {
+                        for (const pos of posSet) {
+                            excludeIds.add(pos);
+                        }
+                    }
+                }
+                // Filter out any position that exists in the exclude set.
+                includedIds = includedIds.filter(pos => !excludeIds.has(pos));
+            }
+            return {
+                matched: true,
+                ids: includedIds,
+                fields: [field],
+                keepSelector: filteresForNull,
+            };
+        },
+        rebuild(items) {
+            index.clear();
+            items.forEach((item) => {
+                const value = (0, serializeValue_1.default)((0, get_1.default)(item, field));
+                ensureSet(value).add(item.id);
+            });
+        },
+        // NEW: delta methods
+        insert(items) {
+            for (const item of items) {
+                const value = (0, serializeValue_1.default)((0, get_1.default)(item, field));
+                ensureSet(value).add(item.id);
+            }
+        },
+        remove(items) {
+            for (const item of items) {
+                const value = (0, serializeValue_1.default)((0, get_1.default)(item, field));
+                const set = index.get(value);
+                if (!set)
+                    continue;
+                set.delete(item.id);
+                if (set.size === 0)
+                    index.delete(value);
+            }
+        },
+        update(pairs) {
+            for (const { oldItem, newItem } of pairs) {
+                const oldValue = (0, serializeValue_1.default)((0, get_1.default)(oldItem, field));
+                const newValue = (0, serializeValue_1.default)((0, get_1.default)(newItem, field));
+                if (oldValue === newValue)
+                    continue;
+                const oldSet = index.get(oldValue);
+                if (oldSet) {
+                    oldSet.delete(oldItem.id);
+                    if (oldSet.size === 0)
+                        index.delete(oldValue);
+                }
+                ensureSet(newValue).add(newItem.id);
+            }
+        },
+    });
+}

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

@@ -0,0 +1,8 @@
+import type { BaseItem } from './Collection';
+import type IndexProvider from './types/IndexProvider';
+/**
+ * Creates an IndexProvider based on the given definition.
+ * @param definition - The definition of the IndexProvider.
+ * @returns The created IndexProvider.
+ */
+export default function createIndexProvider<T extends BaseItem<I> = BaseItem, I = any>(definition: IndexProvider<T, I>): IndexProvider<T, I>;

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

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

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

@@ -0,0 +1,8 @@
+import type Dependency from './types/Dependency';
+import type ReactivityAdapter from './types/ReactivityAdapter';
+/**
+ * Creates an ReactivityAdapter based on the given definition.
+ * @param definition - The definition of the ReactivityAdapter.
+ * @returns The created ReactivityAdapter.
+ */
+export default function createReactivityAdapter<T extends Dependency = Dependency>(definition: ReactivityAdapter<T>): ReactivityAdapter<T>;

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

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

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

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

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

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

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,176 @@
+"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;
+            const process$or = ($orNew) => {
+                if (hasNonIndexField || ($orNew && $orNew.length > 0)) {
+                    newSelector.$or = $or;
+                    matched = matchedBefore;
+                    ids = idsBefore;
+                }
+                return {
+                    matched,
+                    ids: ids || [],
+                    optimizedSelector: newSelector,
+                };
+            };
+            const $orNewOrPromise = Array.isArray($or)
+                ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
+                    if (match) {
+                        ids = [...new Set([...ids, ...selIds])];
+                        matched = 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,22 @@
+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, } from './Collection';
+export type { default as DataAdapter } from './DataAdapter';
+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 { 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 });