@vielzeug/toolkit 1.0.13 → 1.1.2

package/dist/index.d.ts

@@ -1,3 +1,40 @@
+/**
+ * Returns the absolute value of a number.
+ * Supports both regular numbers and bigint.
+ *
+ * @example
+ * ```ts
+ * abs(-5); // 5
+ * abs(3); // 3
+ * abs(-100n); // 100n
+ * ```
+ *
+ * @param value - The number or bigint to get absolute value of
+ * @returns Absolute value
+ */
+export declare function abs(value: number): number;
+
+export declare function abs(value: bigint): bigint;
+
+/**
+ * Adds two numbers with precision handling for financial calculations.
+ * Supports both regular numbers and bigint for exact precision.
+ *
+ * @example
+ * ```ts
+ * add(10, 20); // 30
+ * add(0.1, 0.2); // 0.3 (precision-safe)
+ * add(100n, 200n); // 300n
+ * ```
+ *
+ * @param a - First number or bigint
+ * @param b - Second number or bigint
+ * @returns Sum of a and b
+ */
+export declare function add(a: number, b: number): number;
+
+export declare function add(a: bigint, b: bigint): bigint;
+
 /**
  * Aggregates an array of objects into an object based on a key generated by a selector function.
  *
@@ -20,6 +57,31 @@ export declare namespace aggregate {
     var fp: boolean;
 }
 
+/**
+ * Distributes an amount proportionally according to given ratios.
+ * Handles rounding to ensure the sum equals the original amount exactly.
+ * Critical for financial operations like splitting payments to avoid rounding errors.
+ *
+ * @example
+ * ```ts
+ * // Split $100 in ratio 1:2:3
+ * allocate(100, [1, 2, 3]);
+ * // [17, 33, 50] - sum is exactly 100
+ *
+ * // Split with bigint (e.g., cents)
+ * allocate(10000n, [1, 1, 1]);
+ * // [3334n, 3333n, 3333n] - sum is exactly 10000n
+ * ```
+ *
+ * @param amount - Total amount to allocate
+ * @param ratios - Array of ratios for distribution
+ * @returns Array of allocated amounts (sum equals original amount)
+ * @throws {Error} If ratios array is empty or contains negative values
+ */
+export declare function allocate(amount: number, ratios: number[]): number[];
+
+export declare function allocate(amount: bigint, ratios: number[]): bigint[];
+
 /**
  * Either adds or removes an item from an array, based on whether it already exists in the array.
  *
@@ -54,6 +116,27 @@ export declare namespace alternate {
 
 export declare type ArgType = 'array' | 'boolean' | 'date' | 'error' | 'function' | 'map' | 'nan' | 'null' | 'number' | 'object' | 'promise' | 'regexp' | 'set' | 'string' | 'symbol' | 'weakmap' | 'weakset' | 'undefined';
 
+/**
+ * Arranges (sorts) an array of objects based on multiple selectors.
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { name: 'Alice', age: 30 },
+ *   { name: 'Bob', age: 25 },
+ *   { name: 'Charlie', age: 35 },
+ *   { name: 'Alice', age: 25 },
+ *   { name: 'Bob', age: 30 },
+ *   { name: 'Charlie', age: 30 },
+ * ].arrange(data, { name: 'asc', age: 'desc' }); // [ { name: 'Alice', age: 30 }, { name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }, { name: 'Bob', age: 25 }, { name: 'Charlie', age: 35 }, { name: 'Charlie', age: 30 } ]
+ * ```
+ *
+ * @param array - The array to sort.
+ * @param selectors - An object where keys are the properties to sort by and values are 'asc' or 'desc'.
+ * @returns A new sorted array.
+ */
+export declare const arrange: <T>(array: T[], selectors: Partial<Record<keyof T, "asc" | "desc">>) => T[];
+
 /**
  * Asserts that the condition is true. If the condition is false, it throws an error
  * with the provided message or logs a warning in soft mode.
@@ -177,6 +260,35 @@ export declare function average<T>(array: T[], callback?: (item: T) => number |
  */
 export declare function boil<T>(array: readonly T[], callback: (a: T, b: T) => T): T | undefined;
 
+/**
+ * Creates a generic key-value cache with automatic garbage collection and observer support.
+ *
+ * @example
+ * ```ts
+ * const myCache = cache<string>();
+ * myCache.set(['user', 1], 'John Doe');
+ * const value = myCache.get(['user', 1]); // 'John Doe'
+ * myCache.scheduleGc(['user', 1], 5000); // Auto-delete after 5s
+ * ```
+ *
+ * @template T - The type of values stored in the cache.
+ *
+ * @returns A cache instance with get, set, delete, clear, and GC methods.
+ */
+export declare function cache<T>(): {
+    clear: () => void;
+    delete: (key: readonly unknown[]) => boolean;
+    get: (key: readonly unknown[]) => T | undefined;
+    getMeta: (key: readonly unknown[]) => Record<string, unknown> | undefined;
+    getMetaByHash: (keyHash: string) => Record<string, unknown> | undefined;
+    hash: (key: readonly unknown[]) => string;
+    listMetaHashes: () => string[];
+    scheduleGc: (key: readonly unknown[], delayMs: number) => void;
+    set: (key: readonly unknown[], value: T) => void;
+    setMeta: (key: readonly unknown[], meta: Record<string, unknown>) => void;
+    size: () => number;
+};
+
 /** biome-ignore-all lint/suspicious/noExplicitAny: - */
 export declare type Callback<T = any, R = any> = (value: T, index: number, array: T[]) => R;
 
@@ -361,12 +473,6 @@ export declare function compose<T extends FnDynamic[]>(...fns: T): ComposeReturn
 
 declare type ComposeReturn<T extends FnDynamic[]> = (...args: LastParameters<T>) => FirstReturnType<T> extends Promise<any> ? Promise<Awaited<FirstReturnType<T>>> : FirstReturnType<T>;
 
-declare type Config<T> = {
-    filterFn?: Predicate<T>;
-    limit?: number;
-    sortFn?: (a: T, b: T) => number;
-};
-
 /**
  * Checks if a value is present in an array.
  *
@@ -390,6 +496,36 @@ export declare namespace contains {
     var fp: boolean;
 }
 
+/**
+ * Formats a monetary amount as a currency string with proper locale and symbol.
+ * Handles decimal places automatically based on currency.
+ *
+ * @example
+ * ```ts
+ * const money = { amount: 123456n, currency: 'USD' };
+ *
+ * currency(money); // '$1,234.56' (default en-US)
+ * currency(money, { locale: 'de-DE' }); // '1.234,56 $'
+ * currency(money, { style: 'code' }); // 'USD 1,234.56'
+ * currency(money, { style: 'name' }); // '1,234.56 US dollars'
+ * ```
+ *
+ * @param money - Money object to format
+ * @param options - Formatting options
+ * @returns Formatted currency string
+ */
+export declare function currency(money: Money, options?: CurrencyFormatOptions): string;
+
+/**
+ * Options for currency formatting.
+ */
+export declare type CurrencyFormatOptions = {
+    locale?: string;
+    style?: 'symbol' | 'code' | 'name';
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+};
+
 export declare type Curried<P extends readonly unknown[], R> = P extends readonly [] ? () => R : <A extends readonly [unknown, ...(readonly unknown[])]>(...args: A) => P extends readonly [...A, ...infer Rest] ? (Rest extends readonly [] ? R : Curried<Rest, R>) : never;
 
 export declare function curry<T extends (...args: any[]) => any>(fn: T): Curried<Parameters<T>, ReturnType<T>>;
@@ -412,6 +548,29 @@ declare type DeepMerge<T, U> = T extends Obj ? U extends Obj ? {
     [K in keyof T | keyof U]: K extends keyof T ? K extends keyof U ? DeepMerge<T[K], U[K]> : T[K] : K extends keyof U ? U[K] : never;
 } : U : U;
 
+/**
+ * Creates a deferred promise with resolve and reject methods exposed.
+ * Useful for creating promises that are resolved/rejected externally.
+ *
+ * @example
+ * ```ts
+ * const deferred = defer<string>();
+ *
+ * setTimeout(() => {
+ *   deferred.resolve('Done!');
+ * }, 1000);
+ *
+ * const result = await deferred.promise; // 'Done!'
+ * ```
+ *
+ * @returns Object with promise and resolve/reject methods
+ */
+export declare function defer<T = void>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+
 /**
  * Delays the execution of a function by a specified amount of time.
  *
@@ -447,6 +606,51 @@ export declare function delay<T extends Fn>(fn: T, delay?: number): Promise<any>
  */
 export declare function diff<T extends Obj>(curr?: T, prev?: T, compareFn?: (a: unknown, b: unknown) => boolean): Partial<T>;
 
+/**
+ * Distributes an amount evenly among N parties.
+ * Handles rounding to ensure the sum equals the original amount exactly.
+ * Useful for splitting bills, costs, or payments equally.
+ *
+ * @example
+ * ```ts
+ * // Split $100 among 3 people
+ * distribute(100, 3);
+ * // [34, 33, 33] - sum is exactly 100
+ *
+ * // Split with bigint (e.g., cents)
+ * distribute(10000n, 3);
+ * // [3334n, 3333n, 3333n] - sum is exactly 10000n
+ * ```
+ *
+ * @param amount - Total amount to distribute
+ * @param parts - Number of parts to divide into
+ * @returns Array of distributed amounts (a sum equals original amount)
+ * @throws {Error} If parts are less than 1
+ */
+export declare function distribute(amount: number, parts: number): number[];
+
+export declare function distribute(amount: bigint, parts: number): bigint[];
+
+/**
+ * Divides a number by a divisor with precision handling for financial calculations.
+ * Supports both regular numbers and bigint for exact precision.
+ *
+ * @example
+ * ```ts
+ * divide(20, 5); // 4
+ * divide(0.6, 3); // 0.2 (precision-safe)
+ * divide(500n, 5n); // 100n
+ * ```
+ *
+ * @param a - Number to divide (dividend)
+ * @param b - Divisor
+ * @returns Quotient of a divided by b
+ * @throws {Error} If divisor is zero
+ */
+export declare function divide(a: number, b: number): number;
+
+export declare function divide(a: bigint, b: bigint): bigint;
+
 /**
  * “Draw” a random item from an array.
  *
@@ -505,6 +709,35 @@ export declare namespace every {
     var fp: boolean;
 }
 
+/**
+ * Converts money from one currency to another using the provided exchange rate.
+ * Maintains precision by using bigint arithmetic.
+ *
+ * @example
+ * ```ts
+ * const usd = { amount: 100000n, currency: 'USD' }; // $1,000.00
+ * const rate = { from: 'USD', to: 'EUR', rate: 0.85 };
+ *
+ * exchange(usd, rate);
+ * // { amount: 85000n, currency: 'EUR' } // €850.00
+ * ```
+ *
+ * @param money - Money to convert
+ * @param rate - Exchange rate information
+ * @returns Converted money in target currency
+ * @throws {Error} If source currency doesn't match rate.from
+ */
+export declare function exchange(money: Money, rate: ExchangeRate): Money;
+
+/**
+ * Exchange rate for currency conversion.
+ */
+export declare type ExchangeRate = {
+    from: string;
+    to: string;
+    rate: number;
+};
+
 export declare type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';
 
 /**
@@ -1297,32 +1530,42 @@ declare type LastReturnType<T> = T extends [...any, infer Last extends FnDynamic
  */
 export declare function le(a: unknown, b: unknown): boolean;
 
-export declare function list<T>(initialData: T[], config?: Config<T>): {
-    readonly current: T[];
-    data: T[];
-    filter(predicate: (item: T) => boolean): T[];
-    limit: number;
-    readonly meta: {
-        end: number;
-        isEmpty: boolean;
-        isFirst: boolean;
-        isLast: boolean;
-        limit: number;
-        page: number;
-        pages: number;
-        start: number;
-        total: number;
-    };
+export declare type List<T, F, S> = {
+    readonly current: readonly T[];
+    readonly meta: Meta;
+    subscribe(listener: () => void): () => void;
+    goTo(page: number): void;
     next(): void;
-    page: number;
-    readonly pages: T[][];
     prev(): void;
-    reset(): T[];
-    search: Debounced<(str: string) => T[]>;
-    sort(fn?: (a: T, b: T) => number): T[];
-    [Symbol.iterator](): Generator<T[], void, unknown>;
+    reset(): void;
+    search(query: string, opts?: {
+        immediate?: boolean;
+    }): void;
+    setData?(data: readonly T[]): void;
+    setFilter(filter: F): void;
+    setLimit(n: number): void;
+    setSort(sort?: S): void;
+    batch(mutator: (ctx: {
+        setLimit(n: number): void;
+        setFilter(f: F): void;
+        setSort(s?: S): void;
+        setQuery(q: string): void;
+        setData?(d: readonly T[]): void;
+        goTo(p: number): void;
+    }) => void): void;
 };
 
+export declare function list<T>(initialData: readonly T[], cfg?: LocalConfig<T>): List<T, Predicate<T>, Sorter<T>>;
+
+declare type LocalConfig<T> = Readonly<{
+    debounceMs?: number;
+    filterFn?: Predicate<T>;
+    limit?: number;
+    searchFn?: (items: readonly T[], query: string, tone: number) => readonly T[];
+    searchTone?: number;
+    sortFn?: Sorter<T>;
+}>;
+
 /**
  * Checks if the first argument is less than the second argument.
  *
@@ -1456,6 +1699,18 @@ export declare function merge<T extends Obj[]>(strategy?: MergeStrategy, ...item
 
 declare type MergeStrategy = 'deep' | 'shallow' | 'lastWins' | 'arrayConcat' | 'arrayReplace' | ((target: any, source: any) => any);
 
+export declare type Meta = Readonly<{
+    end: number;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    limit: number;
+    page: number;
+    pages: number;
+    start: number;
+    total: number;
+}>;
+
 /**
  * Finds the minimum item in an array.
  *
@@ -1479,6 +1734,34 @@ declare type MergeStrategy = 'deep' | 'shallow' | 'lastWins' | 'arrayConcat' | '
  */
 export declare function min<T>(array: T[], callback?: (item: T) => string | number | Date): T | undefined;
 
+/**
+ * Represents a monetary amount with currency.
+ * Amount is stored as bigint (minor units/cents) for precision.
+ */
+export declare type Money = {
+    readonly amount: bigint;
+    readonly currency: string;
+};
+
+/**
+ * Multiplies a number by a scalar with precision handling for financial calculations.
+ * Supports both regular numbers and bigint for exact precision.
+ *
+ * @example
+ * ```ts
+ * multiply(10, 5); // 50
+ * multiply(0.1, 3); // 0.3 (precision-safe)
+ * multiply(100n, 5n); // 500n
+ * ```
+ *
+ * @param a - Number to multiply
+ * @param b - Multiplier
+ * @returns Product of a and b
+ */
+export declare function multiply(a: number, b: number): number;
+
+export declare function multiply(a: bigint, b: bigint): bigint;
+
 export declare type Obj = Record<string, any>;
 
 /**
@@ -1504,6 +1787,37 @@ export declare const once: <T extends Fn>(fn: T) => T & {
     reset: () => void;
 };
 
+/**
+ * Processes an array with an async callback with controlled parallelism.
+ * Similar to Promise.all, but limits how many items are processed concurrently.
+ * Returns an ordered array of results.
+ *
+ * @example
+ * ```ts
+ * // Process 3 items at a time
+ * const results = await parallel(3, [1, 2, 3, 4, 5], async (n) => {
+ *   await delay(100);
+ *   return n * 2;
+ * });
+ * // [2, 4, 6, 8, 10]
+ *
+ * // With abort signal
+ * const controller = new AbortController();
+ * const results = await parallel(2, items, async (item) => {
+ *   return processItem(item);
+ * }, controller.signal);
+ * ```
+ *
+ * @param limit - Maximum number of concurrent operations (must be >= 1)
+ * @param array - Array of items to process
+ * @param callback - Async function to process each item
+ * @param signal - Optional AbortSignal to cancel processing
+ * @returns Promise resolving to an ordered array of results
+ * @throws {Error} If limit is less than 1
+ * @throws {DOMException} If aborted via signal
+ */
+export declare function parallel<T, R>(limit: number, array: T[], callback: (item: T, index: number, array: T[]) => Promise<R>, signal?: AbortSignal): Promise<R[]>;
+
 /**
  * Parses a JSON string and returns the resulting object.
  *
@@ -1527,12 +1841,12 @@ export declare const once: <T extends Fn>(fn: T) => T & {
  */
 export declare function parseJSON<T extends JSONValue>(json: unknown, options?: ParseJSONOptions<T>): T | undefined;
 
-declare interface ParseJSONOptions<T> {
+declare type ParseJSONOptions<T> = {
     defaultValue?: T;
     reviver?: (key: string, value: any) => any;
     validator?: (value: any) => boolean;
     silent?: boolean;
-}
+};
 
 /**
  * Converts a string to Pascal case.
@@ -1636,7 +1950,28 @@ export declare function pipe<T extends FnDynamic[]>(...fns: T): PipeReturn<T>;
 
 declare type PipeReturn<T extends FnDynamic[]> = (...args: FirstParameters<T>) => LastReturnType<T> extends Promise<any> ? Promise<Awaited<LastReturnType<T>>> : LastReturnType<T>;
 
-export declare type Predicate<T> = (value: T, index: number, array: T[]) => boolean | boolean[];
+/**
+ * Creates a promise pool that limits the number of concurrent promises.
+ * Useful for rate limiting API calls or controlling resource usage.
+ *
+ * @example
+ * ```ts
+ * const requestPool = pool(3);
+ *
+ * const results = await Promise.all([
+ *   requestPool(() => fetch('/api/1')),
+ *   requestPool(() => fetch('/api/2')),
+ *   requestPool(() => fetch('/api/3')),
+ *   requestPool(() => fetch('/api/4')), // Will wait for one of the above to finish
+ * ]);
+ * ```
+ *
+ * @param limit - Maximum number of concurrent promises
+ * @returns Function that accepts a promise-returning function and executes it when a slot is available
+ */
+export declare function pool(limit: number): <T>(fn: () => Promise<T>) => Promise<T>;
+
+export declare type Predicate<T> = (value: T, index: number, array: readonly T[]) => boolean;
 
 /**
  * Creates a Promise that can be aborted using an AbortController.
@@ -1693,6 +2028,95 @@ declare type ProxyOptions<T> = {
     watch?: (keyof T)[];
 };
 
+/**
+ * Removes all nullable and empty values from strings, arrays, or objects.
+ *
+ * - For strings: Removes leading/trailing whitespace and returns undefined if empty
+ * - For arrays: Recursively removes null, undefined, empty strings, and empty objects/arrays
+ * - For objects: Recursively removes properties with null, undefined, empty strings, and empty objects/arrays
+ *
+ * @example
+ * ```ts
+ * prune('  hello  '); // 'hello'
+ * prune('   '); // undefined
+ * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]
+ * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }
+ * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }
+ * ```
+ *
+ * @param value - The value to prune (can be string, array, object, or any other type)
+ * @returns The pruned value, or undefined if the result would be empty
+ */
+export declare function prune<T>(value: T): T | undefined;
+
+/**
+ * Creates a promise queue that processes promises sequentially with optional concurrency limit.
+ *
+ * @example
+ * ```ts
+ * const requestQueue = queue({ concurrency: 2 });
+ *
+ * requestQueue.add(() => fetch('/api/1'));
+ * requestQueue.add(() => fetch('/api/2'));
+ * requestQueue.add(() => fetch('/api/3'));
+ *
+ * await requestQueue.onIdle(); // Wait for all tasks to complete
+ * ```
+ *
+ * @param options - Queue configuration
+ * @param options.concurrency - Maximum number of concurrent promises (default: 1)
+ * @returns Queue instance with add, onIdle, and clear methods
+ */
+export declare function queue(options?: {
+    concurrency?: number;
+}): {
+    /**
+     * Adds a promise-returning function to the queue
+     */
+    add: <T>(fn: () => Promise<T>) => Promise<T>;
+    /**
+     * Clears all pending tasks from the queue
+     */
+    clear: () => void;
+    /**
+     * Returns a promise that resolves when the queue becomes idle
+     */
+    onIdle: () => Promise<void>;
+    /**
+     * Returns the number of currently active promises
+     */
+    readonly pending: number;
+    /**
+     * Returns the current size of the queue
+     */
+    readonly size: number;
+};
+
+/**
+ * Race multiple promises but with a guaranteed minimum delay.
+ * Useful for showing loading states for at least a minimum duration.
+ *
+ * @example
+ * ```ts
+ * // Show loading spinner for at least 500ms
+ * const result = await race(
+ *   fetchData(),
+ *   500
+ * );
+ *
+ * // With multiple promises
+ * const result = await race(
+ *   [fetch('/api/1'), fetch('/api/2')],
+ *   1000
+ * );
+ * ```
+ *
+ * @param promises - Single promise or array of promises to race
+ * @param minDelay - Minimum delay in milliseconds before resolving
+ * @returns Promise that resolves with the first result after the minimum delay
+ */
+export declare function race<T>(promises: Promise<T> | Promise<T>[], minDelay: number): Promise<T>;
+
 /**
  * Generates a random integer between two values, inclusive.
  *
@@ -1777,6 +2201,72 @@ export declare namespace reduce {
     var fn: boolean;
 }
 
+declare type RemoteConfig<T, F, S> = Readonly<{
+    debounceMs?: number;
+    fetch: (q: RemoteQuery<F, S>) => Promise<RemoteResult<T>>;
+    initialFilter?: F;
+    initialSort?: S;
+    limit?: number;
+}>;
+
+export declare type RemoteList<T, F, S> = {
+    readonly current: readonly T[];
+    readonly meta: RemoteMeta;
+    subscribe(listener: () => void): () => void;
+    goTo(page: number): Promise<void>;
+    invalidate?(): void;
+    next(): Promise<void>;
+    prev(): Promise<void>;
+    refresh(): Promise<void>;
+    reset(): Promise<void>;
+    search(query: string, opts?: {
+        immediate?: boolean;
+    }): Promise<void>;
+    setFilter(filter: F): Promise<void>;
+    setLimit(n: number): Promise<void>;
+    setSort(sort?: S): Promise<void>;
+    batch(mutator: (ctx: {
+        setLimit(n: number): void;
+        setFilter(f: F): void;
+        setSort(s?: S): void;
+        setQuery(q: string): void;
+        setData?(d: readonly T[]): void;
+        goTo(p: number): void;
+    }) => void): Promise<void>;
+};
+
+export declare function remoteList<T, F = Record<string, unknown>, S = {
+    key?: string;
+    dir?: 'asc' | 'desc';
+}>(cfg: RemoteConfig<T, F, S>): RemoteList<T, F, S>;
+
+export declare type RemoteMeta = Readonly<{
+    end: number;
+    error: string | null;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    limit: number;
+    loading: boolean;
+    page: number;
+    pages: number;
+    start: number;
+    total: number;
+}>;
+
+declare type RemoteQuery<F, S> = Readonly<{
+    filter?: F;
+    limit: number;
+    page: number;
+    search?: string;
+    sort?: S;
+}>;
+
+declare type RemoteResult<T> = Readonly<{
+    items: readonly T[];
+    total: number;
+}>;
+
 declare type RemoveFirstParameter<T extends Fn> = T extends (first: any, ...rest: infer R) => any ? R : never;
 
 export declare type Result<C extends FnDynamic> = C extends FnAsync ? Promise<Awaited<ReturnType<C>>> : ReturnType<C>;
@@ -2036,26 +2526,7 @@ export declare const sort: {
     fp: boolean;
 };
 
-/**
- * Sorts an array of objects based on multiple selectors.
- *
- * @example
- * ```ts
- * const data = [
- *   { name: 'Alice', age: 30 },
- *   { name: 'Bob', age: 25 },
- *   { name: 'Charlie', age: 35 },
- *   { name: 'Alice', age: 25 },
- *   { name: 'Bob', age: 30 },
- *   { name: 'Charlie', age: 30 },
- * ].sortBy(data, { name: 'asc', age: 'desc' }); // [ { name: 'Alice', age: 30 }, { name: 'Alice', age: 25 }, { name: 'Bob', age: 30 }, { name: 'Bob', age: 25 }, { name: 'Charlie', age: 35 }, { name: 'Charlie', age: 30 } ]
- * ```
- *
- * @param array - The array to sort.
- * @param selectors - An object where keys are the properties to sort by and values are 'asc' or 'desc'.
- * @returns A new sorted array.
- */
-export declare const sortBy: <T>(array: T[], selectors: Partial<Record<keyof T, "asc" | "desc">>) => T[];
+export declare type Sorter<T> = (a: T, b: T) => number;
 
 /**
  * Replaces the first element in an array that satisfies the provided predicate function with a new value.
@@ -2079,6 +2550,25 @@ export declare namespace substitute {
     var fn: boolean;
 }
 
+/**
+ * Subtracts one number from another with precision handling for financial calculations.
+ * Supports both regular numbers and bigint for exact precision.
+ *
+ * @example
+ * ```ts
+ * subtract(20, 10); // 10
+ * subtract(0.3, 0.1); // 0.2 (precision-safe)
+ * subtract(300n, 100n); // 200n
+ * ```
+ *
+ * @param a - Number to subtract from
+ * @param b - Number to subtract
+ * @returns Difference of a and b
+ */
+export declare function subtract(a: number, b: number): number;
+
+export declare function subtract(a: bigint, b: bigint): bigint;
+
 /**
  * Sum numbers in an array or numbers mapped by a callback function.
  *
@@ -2272,6 +2762,40 @@ export declare function uuid(): string;
  */
 export declare function values<T extends Obj, K extends keyof T>(item: T): T[K][];
 
+/**
+ * Waits for a condition to become true by polling.
+ * Useful for waiting for DOM elements, API states, or other conditions.
+ *
+ * @example
+ * ```ts
+ * // Wait for an element to appear
+ * await waitFor(() => document.querySelector('#myElement') !== null);
+ *
+ * // Wait for API to be ready
+ * await waitFor(
+ *   async () => {
+ *     const res = await fetch('/api/health');
+ *     return res.ok;
+ *   },
+ *   { timeout: 30000, interval: 1000 }
+ * );
+ * ```
+ *
+ * @param condition - Function that returns true when condition is met
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait in ms (default: 5000)
+ * @param options.interval - Polling interval in ms (default: 100)
+ * @param options.signal - AbortSignal to cancel waiting
+ * @returns Promise that resolves when condition becomes true
+ * @throws {Error} If timeout is reached
+ * @throws {DOMException} If aborted via signal
+ */
+export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
+    timeout?: number;
+    interval?: number;
+    signal?: AbortSignal;
+}): Promise<void>;
+
 /**
  * Creates a function that runs the provided callback in a web worker with specified dependencies.
  *