@dxyl/utils 1.0.0 → 1.1.0

package/types/lodash/upper-first.d.ts

@@ -0,0 +1,2 @@
+declare const upperFirst: (value: string) => string;
+export default upperFirst;

package/types/lodash/values-of-key.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (data: any[], name: string) => any[];
+export default _default;

package/types/lodash/values.d.ts

@@ -0,0 +1,2 @@
+declare const values: (obj: any) => any[];
+export default values;

package/types/lodash/wrap-behavior.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 封装事件，便于使用上下文this,和便于解除事件时使用
+ * @protected
+ * @param  {Object} obj   对象
+ * @param  {String} action 事件名称
+ * @return {Function}        返回事件处理函数
+ */
+declare function wrapBehavior(obj: object, action: string): Function;
+export default wrapBehavior;

package/types/parse-svg-path.d.ts

@@ -0,0 +1,19 @@
+ /**
+     * Represents a single SVG path command
+     * First element is the command letter (e.g. 'M' for moveto, 'L' for lineto, etc)
+     * Remaining elements are the numeric parameters for that command
+     * @example ['M', 10, 20] // Move to x=10, y=20
+     * @example ['L', 30, 40] // Line to x=30, y=40
+     * @internal
+     */
+ export type Command = [string, ...number[]];
+
+ /**
+  * Parses an SVG path data string into an array of commands
+  * @param path - The SVG path data string to parse
+  * @returns Array of parsed commands, each containing a command letter and parameters
+  * @example
+  * parse('M10 20L30 40')
+  * // Returns: [['M', 10, 20], ['L', 30, 40]]
+  */
+ export default function parse(path: string): Command[];

package/types/priority_queue.d.ts

@@ -0,0 +1,41 @@
+export declare class PriorityQueue<T> {
+    private heap;
+    private compare;
+    /**
+     * 创建优先队列
+     * @param compare 比较函数 (a, b) => 负数表示a应排在b前面
+     */
+    constructor(compare: (a: T, b: T) => number);
+    /**
+     * 获取队列元素数量
+     */
+    get size(): number;
+    /**
+     * 判断队列是否为空
+     */
+    isEmpty(): boolean;
+    top(): T | null;
+    /**
+     * 查看队首元素
+     */
+    peek(): T | null;
+    /**
+     * 入队
+     * @param value 要添加的元素
+     */
+    enqueue(value: T): void;
+    push(value: T): void;
+    pop(): T | null;
+    /**
+     * 出队
+     * @returns 队首元素或null（空队列时）
+     */
+    dequeue(): T | null;
+    private siftUp;
+    private siftDown;
+    private swap;
+    /**
+     * 清空队列
+     */
+    clear(): void;
+}

package/types/radash/array.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Sorts an array of items into groups. The return value is a map where the keys are
+ * the group ids the given getGroupId function produced and the value is an array of
+ * each item in that group.
+ */
+export declare const group: <T, Key extends string | number | symbol>(array: readonly T[], getGroupId: (item: T) => Key) => Partial<Record<Key, T[]>>;
+/**
+ * Creates an array of grouped elements, the first of which contains the
+ * first elements of the given arrays, the second of which contains the
+ * second elements of the given arrays, and so on.
+ *
+ * Ex. const zipped = zip(['a', 'b'], [1, 2], [true, false]) // [['a', 1, true], ['b', 2, false]]
+ */
+export declare function zip<T1, T2, T3, T4, T5>(array1: T1[], array2: T2[], array3: T3[], array4: T4[], array5: T5[]): [T1, T2, T3, T4, T5][];
+export declare function zip<T1, T2, T3, T4>(array1: T1[], array2: T2[], array3: T3[], array4: T4[]): [T1, T2, T3, T4][];
+export declare function zip<T1, T2, T3>(array1: T1[], array2: T2[], array3: T3[]): [T1, T2, T3][];
+export declare function zip<T1, T2>(array1: T1[], array2: T2[]): [T1, T2][];
+/**
+ * Creates an object mapping the specified keys to their corresponding values
+ *
+ * Ex. const zipped = zipToObject(['a', 'b'], [1, 2]) // { a: 1, b: 2 }
+ * Ex. const zipped = zipToObject(['a', 'b'], (k, i) => k + i) // { a: 'a0', b: 'b1' }
+ * Ex. const zipped = zipToObject(['a', 'b'], 1) // { a: 1, b: 1 }
+ */
+export declare function zipToObject<K extends string | number | symbol, V>(keys: K[], values: V | ((key: K, idx: number) => V) | V[]): Record<K, V>;
+/**
+ * Go through a list of items, starting with the first item,
+ * and comparing with the second. Keep the one you want then
+ * compare that to the next item in the list with the same
+ *
+ * Ex. const greatest = () => boil(numbers, (a, b) => a > b)
+ */
+export declare const boil: <T>(array: readonly T[], compareFunc: (a: T, b: T) => T) => T | null;
+/**
+ * Sum all numbers in an array. Optionally provide a function
+ * to convert objects in the array to number values.
+ */
+export declare function sum<T extends number>(array: readonly T[]): number;
+export declare function sum<T extends object>(array: readonly T[], fn: (item: T) => number): number;
+/**
+ * Get the first item in an array or a default value
+ */
+export declare const first: <T>(array: readonly T[], defaultValue?: T | null | undefined) => T | null | undefined;
+/**
+ * Get the last item in an array or a default value
+ */
+export declare const last: <T>(array: readonly T[], defaultValue?: T | null | undefined) => T | null | undefined;
+/**
+ * Sort an array without modifying it and return
+ * the newly sorted value
+ */
+export declare const sort: <T>(array: readonly T[], getter: (item: T) => number, desc?: boolean) => T[];
+/**
+ * Sort an array without modifying it and return
+ * the newly sorted value. Allows for a string
+ * sorting value.
+ */
+export declare const alphabetical: <T>(array: readonly T[], getter: (item: T) => string, dir?: "asc" | "desc") => T[];
+export declare const counting: <T, TId extends string | number | symbol>(list: readonly T[], identity: (item: T) => TId) => Record<TId, number>;
+/**
+ * Replace an element in an array with a new
+ * item without modifying the array and return
+ * the new value
+ */
+export declare const replace: <T>(list: readonly T[], newItem: T, match: (item: T, idx: number) => boolean) => T[];
+/**
+ * Convert an array to a dictionary by mapping each item
+ * into a dictionary key & value
+ */
+export declare const objectify: <T, Key extends string | number | symbol, Value = T>(array: readonly T[], getKey: (item: T) => Key, getValue?: (item: T) => Value) => Record<Key, Value>;
+/**
+ * Select performs a filter and a mapper inside of a reduce,
+ * only iterating the list one time.
+ *
+ * @example
+ * select([1, 2, 3, 4], x => x*x, x > 2) == [9, 16]
+ */
+export declare const select: <T, K>(array: readonly T[], mapper: (item: T, index: number) => K, condition: (item: T, index: number) => boolean) => K[];
+/**
+ * Max gets the greatest value from a list
+ *
+ * @example
+ * max([ 2, 3, 5]) == 5
+ * max([{ num: 1 }, { num: 2 }], x => x.num) == { num: 2 }
+ */
+export declare function max(array: readonly [number, ...number[]]): number;
+export declare function max(array: readonly number[]): number | null;
+export declare function max<T>(array: readonly T[], getter: (item: T) => number): T | null;
+/**
+ * Min gets the smallest value from a list
+ *
+ * @example
+ * min([1, 2, 3, 4]) == 1
+ * min([{ num: 1 }, { num: 2 }], x => x.num) == { num: 1 }
+ */
+export declare function min(array: readonly [number, ...number[]]): number;
+export declare function min(array: readonly number[]): number | null;
+export declare function min<T>(array: readonly T[], getter: (item: T) => number): T | null;
+/**
+ * Splits a single list into many lists of the desired size. If
+ * given a list of 10 items and a size of 2, it will return 5
+ * lists with 2 items each
+ */
+export declare const cluster: <T>(list: readonly T[], size?: number) => T[][];
+/**
+ * Given a list of items returns a new list with only
+ * unique items. Accepts an optional identity function
+ * to convert each item in the list to a comparable identity
+ * value
+ */
+export declare const unique: <T, K extends string | number | symbol>(array: readonly T[], toKey?: (item: T) => K) => T[];
+/**
+ * Creates a generator that will produce an iteration through
+ * the range of number as requested.
+ *
+ * @example
+ * range(3)                  // yields 0, 1, 2, 3
+ * range(0, 3)               // yields 0, 1, 2, 3
+ * range(0, 3, 'y')          // yields y, y, y, y
+ * range(0, 3, () => 'y')    // yields y, y, y, y
+ * range(0, 3, i => i)       // yields 0, 1, 2, 3
+ * range(0, 3, i => `y${i}`) // yields y0, y1, y2, y3
+ * range(0, 3, obj)          // yields obj, obj, obj, obj
+ * range(0, 6, i => i, 2)    // yields 0, 2, 4, 6
+ */
+export declare function range<T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number): Generator<T>;
+/**
+ * Creates a list of given start, end, value, and
+ * step parameters.
+ *
+ * @example
+ * list(3)                  // 0, 1, 2, 3
+ * list(0, 3)               // 0, 1, 2, 3
+ * list(0, 3, 'y')          // y, y, y, y
+ * list(0, 3, () => 'y')    // y, y, y, y
+ * list(0, 3, i => i)       // 0, 1, 2, 3
+ * list(0, 3, i => `y${i}`) // y0, y1, y2, y3
+ * list(0, 3, obj)          // obj, obj, obj, obj
+ * list(0, 6, i => i, 2)    // 0, 2, 4, 6
+ */
+export declare const list: <T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number) => T[];
+/**
+ * Given an array of arrays, returns a single
+ * dimentional array with all items in it.
+ */
+export declare const flat: <T>(lists: readonly T[][]) => T[];
+/**
+ * Given two arrays, returns true if any
+ * elements intersect
+ */
+export declare const intersects: <T, K extends string | number | symbol>(listA: readonly T[], listB: readonly T[], identity?: (t: T) => K) => boolean;
+/**
+ * Split an array into two array based on
+ * a true/false condition function
+ */
+export declare const fork: <T>(list: readonly T[], condition: (item: T) => boolean) => [T[], T[]];
+/**
+ * Given two lists of the same type, iterate the first list
+ * and replace items matched by the matcher func in the
+ * first place.
+ */
+export declare const merge: <T>(root: readonly T[], others: readonly T[], matcher: (item: T) => any) => readonly T[];
+/**
+ * Replace an item in an array by a match function condition. If
+ * no items match the function condition, appends the new item to
+ * the end of the list.
+ */
+export declare const replaceOrAppend: <T>(list: readonly T[], newItem: T, match: (a: T, idx: number) => boolean) => T[];
+/**
+ * If the item matching the condition already exists
+ * in the list it will be removed. If it does not it
+ * will be added.
+ */
+export declare const toggle: <T>(list: readonly T[], item: T, 
+/**
+ * Converts an item of type T item into a value that
+ * can be checked for equality
+ */
+toKey?: null | ((item: T, idx: number) => number | string | symbol), options?: {
+    strategy?: "prepend" | "append";
+}) => T[];
+type Falsy = null | undefined | false | '' | 0 | 0n;
+/**
+ * Given a list returns a new list with
+ * only truthy values
+ */
+export declare const sift: <T>(list: readonly (T | Falsy)[]) => T[];
+/**
+ * Like a reduce but does not require an array.
+ * Only need a number and will iterate the function
+ * as many times as specified.
+ *
+ * NOTE: This is NOT zero indexed. If you pass count=5
+ * you will get 1, 2, 3, 4, 5 iteration in the callback
+ * function
+ */
+export declare const iterate: <T>(count: number, func: (currentValue: T, iteration: number) => T, initValue: T) => T;
+/**
+ * Returns all items from the first list that
+ * do not exist in the second list.
+ */
+export declare const diff: <T>(root: readonly T[], other: readonly T[], identity?: (item: T) => string | number | symbol) => T[];
+/**
+ * Shift array items by n steps
+ * If n > 0 items will shift n steps to the right
+ * If n < 0 items will shift n steps to the left
+ */
+export declare function shift<T>(arr: Array<T>, n: number): T[];
+export {};

package/types/radash/async.d.ts

@@ -0,0 +1,99 @@
+/**
+ * An async reduce function. Works like the
+ * built-in Array.reduce function but handles
+ * an async reducer function
+ */
+export declare const reduce: <T, K>(array: readonly T[], asyncReducer: (acc: K, item: T, index: number) => Promise<K>, initValue?: K) => Promise<K>;
+/**
+ * An async map function. Works like the
+ * built-in Array.map function but handles
+ * an async mapper function
+ */
+export declare const map: <T, K>(array: readonly T[], asyncMapFunc: (item: T, index: number) => Promise<K>) => Promise<K[]>;
+/**
+ * Useful when for script like things where cleanup
+ * should be done on fail or sucess no matter.
+ *
+ * You can call defer many times to register many
+ * defered functions that will all be called when
+ * the function exits in any state.
+ */
+export declare const defer: <TResponse>(func: (register: (fn: (error?: any) => any, options?: {
+    rethrow?: boolean;
+}) => void) => Promise<TResponse>) => Promise<TResponse>;
+/**
+ * Support for the built-in AggregateError
+ * is still new. Node < 15 doesn't have it
+ * so patching here.
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError#browser_compatibility
+ */
+export declare class AggregateError extends Error {
+    errors: Error[];
+    constructor(errors?: Error[]);
+}
+/**
+ * Executes many async functions in parallel. Returns the
+ * results from all functions as an array. After all functions
+ * have resolved, if any errors were thrown, they are rethrown
+ * in an instance of AggregateError
+ */
+export declare const parallel: <T, K>(limit: number, array: readonly T[], func: (item: T) => Promise<K>) => Promise<K[]>;
+type PromiseValues<T extends Promise<any>[]> = {
+    [K in keyof T]: T[K] extends Promise<infer U> ? U : never;
+};
+/**
+ * Functionally similar to Promise.all or Promise.allSettled. If any
+ * errors are thrown, all errors are gathered and thrown in an
+ * AggregateError.
+ *
+ * @example
+ * const [user] = await all([
+ *   api.users.create(...),
+ *   s3.buckets.create(...),
+ *   slack.customerSuccessChannel.sendMessage(...)
+ * ])
+ */
+export declare function all<T extends [Promise<any>, ...Promise<any>[]]>(promises: T): Promise<PromiseValues<T>>;
+export declare function all<T extends Promise<any>[]>(promises: T): Promise<PromiseValues<T>>;
+/**
+ * Functionally similar to Promise.all or Promise.allSettled. If any
+ * errors are thrown, all errors are gathered and thrown in an
+ * AggregateError.
+ *
+ * @example
+ * const { user } = await all({
+ *   user: api.users.create(...),
+ *   bucket: s3.buckets.create(...),
+ *   message: slack.customerSuccessChannel.sendMessage(...)
+ * })
+ */
+export declare function all<T extends Record<string, Promise<any>>>(promises: T): Promise<{
+    [K in keyof T]: Awaited<T[K]>;
+}>;
+/**
+ * Retries the given function the specified number
+ * of times.
+ */
+export declare const retry: <TResponse>(options: {
+    times?: number;
+    delay?: number | null;
+    backoff?: (count: number) => number;
+}, func: (exit: (err: any) => void) => Promise<TResponse>) => Promise<TResponse>;
+/**
+ * Async wait
+ */
+export declare const sleep: (milliseconds: number) => Promise<unknown>;
+/**
+ * A helper to try an async function without forking
+ * the control flow. Returns an error first callback _like_
+ * array response as [Error, result]
+ */
+export declare const tryit: <Args extends any[], Return>(func: (...args: Args) => Return) => (...args: Args) => Return extends Promise<any> ? Promise<[Error, undefined] | [undefined, Awaited<Return>]> : [Error, undefined] | [undefined, Return];
+/**
+ * A helper to try an async function that returns undefined
+ * if it fails.
+ *
+ * e.g. const result = await guard(fetchUsers)() ?? [];
+ */
+export declare const guard: <TFunction extends () => any>(func: TFunction, shouldGuard?: (err: any) => boolean) => ReturnType<TFunction> extends Promise<any> ? Promise<Awaited<ReturnType<TFunction>> | undefined> : ReturnType<TFunction> | undefined;
+export {};

package/types/radash/curry.d.ts

@@ -0,0 +1,113 @@
+export declare function chain<T1 extends any[], T2, T3>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3): (...arg: T1) => T3;
+export declare function chain<T1 extends any[], T2, T3, T4>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4): (...arg: T1) => T4;
+export declare function chain<T1 extends any[], T2, T3, T4, T5>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5): (...arg: T1) => T5;
+export declare function chain<T1 extends any[], T2, T3, T4, T5, T6>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6): (...arg: T1) => T6;
+export declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7): (...arg: T1) => T7;
+export declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8): (...arg: T1) => T8;
+export declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9): (...arg: T1) => T9;
+export declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9, f9: (arg: T3) => T10): (...arg: T1) => T10;
+export declare function chain<T1 extends any[], T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(f1: (...arg: T1) => T2, f2: (arg: T2) => T3, f3: (arg: T3) => T4, f4: (arg: T3) => T5, f5: (arg: T3) => T6, f6: (arg: T3) => T7, f7: (arg: T3) => T8, f8: (arg: T3) => T9, f9: (arg: T3) => T10, f10: (arg: T3) => T11): (...arg: T1) => T11;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], LastResult>(f1: (next: (...args: F1NextArgs) => LastResult) => (...args: F1Args) => F1Result, last: (...args: F1NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2Result, F2NextArgs extends any[], LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => LastResult) => (...args: F1NextArgs) => F2Result, last: (...args: F2NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => LastResult) => (...args: F2NextArgs) => F3Result, last: (...args: F3NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => LastResult) => (...args: F3NextArgs) => F4Result, last: (...args: F4NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => LastResult) => (...args: F4NextArgs) => F5Result, last: (...args: F5NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => LastResult) => (...args: F5NextArgs) => F6Result, last: (...args: F6NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, last: (...args: F7NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, F8NextArgs extends any[], F8Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, f8: (next: (...args: F8NextArgs) => LastResult) => (...args: F7NextArgs) => F8Result, last: (...args: F8NextArgs) => LastResult): (...args: F1Args) => F1Result;
+export declare function compose<F1Result, F1Args extends any[], F1NextArgs extends any[], F2NextArgs extends any[], F2Result, F3NextArgs extends any[], F3Result, F4NextArgs extends any[], F4Result, F5NextArgs extends any[], F5Result, F6NextArgs extends any[], F6Result, F7NextArgs extends any[], F7Result, F8NextArgs extends any[], F8Result, F9NextArgs extends any[], F9Result, LastResult>(f1: (next: (...args: F1NextArgs) => F2Result) => (...args: F1Args) => F1Result, f2: (next: (...args: F2NextArgs) => F3Result) => (...args: F1NextArgs) => F2Result, f3: (next: (...args: F3NextArgs) => F4Result) => (...args: F2NextArgs) => F3Result, f4: (next: (...args: F4NextArgs) => F5Result) => (...args: F3NextArgs) => F4Result, f5: (next: (...args: F5NextArgs) => F6Result) => (...args: F4NextArgs) => F5Result, f6: (next: (...args: F6NextArgs) => F7Result) => (...args: F5NextArgs) => F6Result, f7: (next: (...args: F7NextArgs) => LastResult) => (...args: F6NextArgs) => F7Result, f8: (next: (...args: F8NextArgs) => LastResult) => (...args: F7NextArgs) => F8Result, f9: (next: (...args: F9NextArgs) => LastResult) => (...args: F8NextArgs) => F9Result, last: (...args: F9NextArgs) => LastResult): (...args: F1Args) => F1Result;
+/**
+ * This type produces the type array of TItems with all the type items
+ * in TItemsToRemove removed from the start of the array type.
+ *
+ * @example
+ * ```
+ * RemoveItemsInFront<[number, number], [number]> = [number]
+ * RemoveItemsInFront<[File, number, string], [File, number]> = [string]
+ * ```
+ */
+type RemoveItemsInFront<TItems extends any[], TItemsToRemove extends any[]> = TItems extends [...TItemsToRemove, ...infer TRest] ? TRest : TItems;
+export declare const partial: <T extends any[], TA extends Partial<T>, R>(fn: (...args: T) => R, ...args: TA) => (...rest: RemoveItemsInFront<T, TA>) => R;
+/**
+ * Like partial but for unary functions that accept
+ * a single object argument
+ */
+export declare const partob: <T, K, PartialArgs extends Partial<T>>(fn: (args: T) => K, argobj: PartialArgs) => (restobj: Omit<T, keyof PartialArgs>) => K;
+/**
+ * Creates a Proxy object that will dynamically
+ * call the handler argument when attributes are
+ * accessed
+ */
+export declare const proxied: <T, K>(handler: (propertyName: T) => K) => Record<string, K>;
+/**
+ * Creates a memoized function. The returned function
+ * will only execute the source function when no value
+ * has previously been computed. If a ttl (milliseconds)
+ * is given previously computed values will be checked
+ * for expiration before being returned.
+ */
+export declare const memo: <TArgs extends any[], TResult>(func: (...args: TArgs) => TResult, options?: {
+    key?: (...args: TArgs) => string;
+    ttl?: number;
+}) => (...args: TArgs) => TResult;
+export type DebounceFunction<TArgs extends any[]> = {
+    (...args: TArgs): void;
+    /**
+     * Cancels the debounced function
+     */
+    cancel(): void;
+    /**
+     * Checks if there is any invocation debounced
+     */
+    isPending(): boolean;
+    /**
+     * Runs the debounced function immediately
+     */
+    flush(...args: TArgs): void;
+};
+export type ThrottledFunction<TArgs extends any[]> = {
+    (...args: TArgs): void;
+    /**
+     * Checks if there is any invocation throttled
+     */
+    isThrottled(): boolean;
+};
+/**
+ * Given a delay and a function returns a new function
+ * that will only call the source function after delay
+ * milliseconds have passed without any invocations.
+ *
+ * The debounce function comes with a `cancel` method
+ * to cancel delayed `func` invocations and a `flush`
+ * method to invoke them immediately
+ */
+export declare const debounce: <TArgs extends any[]>({ delay }: {
+    delay: number;
+}, func: (...args: TArgs) => any) => DebounceFunction<TArgs>;
+/**
+ * Given an interval and a function returns a new function
+ * that will only call the source function if interval milliseconds
+ * have passed since the last invocation
+ */
+export declare const throttle: <TArgs extends any[]>({ interval }: {
+    interval: number;
+}, func: (...args: TArgs) => any) => ThrottledFunction<TArgs>;
+/**
+ * Make an object callable. Given an object and a function
+ * the returned object will be a function with all the
+ * objects properties.
+ *
+ * @example
+ * ```typescript
+ * const car = callable({
+ *   wheels: 2
+ * }, self => () => {
+ *   return 'driving'
+ * })
+ *
+ * car.wheels // => 2
+ * car() // => 'driving'
+ * ```
+ */
+export declare const callable: <TValue, TObj extends Record<string | number | symbol, TValue>, TFunc extends (...args: any) => any>(obj: TObj, fn: (self: TObj) => TFunc) => TObj & TFunc;
+export {};

package/types/radash/index.d.ts

@@ -0,0 +1,10 @@
+export { alphabetical, boil, cluster, counting, diff, first, flat, fork, group, intersects, iterate, last, list, max, merge, min, objectify, range, replace, replaceOrAppend, select, shift, sift, sort, sum, toggle, unique, zip, zipToObject } from './array';
+export { all, defer, guard, map, parallel, reduce, retry, sleep, tryit as try, tryit } from './async';
+export type { AggregateError } from './async';
+export { callable, chain, compose, debounce, memo, partial, partob, proxied, throttle } from './curry';
+export { inRange, toFloat, toInt } from './number';
+export { assign, clone, construct, crush, get, invert, keys, listify, lowerize, mapEntries, mapKeys, mapValues, omit, pick, set, shake, upperize } from './object';
+export { draw, random, shuffle, uid } from './random';
+export { series } from './series';
+export { camel, capitalize, dash, pascal, snake, template, title, trim } from './string';
+export { isArray, isDate, isEmpty, isEqual, isFloat, isFunction, isInt, isNumber, isObject, isPrimitive, isPromise, isString, isSymbol } from './typed';

package/types/radash/number.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if the given number is between zero (0) and the ending number. 0 is inclusive.
+ *
+ * * Numbers can be negative or positive.
+ * * Ending number is exclusive.
+ *
+ * @param {number} number The number to check.
+ * @param {number} end The end of the range. Exclusive.
+ * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
+ */
+export declare function inRange(number: number, end: number): boolean;
+/**
+ * Checks if the given number is between two numbers.
+ *
+ * * Numbers can be negative or positive.
+ * * Starting number is inclusive.
+ * * Ending number is exclusive.
+ * * The start and the end of the range can be ascending OR descending order.
+ *
+ * @param {number} number The number to check.
+ * @param {number} start The start of the range. Inclusive.
+ * @param {number} end The end of the range. Exclusive.
+ * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
+ */
+export declare function inRange(number: number, start: number, end: number): boolean;
+export declare const toFloat: <T extends number | null = number>(value: any, defaultValue?: T) => number | T;
+export declare const toInt: <T extends number | null = number>(value: any, defaultValue?: T) => number | T;

package/types/radash/object.d.ts

@@ -0,0 +1,112 @@
+type LowercasedKeys<T extends Record<string, any>> = {
+    [P in keyof T & string as Lowercase<P>]: T[P];
+};
+type UppercasedKeys<T extends Record<string, any>> = {
+    [P in keyof T & string as Uppercase<P>]: T[P];
+};
+/**
+ * Removes (shakes out) undefined entries from an
+ * object. Optional second argument shakes out values
+ * by custom evaluation.
+ */
+export declare const shake: <RemovedKeys extends string, T>(obj: T, filter?: (value: any) => boolean) => Omit<T, RemovedKeys>;
+/**
+ * Map over all the keys of an object to return
+ * a new object
+ */
+export declare const mapKeys: <TValue, TKey extends string | number | symbol, TNewKey extends string | number | symbol>(obj: Record<TKey, TValue>, mapFunc: (key: TKey, value: TValue) => TNewKey) => Record<TNewKey, TValue>;
+/**
+ * Map over all the keys to create a new object
+ */
+export declare const mapValues: <TValue, TKey extends string | number | symbol, TNewValue>(obj: Record<TKey, TValue>, mapFunc: (value: TValue, key: TKey) => TNewValue) => Record<TKey, TNewValue>;
+/**
+ * Map over all the keys to create a new object
+ */
+export declare const mapEntries: <TKey extends string | number | symbol, TValue, TNewKey extends string | number | symbol, TNewValue>(obj: Record<TKey, TValue>, toEntry: (key: TKey, value: TValue) => [TNewKey, TNewValue]) => Record<TNewKey, TNewValue>;
+/**
+ * Returns an object with { [keys]: value }
+ * inverted as { [value]: key }
+ */
+export declare const invert: <TKey extends string | number | symbol, TValue extends string | number | symbol>(obj: Record<TKey, TValue>) => Record<TValue, TKey>;
+/**
+ * Convert all keys in an object to lower case
+ */
+export declare const lowerize: <T extends Record<string, any>>(obj: T) => LowercasedKeys<T>;
+/**
+ * Convert all keys in an object to upper case
+ */
+export declare const upperize: <T extends Record<string, any>>(obj: T) => UppercasedKeys<T>;
+/**
+ * Creates a shallow copy of the given obejct/value.
+ * @param {*} obj value to clone
+ * @returns {*} shallow clone of the given value
+ */
+export declare const clone: <T>(obj: T) => T;
+/**
+ * Convert an object to a list, mapping each entry
+ * into a list item
+ */
+export declare const listify: <TValue, TKey extends string | number | symbol, KResult>(obj: Record<TKey, TValue>, toItem: (key: TKey, value: TValue) => KResult) => KResult[];
+/**
+ * Pick a list of properties from an object
+ * into a new object
+ */
+export declare const pick: <T extends object, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Pick<T, TKeys>;
+/**
+ * Omit a list of properties from an object
+ * returning a new object with the properties
+ * that remain
+ */
+export declare const omit: <T, TKeys extends keyof T>(obj: T, keys: TKeys[]) => Omit<T, TKeys>;
+/**
+ * Dynamically get a nested value from an array or
+ * object with a string.
+ *
+ * @example get(person, 'friends[0].name')
+ */
+export declare const get: <TDefault = unknown>(value: any, path: string, defaultValue?: TDefault) => TDefault;
+/**
+ * Opposite of get, dynamically set a nested value into
+ * an object using a key path. Does not modify the given
+ * initial object.
+ *
+ * @example
+ * set({}, 'name', 'ra') // => { name: 'ra' }
+ * set({}, 'cards[0].value', 2) // => { cards: [{ value: 2 }] }
+ */
+export declare const set: <T extends object, K>(initial: T, path: string, value: K) => T;
+/**
+ * Merges two objects together recursivly into a new
+ * object applying values from right to left.
+ * Recursion only applies to child object properties.
+ */
+export declare const assign: <X extends Record<string | symbol | number, any>>(initial: X, override: X) => X;
+/**
+ * Get a string list of all key names that exist in
+ * an object (deep).
+ *
+ * @example
+ * keys({ name: 'ra' }) // ['name']
+ * keys({ name: 'ra', children: [{ name: 'hathor' }] }) // ['name', 'children.0.name']
+ */
+export declare const keys: <TValue extends object>(value: TValue) => string[];
+/**
+ * Flattens a deep object to a single demension, converting
+ * the keys to dot notation.
+ *
+ * @example
+ * crush({ name: 'ra', children: [{ name: 'hathor' }] })
+ * // { name: 'ra', 'children.0.name': 'hathor' }
+ */
+export declare const crush: <TValue extends object>(value: TValue) => object;
+/**
+ * The opposite of crush, given an object that was
+ * crushed into key paths and values will return
+ * the original object reconstructed.
+ *
+ * @example
+ * construct({ name: 'ra', 'children.0.name': 'hathor' })
+ * // { name: 'ra', children: [{ name: 'hathor' }] }
+ */
+export declare const construct: <TObject extends object>(obj: TObject) => object;
+export {};