@signaldb/sync 2.0.0-beta.7 → 2.0.0-beta.9

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

@@ -1,46 +0,0 @@
-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/core/src/types/ReactivityAdapter.d.ts

@@ -1,6 +0,0 @@
-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/core/src/types/Selector.d.ts

@@ -1,46 +0,0 @@
-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/core/src/types/Signal.d.ts

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

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

@@ -1,20 +0,0 @@
-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>;
-    readIndex(field: string): Promise<Map<any, Set<I>>>;
-    insert(items: T[]): Promise<void>;
-    replace(items: T[]): Promise<void>;
-    remove(items: T[]): Promise<void>;
-    removeAll(): Promise<void>;
-}

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

@@ -1,71 +0,0 @@
-/**
- * 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;
-}

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

@@ -1,16 +0,0 @@
-/**
- * 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/core/src/utils/compact.d.ts

@@ -1,9 +0,0 @@
-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/core/src/utils/createSignal.d.ts

@@ -1,14 +0,0 @@
-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/core/src/utils/deepClone.d.ts

@@ -1,17 +0,0 @@
-/**
- * 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/core/src/utils/get.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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/core/src/utils/getMatchingKeys.d.ts

@@ -1,19 +0,0 @@
-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/core/src/utils/intersection.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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/core/src/utils/isEqual.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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/core/src/utils/isFieldExpression.d.ts

@@ -1,11 +0,0 @@
-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/core/src/utils/match.d.ts

@@ -1,12 +0,0 @@
-import type Selector from '../types/Selector';
-type BaseItem = Record<string, any>;
-/**
- * Tests whether a given item matches a specified selector.
- * Uses the `mingo` library to evaluate the query.
- * @template T - The type of the item being tested.
- * @param item - The item to test against the selector.
- * @param selector - The query selector used to match the item.
- * @returns A boolean indicating whether the item matches the selector.
- */
-export default function match<T extends BaseItem = BaseItem>(item: T, selector: Selector<T>): boolean;
-export {};

package/dist/core/src/utils/modify.d.ts

@@ -1,14 +0,0 @@
-import type Modifier from '../types/Modifier';
-/**
- * Applies a modifier to an object and returns a new modified object.
- * @template T - The type of the object to be modified.
- * @param item - The object to be modified.
- * @param modifier - The modifier to apply. This can be any transformation logic.
- * @returns - Returns a new object with the modifications applied.
- * @example
- * const item = { a: 1, b: 2 }
- * const modifier = { $set: { b: 3, c: 4 } }
- * const result = modify(item, modifier)
- * // result: { a: 1, b: 3, c: 4 }
- */
-export default function modify<T extends Record<string, any>>(item: T, modifier: Modifier): T;

package/dist/core/src/utils/project.d.ts

@@ -1,15 +0,0 @@
-/**
- * Projects the fields of an object based on a specified fields configuration.
- * Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
- * with the desired fields included or excluded, based on the configuration.
- * @template T - The type of the object being projected.
- * @param item - The original object to project fields from.
- * @param fields - An object defining the fields to include (`1`) or exclude (`0`).
- *   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
- * @returns A new object with the specified fields included or excluded.
- *   - If all fields are set to `0`, the excluded fields are removed from the result.
- *   - If fields are set to `1`, only the included fields are retained.
- */
-export default function project<T extends Record<string, any>>(item: T, fields: {
-    [P in keyof T]?: 0 | 1;
-} & Record<string, 0 | 1>): T;

package/dist/core/src/utils/queryId.d.ts

@@ -1,9 +0,0 @@
-import type { QueryOptions } from '../DataAdapter';
-import type Selector from '../types/Selector';
-/**
- * Generates a unique identifier for a query based on its selector and options.
- * @param selector - The selector object.
- * @param options - The query options object (optional).
- * @returns A unique identifier string for the query.
- */
-export default function queryId(selector: Selector<any>, options?: QueryOptions<any>): string;

package/dist/core/src/utils/randomId.d.ts

@@ -1,7 +0,0 @@
-/**
- * creates a random id
- * @returns a random string of 16 characters
- * @example
- * randomId() // '1234567890abcdef'
- */
-export default function randomId(): string;

package/dist/core/src/utils/reactiveOrAsync.d.ts

@@ -1,59 +0,0 @@
-export type MaybePromise<T> = T | Promise<T>;
-/**
- * Options that control execution mode (and potential future mode-specific behavior).
- * Keep this minimal; you can extend it later (e.g. signal, timeoutMs, debugLabel).
- */
-export type ModeOptions = {
-    async?: boolean;
-};
-/**
- * A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
- *
- * Usage:
- *   const doc = yield* unwrap(Collection.findOne(...))
- *   const list = yield* unwrap(Collection.find(...).fetch())
- *
- * Runtime note:
- *   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
- *   value that the runner feeds back via `.next(...)`.
- * @param value The value (or Promise of a value) to yield to the runner.
- * @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
- */
-export declare function unwrap<T>(value: MaybePromise<T>): Generator<MaybePromise<T>, T, T>;
-/**
- * Generator shape used by the factory.
- *
- * `TThis` is the type of `this` inside the generator.
- * `Args` are the method parameters (excluding the mode flag).
- * `TReturn` is the final return value of the workflow.
- * `TNext` is the type that is yielded/awaited and fed back via `.next(...)`.
- *
- * Note:
- * - For best inference at yield sites, prefer `yield* unwrap(expr)` for maybe-async expressions.
- */
-export type ReactiveOrAsyncGen<TThis, Arguments extends any[], TReturn, TNext> = (this: TThis, a: boolean, ...args: Arguments) => Generator<MaybePromise<TNext>, TReturn, TNext>;
-/**
- * The method type produced from the generator signature.
- * Adds overloads so that `{ async: true }` yields a `Promise<...>` return type.
- */
-export type ReactiveOrAsyncMethod<TThis, P extends any[], R, N> = {
-    (this: TThis, ...args: P): R;
-    (this: TThis, ...args: [...P, ModeOptions?]): MaybePromise<R>;
-    (this: TThis, ...args: [...P, {
-        async: true;
-    }]): Promise<R>;
-} & {
-    /** Exposes the underlying generator for composition via `yield* method.generator.call(this, a, ...)` */
-    generator: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>;
-};
-/**
- * Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
- *
- * Call style:
- *   fn(a, b)                        -> sync/reactive return
- *   await fn(a, b, { async: true }) -> async return
- * @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
- *   any values that may be Promises.
- * @returns A callable method with overloads plus a `.generator` property for composition.
- */
-export default function reactiveOrAsync<TThis, P extends any[], R, N>(gen: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>): ReactiveOrAsyncMethod<TThis, P, R, N>;

package/dist/core/src/utils/serializeValue.d.ts

@@ -1,12 +0,0 @@
-/**
- * Serializes a value into a string representation.
- * Handles various types, including strings, numbers, booleans, dates, and objects.
- * Falls back to JSON stringification for unsupported types.
- * @param value - The value to serialize.
- *   - Strings are returned as-is.
- *   - Numbers and booleans are converted to their string representation.
- *   - Dates are converted to ISO string format.
- *   - Other values are stringified using `JSON.stringify`.
- * @returns A string representation of the value.
- */
-export default function serializeValue(value: any): string | null;

package/dist/core/src/utils/set.d.ts

@@ -1,13 +0,0 @@
-/**
- * Sets a value at a specified path within an object. Creates nested structures
- * (arrays or objects) as needed to set the value at the correct location. Supports
- * deleting the key if the value is `undefined` and the `deleteIfUndefined` flag is set to `true`.
- * @template T - The type of the object to modify.
- * @template K - The type of the value to set.
- * @param object - The object to modify. The object is mutated directly.
- * @param path - The path (dot or bracket notation) where the value should be set.
- * @param value - The value to set at the specified path.
- * @param deleteIfUndefined - A boolean indicating whether to delete the key if the value is `undefined` (default: `false`).
- * @returns The modified object.
- */
-export default function set<T extends object, K>(object: T, path: string, value: K, deleteIfUndefined?: boolean): T;

package/dist/core/src/utils/sortItems.d.ts

@@ -1,12 +0,0 @@
-/**
- * Sorts an array of items based on multiple fields and their specified sort order.
- * Uses the `fast-sort` library for efficient sorting.
- * @template T - The type of the items in the array.
- * @param items - The array of items to be sorted.
- * @param sortFields - An object defining the sort order for each field.
- *   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
- * @returns A new array of items sorted based on the specified fields and their order.
- */
-export default function sortItems<T extends Record<string, any>>(items: T[], sortFields: {
-    [P in keyof T]?: -1 | 1;
-} & Record<string, -1 | 1>): T[];

package/dist/core/src/utils/uniqueBy.d.ts

@@ -1,10 +0,0 @@
-/**
- * Filters an array to ensure unique values based on a specified key or transformation function.
- * @template T - The type of the elements in the array.
- * @param array - The array to filter for unique values.
- * @param fn - A key or transformation function to determine uniqueness.
- *   - If a key is provided, it will use the corresponding property of each element for uniqueness.
- *   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
- * @returns A new array containing only unique elements based on the specified key or transformation.
- */
-export default function uniqueBy<T>(array: T[], fn: keyof T | ((item: T) => any)): T[];