@signaldb/sinuous 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/base/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/base/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/base/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/base/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/base/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/base/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/base/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/base/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/base/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/base/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/base/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/base/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[];