@catstral/levy-utils 1.1.0 → 2.0.0

package/dist/array/index.d.ts

@@ -1,8 +1,20 @@
-export * from './utils/cluster';
-export * from './utils/counting';
-export * from './utils/fork';
-export * from './utils/list';
-export * from './utils/select';
-export * from './utils/sift';
-export * from './utils/sum';
-export * from './utils/toggle';
+export * from "./utils/cluster";
+export * from "./utils/concat";
+export * from "./utils/counting";
+export * from "./utils/filter";
+export * from "./utils/filterMap";
+export * from "./utils/first";
+export * from "./utils/fork";
+export * from "./utils/group";
+export * from "./utils/hasItems";
+export * from "./utils/last";
+export * from "./utils/list";
+export * from "./utils/map";
+export * from "./utils/max";
+export * from "./utils/min";
+export * from "./utils/overflow";
+export * from "./utils/reduce";
+export * from "./utils/select";
+export * from "./utils/sift";
+export * from "./utils/sum";
+export * from "./utils/toggle";

package/dist/array/utils/cluster/index.d.ts

@@ -1,4 +1,4 @@
-import { UtilError } from '../../../error';
+import { UtilError } from "~/error";
 export declare class ClusterUtilError extends UtilError {
     readonly util = "cluster";
 }
@@ -11,7 +11,6 @@ export declare class ClusterUtilError extends UtilError {
  * @param {T[]} items The items to cluster
  * @param size The max size for each list
  * @returns {T[][]} An array of arrays with a max size of the specified size
- * @throws {ClusterUtilError} If the cluster size is less then 1
- * @throws {ClusterUtilError} If the given items are not an array
+ * @throws {ClusterUtilError} If the cluster size is less than 1
  */
 export declare function cluster<const T>(items: T[], size: number): T[][];

package/dist/array/utils/concat/index.d.ts

@@ -0,0 +1,14 @@
+export type Concat<T extends (unknown[] | unknown)[]> = T extends [infer V, ...infer R] ? [...(V extends readonly unknown[] ? V : [V]), ...Concat<R>] : [];
+/**
+ * Concatenates values and arrays into a new array.
+ *
+ * Array arguments are flattened by one level.
+ * Non-array arguments are added as individual values.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of values.
+ *
+ * @template {(? | ?[])[]} T
+ * @param {...T} values Values or arrays of values to concatenate
+ * @returns {Concat<T>} A new array containing all provided values
+ */
+export declare function concat<const T extends (unknown | unknown[])[]>(...values: T): Concat<T>;

package/dist/array/utils/counting/index.d.ts

@@ -1,6 +1,6 @@
-import { Key } from '../../../types';
+import type { Key } from "~/types";
 /**
- * Reduces a list down to an object of keys (specified using the `identity` param)
+ * Reduces a list down to an object of keys specified by the given `identity` callback
  * with a number of how many times that identity has been seen.
  *
  * The time complexity for this is `O(n)` where `n` is the amount of items in the list.

package/dist/array/utils/filter/index.d.ts

@@ -0,0 +1,55 @@
+import type { Promisable } from "~/types";
+/**
+ * Returns a new list containing the items of a given list that pass a predicate.
+ *
+ * If the predicate returns a promise for any item, a promise is returned that resolves once all of them have.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @template {T} R
+ * @param {readonly T[]} list The array to filter values from
+ * @param {(item: T, index: number, list: readonly T[]) => item is R} predicate A callback that returns whether an item is filtered
+ * @returns {R[]} A new list containing the filtered items, or a promise of it if the predicate can return a promise
+ */
+export declare function filter<const T, const R extends T>(list: readonly T[], predicate: (item: T, index: number, list: readonly T[]) => item is R): R[];
+/**
+ * Returns a new list containing the items of a given list that pass a predicate.
+ *
+ * If the predicate returns a promise for any item, a promise is returned that resolves once all of them have.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @param {readonly T[]} list The array to filter values from
+ * @param {(item: T, index: number, list: readonly T[]) => Promise<unknown>} predicate A callback that returns whether an item is filtered
+ * @returns {Promise<T[]>} A new list containing the filtered items, or a promise of it if the predicate can return a promise
+ */
+export declare function filter<const T>(list: readonly T[], predicate: (item: T, index: number, list: readonly T[]) => Promise<unknown>): Promise<T[]>;
+/**
+ * Returns a new list containing the items of a given list that pass a predicate.
+ *
+ * If the predicate returns a promise for any item, a promise is returned that resolves once all of them have.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @template P
+ * @param {readonly T[]} list The array to filter values from
+ * @param {(item: T, index: number, list: readonly T[]) => P} predicate A callback that returns whether an item is filtered
+ * @returns {[Extract<P, Promise<unknown>>] extends [never] ? T[] : Promisable<T[]>} A new list containing the filtered items, or a promise of it if the predicate can return a promise
+ */
+export declare function filter<const T, const P>(list: readonly T[], predicate: (item: T, index: number, list: readonly T[]) => P): [Extract<P, Promise<unknown>>] extends [never] ? T[] : Promisable<T[]>;
+/**
+ * Returns a new list containing the items of a given list that pass a predicate.
+ *
+ * If the predicate returns a promise for any item, a promise is returned that resolves once all of them have.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @param {readonly T[]} list The array to filter values from
+ * @param {(item: T, index: number, list: readonly T[]) => unknown} predicate A callback that returns whether an item is filtered
+ * @returns {T[]} A new list containing the filtered items, or a promise of it if the predicate can return a promise
+ */
+export declare function filter<const T>(list: readonly T[], predicate: (item: T, index: number, list: readonly T[]) => unknown): T[];

package/dist/array/utils/filterMap/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a new list of items based on filtered and mapped values of a given list.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @template R
+ * @param {T[] | readonly T[]} list The list to filter and map values through
+ * @param {(item: T, index: number) => boolean} filter A callback to filter out values from the given list
+ * @param {(item: T, index: number, originalIndex: number) => R} mapper A mapper to convert the filtered values
+ * @returns {R[]} A new list with all filtered and mapped values
+ */
+export declare function filterMap<const T, const V extends T, const R>(list: T[] | readonly T[], filter: (item: T, index: number) => item is V, mapper: (item: V, index: number, originalIndex: number) => R): R[];
+export declare function filterMap<const T, const R>(list: T[] | readonly T[], filter: (item: T, index: number) => boolean, mapper: (item: T, index: number, originalIndex: number) => R): R[];

package/dist/array/utils/first/index.d.ts

@@ -0,0 +1,13 @@
+export type First<T extends readonly unknown[], F = undefined> = T extends readonly [infer V, ...T[number][]] ? V : T[number] | (T extends readonly [...T[number][], T[number]] ? never : F);
+/**
+ * Returns the first item of a list or a fallback if the list is empty.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @template [F=undefined]
+ * @param list The array to get the first item from
+ * @param [fallback] The value to fall back to if the list is empty
+ * @returns {First<T, F>} The first item of the list or a fallback
+ */
+export declare function first<const T extends readonly unknown[], const F = undefined>(list: T, fallback?: F): First<T, F>;

package/dist/array/utils/group/index.d.ts

@@ -0,0 +1,14 @@
+import type { Key } from "~/types";
+/**
+ * Reduces a list down to an object of keys specified by the given `identity` callback.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @template T
+ * @template {Key} K
+ * @param {T} list The list to count
+ * @param {(item: T) => K} identity A function to identify what value to count
+ * @returns {Partial<Record<K, T[]>>} A keyed object with how many times that key showed up.
+ * Do note that the keys that didn't show up are not on this object
+ */
+export declare function group<const T, const K extends Key = Key>(list: T[], identity: (item: T) => K): Partial<Record<K, T[]>>;

package/dist/array/utils/hasItems/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks if the given array has at least one item.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @templat T
+ * @param {T[]} list The array to check
+ * @returns {boolean} A boolean to signal if the given array has at least one item
+ */
+export declare function hasItems<const T>(list: [...T[], T]): list is [...T[], T];
+export declare function hasItems<const T>(list: T[]): list is [T, ...T[]];
+export declare function hasItems<const T>(list: readonly [...T[], T]): list is readonly [...T[], T];
+export declare function hasItems<const T>(list: readonly T[]): list is readonly [T, ...T[]];

package/dist/array/utils/isArray/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given item is an array.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {?} value The value to check
+ * @returns {boolean} A boolean to signal if the given item is an array
+ */
+export declare function isArray(value: unknown): value is unknown[];

package/dist/array/utils/last/index.d.ts

@@ -0,0 +1,14 @@
+export type Last<T extends readonly unknown[], F = undefined> = T extends readonly [...T[number][], infer V] ? V : T[number] | (T extends readonly [T[number], ...T[number][]] ? never : F);
+/**
+ * Returns the last item of a list or a fallback if the list is empty.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @template {readonly T[]} [L=T[]]
+ * @template [F=undefined]
+ * @param list The array to get the last item from
+ * @param [fallback] The value to fall back to if the list is empty
+ * @returns {First<T, F>} The last item of the list or a fallback
+ */
+export declare function last<const T extends readonly unknown[], const F = undefined>(list: T, fallback?: F): Last<T, F>;

package/dist/array/utils/list/index.d.ts

@@ -1,5 +1,5 @@
-import { UtilError } from '../../../error';
-import { Computable } from '../../../misc/utils/compute';
+import { UtilError } from "~/error";
+import { type Computable } from "~/misc/utils/compute";
 export declare class ListUtilError extends UtilError {
     readonly util = "list";
 }

package/dist/array/utils/map/index.d.ts

@@ -0,0 +1,29 @@
+import type { Promisable } from "~/types";
+/**
+ * Returns a new list of items based on mapped values of a given list.
+ *
+ * If the callback returns a promise for any item, a promise is returned that resolves once all of them have.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @template R
+ * @param {readonly T[]} list The array to map values from
+ * @param {(item: T, index: number, list: readonly T[]) => R} callback A mapper to convert the list items
+ * @returns {Promise<Awaited<R>[]>} A new array with mapped items from the given list, or a promise of it if the callback can return a promise
+ */
+export declare function map<const T, const R>(list: readonly T[], callback: (item: T, index: number, list: readonly T[]) => Promise<R>): Promise<Awaited<R>[]>;
+/**
+ * Returns a new list of items based on mapped values of a given list.
+ *
+ * If the callback returns a promise for any item, a promise is returned that resolves once all of them have.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ *
+ * @template T
+ * @template R
+ * @param {readonly T[]} list The array to map values from
+ * @param {(item: T, index: number, list: readonly T[]) => R} callback A mapper to convert the list items
+ * @returns {[Extract<R, Promise<unknown>>] extends [never] ? R[] : Promisable<Awaited<R>[]>} A new array with mapped items from the given list, or a promise of it if the callback can return a promise
+ */
+export declare function map<const T, const R>(list: readonly T[], callback: (item: T, index: number, list: readonly T[]) => R): [Extract<R, Promise<unknown>>] extends [never] ? R[] : Promisable<Awaited<R>[]>;

package/dist/array/utils/max/index.d.ts

@@ -0,0 +1,24 @@
+export interface MaxOptions {
+    /**
+     * The direction the list should be checked in.
+     *
+     * @default "ASCENDING"
+     */
+    direction?: "ASCENDING" | "DESCENDING";
+}
+/**
+ * Returns the largest item from a list.
+ *
+ * If no mapper is specified, non-numeric values within a list aren't compared.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @template T
+ * @param {T[]} list The list to
+ * @param {(item: T) => number} mapper A callback to convert an item to a number
+ * @param {MaxOptions} options Options to define how the largest number is decided
+ * @returns {T | undefined} The smallest item from a list
+ */
+export declare function max<const T>(list: [T, ...T[]], mapper: (item: T) => number, options?: MaxOptions): T;
+export declare function max<const T extends number>(list: [T, ...T[]], mapper?: (item: T) => number, options?: MaxOptions): T;
+export declare function max<const T>(list: T[], mapper?: (item: T) => number, options?: MaxOptions): T | undefined;

package/dist/array/utils/min/index.d.ts

@@ -0,0 +1,24 @@
+export interface MinOptions {
+    /**
+     * The direction the list should be checked in.
+     *
+     * @default "ASCENDING"
+     */
+    direction?: "ASCENDING" | "DESCENDING";
+}
+/**
+ * Returns the smallest item from a list.
+ *
+ * If no mapper is specified, non-numeric values within a list aren't compared.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @template T
+ * @param {T[]} list The list to
+ * @param {(item: T) => number} mapper A callback to convert an item to a number
+ * @param {MinOptions} options Options to define how the smallest number is decided
+ * @returns {T | undefined} The smallest item from a list
+ */
+export declare function min<const T>(list: [T, ...T[]], mapper: (item: T) => number, options?: MinOptions): T;
+export declare function min<const T extends number>(list: [T, ...T[]], mapper?: (item: T) => number, options?: MinOptions): T;
+export declare function min<const T>(list: T[], mapper?: (item: T) => number, options?: MinOptions): T | undefined;

package/dist/array/utils/overflow/index.d.ts

@@ -0,0 +1,20 @@
+import { UtilError } from "~/error";
+import type { PositiveInteger } from "~/number";
+export declare class OverflowUtilError extends UtilError {
+    readonly util = "overflow";
+}
+/**
+ * Returns a tuple of 2 arrays that are constructed from a single list based on the given clamp length.
+ * The first item in the tuple is all the items in the list that pass the specified condition,
+ * the second item in the tuple contains the rest of the list items.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @template T
+ * @template {number} L
+ * @param {readonly T[]} list The list to seperate into a clamped and rest list
+ * @param {PositiveInteger<L>} clampLength The length of the clamped list
+ * @returns {[T[], T[]]} A tuple containing a clamped and rest list based off the given list and length
+ * @throws {OverflowUtilError} If the clamp length is less than 1
+ */
+export declare function overflow<const T, const L extends number = number>(list: readonly T[], clampLength: PositiveInteger<L>): [T[], T[]];

package/dist/array/utils/reduce/index.d.ts

@@ -0,0 +1,44 @@
+export type ReduceCallback<T, Acc> = (accumulator: Acc, value: T, index: number, list: readonly T[]) => Acc;
+export interface ReduceOptions<Acc = unknown, R = Acc> {
+    /**
+     * The direction the list should be checked in..
+     *
+     * @default "ASCENDING"
+     */
+    direction?: "ASCENDING" | "DESCENDING";
+    /**
+     * Transforms the accumulator into a final result.
+     *
+     * @param accumulator
+     * @returns {R}
+     */
+    result?: (accumulator: Acc) => R;
+}
+/**
+ * Reduces all items of a list down to an accumulated result.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @template T
+ * @template Acc
+ * @param {readonly T[]} list The array to reduce items from
+ * @param {Acc} initial The initial value of the accumulator
+ * @param {ReduceCallback<T, Acc>} callback A callback that passed the current item and returns a new accumulator
+ * @returns {Acc} The accumulated result of the given list
+ */
+export declare function reduce<const T, Acc>(list: T[], initial: Acc, callback: ReduceCallback<T, Acc>): Acc;
+/**
+ * Reduces all items of a list down to an accumulated result.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @template T
+ * @template Acc
+ * @template [R=Acc]
+ * @param {readonly T[]} list The array to reduce items from
+ * @param {Acc} initial The initial value of the accumulator
+ * @param {ReduceCallback<T, Acc>} callback A callback that passed the current item and returns a new accumulator
+ * @param {ReduceOptions<Acc, R>} options Options to define how the list should be reduced (see {@link ReduceOptions} for more details)
+ * @returns {R} The accumulated result of the given list
+ */
+export declare function reduce<const T, Acc, const R = Acc>(list: readonly T[], initial: Acc, callback: ReduceCallback<T, Acc>, options?: ReduceOptions<Acc, R>): R;

package/dist/array/utils/select/index.d.ts

@@ -1,14 +1,131 @@
+import { UtilError } from "~/error";
+export interface SelectDiscardAction {
+    type: "DISCARD";
+}
+export interface SelectKeepAction {
+    type: "KEEP";
+}
+export interface SelectFilterAction {
+    type: "FILTER";
+    keep: boolean;
+}
+export interface SelectMapAction<R> {
+    type: "MAP";
+    value: R;
+}
+export interface SelectFlatAction<R> {
+    type: "FLAT";
+    list: R[];
+}
+export interface SelectSpreadAction<R> {
+    type: "SPREAD";
+    values: R[];
+}
+export type SelectAction<R> = SelectDiscardAction | SelectKeepAction | SelectFilterAction | SelectMapAction<R> | SelectSpreadAction<R> | SelectFlatAction<R>;
+export interface SelectContext<T, R = T> {
+    /**
+     * The current item in the given list.
+     */
+    item: T;
+    /**
+     * The index of the current item of the given list.
+     */
+    index: number;
+    /**
+     * The given list.
+     */
+    list: readonly T[];
+    /**
+     * Discards the current item from the resulting list.
+     *
+     * @returns {SelectDiscardAction} An action that discards the current item.
+     */
+    discard(): SelectDiscardAction;
+    /**
+     * Keeps the current item in the resulting list.
+     *
+     * @returns {SelectKeepAction} An action that keeps the current item.
+     */
+    keep(): SelectKeepAction;
+    /**
+     * Filters the current item in the resulting list based on the given boolean.
+     *
+     * @param {boolean} keep Whether the current item should be kept
+     * @returns {SelectFilterAction} An action that keeps or discards the current item.
+     */
+    filter(keep: boolean): SelectFilterAction;
+    /**
+     * Maps the current item to the given value in the resulting list.
+     *
+     * @param {R} value The value to add in place of the current item
+     * @returns {SelectMapAction<R>} An action that maps the current item to the given value
+     */
+    map(value: R): SelectMapAction<R>;
+    /**
+     * Flats every item of the given list into the resulting list in place of the current item.
+     *
+     * @param {R[]} list The values to add in place of the current item
+     * @returns {SelectFlatAction<R>} An action that flattens the given values into the resulting list
+     */
+    flat(list: R[]): SelectFlatAction<R>;
+    /**
+     * Spreads every given item into the resulting list in place of the current item.
+     *
+     * @param {...R[]} values The values to add in place of the current item
+     * @returns {SelectSpreadAction<R>} An action that spreads the given values into the resulting list
+     */
+    spread(...values: R[]): SelectSpreadAction<R>;
+}
+export declare class SelectUtilError extends UtilError {
+    readonly util = "select";
+}
 /**
- * Returns a new list of items based on filtered and mapped values of a given list.
+ * Returns a new list built by deciding what should end up in the result per item.
  *
- * The time complexity for this is `O(n)` where `n` is the amount of items in the given list.
+ * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ *
+ * @example
+ * select(
+ *     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+ *     ({ item, keep, discard, filter }) => {
+ *         // Keep all numbers less than 3
+ *         if (item < 3) {
+ *             return keep();
+ *         }
+ *
+ * 		   // Removes all numbers greater than 8
+ *         if (item > 8) {
+ *             return discard();
+ *         }
+ *
+ *         // Filters all even numbers
+ *         return filter(item % 2 === 0);
+ *     },
+ * );
+ *
+ * @example
+ * select<number | string[] | null, string>(
+ *     [1, ["2", "3", "4"], null, ["7", "8", "9"], 10],
+ *     ({ item, map, flat, spread }) => {
+ *         if (typeof item === "number") {
+ *             return map(item.toString());
+ *         }
+ *
+ *         if (Array.isArray(item)) {
+ *              return flat(item);
+ *         }
+ *
+ *         return spread("5", "6");
+ *     },
+ * );
  *
  * @template T
- * @template R
- * @param {T[] | readonly T[]} list The list to filter and map values through
- * @param {(item: T, index: number) => boolean} filter A callback to filter out values from the given list
- * @param {(item: T, index: number, originalIndex: number) => R} mapper A mapper to convert the filtered values
- * @returns {R[]} A new list with all filtered and mapped values
+ * @template [R=T]
+ * @param {readonly T[]} list The list to select items from
+ * @param {(context: SelectContext<T, R>) => SelectAction<R>} callback A callback that returns an action describing what to do with the current item
+ * @returns {R[]} A new list with all kept, mapped and flattened values
+ * @throws {SelectUtilError} If the callback returns an invalid action
  */
-export declare function select<const T, const V extends T, const R>(list: T[] | readonly T[], filter: (item: T, index: number) => item is V, mapper: (item: V, index: number) => R): R[];
-export declare function select<const T, const R>(list: T[] | readonly T[], filter: (item: T, index: number) => boolean, mapper: (item: T, index: number, originalIndex: number) => R): R[];
+export declare function select<T, R = T>(list: readonly T[], callback: (context: [T] extends [R] ? SelectContext<T, R> : Omit<SelectContext<T, R>, "keep" | "filter">) => Exclude<SelectAction<R>, {
+    type: [T] extends [R] ? never : "KEEP" | "FILTER";
+}>): R[];

package/dist/array/utils/sift/index.d.ts

@@ -1,4 +1,4 @@
-import { Falsy } from '../../../types';
+import type { Falsy } from "~/types";
 /**
  * Turns a list of items into another list of items with all the falsy values filtered out of the list.
  *

package/dist/array/utils/toggle/index.d.ts

@@ -1,4 +1,4 @@
-import { Key } from '../../../types';
+import type { Key } from "~/types";
 /**
  * @typedef {Object} ToggleOptions
  * @template T
@@ -23,7 +23,7 @@ export interface ToggleOptions<T> {
 /**
  * Toggles a value from an array and returns the new array with the value either removed or added.
  *
- * The time complexity for this is `O(n)` where `n` is the amount of items in the list.
+ * The time complexity for this is `O(2n)` where `n` is the amount of items in the list.
  *
  * @template T
  * @param {T[]} list The list to toggle the item from

package/dist/callback/index.d.ts

@@ -1,5 +1,8 @@
-export * from './utils/chain';
-export * from './utils/compose';
-export * from './utils/defer';
-export * from './utils/preset';
-export * from './utils/retry';
+export * from "./utils/chain";
+export * from "./utils/compose";
+export * from "./utils/defer";
+export * from "./utils/noop";
+export * from "./utils/pipe";
+export * from "./utils/preset";
+export * from "./utils/retry";
+export * from "./utils/task";

package/dist/callback/utils/noop/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * No operation, this function does nothing.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {void}
+ */
+export declare function noop(): void;

package/dist/callback/utils/pipe/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Pipes a value into a callback and returns its result.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {?} T
+ * @template {?} R
+ * @param {T} value The initial value to be passed into the callback
+ * @param {(value: T) => R} callback A function that accepts `value` and computes a result
+ * @returns {R} The result of the `callback` function
+ */
+export declare function pipe<const T, const R>(value: T, callback: (value: T) => R): R;

package/dist/callback/utils/preset/index.d.ts

@@ -1,13 +1,15 @@
+import { type Computable } from "~/misc";
 /**
- * Presets the parameters of a callback with a callback that computes its arguments.
+ * Presets the parameters of a callback with arguments or a callback that computes its arguments.
  *
  * The time complexity for this is `O(1)`.
  *
  * @template {(...args: never[]) => unknown} T
  * @template {unknown[]} [Args=never[]]
- * @template {Parameters<T>} [Params=Parameters<T>]
  * @param {T} callback The callback to preset the parameters for
- * @param {Computable<Params, Args>} parameters The parameters or callback that computes parameters to preset
+ * @param {Computable<Parameters<T>, Args>} parameters The parameters or callback that computes parameters to preset
  * @returns {(...args: Args) => ReturnType<T>} A callback that runs the input `callback` with the preset parameters
  */
-export declare function preset<const T extends (...args: never[]) => unknown, const Args extends unknown[] = never[]>(callback: T, parameters: (...args: Args) => Parameters<T>): (...args: Args) => ReturnType<T>;
+export declare function preset<const Args extends unknown[] = never[], const R = unknown>(callback: (...args: Args) => R, parameters: Args): () => R;
+export declare function preset<const Args extends unknown[] = never[], const R = unknown, const P extends unknown[] = never[]>(callback: (...args: Args) => R, parameters: (...args: P) => Args): (...args: P) => R;
+export declare function preset<const Args extends unknown[] = never[], const R = unknown, const P extends unknown[] = never[]>(callback: (...args: Args) => R, parameters: Computable<Args, P>): (...args: P) => R;

package/dist/callback/utils/retry/index.d.ts

@@ -1,5 +1,5 @@
-import { UtilError } from '../../../error';
-import { Promisable } from '../../../types';
+import { UtilError } from "~/error";
+import type { Promisable } from "~/types";
 export declare class RetryUtilError extends UtilError {
     readonly util = "retry";
 }

package/dist/callback/utils/task/index.d.ts

@@ -0,0 +1,12 @@
+import type { Promisable } from "~/types";
+/**
+ * Executes the given callback in asynchronous context.
+ *
+ * If no callback is given, it yields execution to the microtask queue.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {() => Promisable<void>} [callback] An optional callback to execute
+ * @returns {Promise<void>} A Promise that resolves after the callback has completed or execution has yielded to the microtask queue
+ */
+export declare function task(callback?: () => Promisable<void>): Promise<void>;

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export * from './array';
-export * from './callback';
-export * from './error';
-export * from './misc';
-export * from './number';
-export * from './object';
-export * from './string';
-export type * from './types';
+export * from "./array";
+export * from "./callback";
+export * from "./error";
+export * from "./misc";
+export * from "./number";
+export * from "./object";
+export * from "./random";
+export * from "./string";
+export type * from "./types";