@1k/shared v0.1.19

@1k/shared

types

type Task = () => void;
type Asap = (task: Task) => void;
const always: <const V>(value: V) => () => V;
const asap: (task: Task) => void;
const at: <T>(list: Readonly<ArrayLike<T>>, n: number) => T | undefined;
const attempt: <A extends unknown[], R>(func: (...args: A) => R, ...args: A) => Error | R;
const camelCase: (input: string) => string;
const capitalCase: (input: string) => string;
const capitalize: (str: string) => string;
const ceil: (n: number, precision?: number | undefined) => number;
const chunk: <T>(array: Readonly<ArrayLike<T>>, size?: number) => T[][];
const clamp: (num: number, lower: number, upper: number) => number;
const constCase: (input: string) => string;
const dashCase: (input: string) => string;
type Debounce = <A extends unknown[], R = unknown, Me = unknown>(function_: (this: Me, ...arguments_: A) => R, wait?: number, options?: {
    immediate: boolean;
} | boolean) => DebouncedFunction<A, R, Me>;
const debounce: Debounce;
type DebouncedFunction<A extends unknown[], R = unknown, Me = unknown> = {
    (this: Me, ...arguments_: A): R | undefined;
    clear(): void;
    flush(): void;
};
type Defaults<O, A extends readonly unknown[]> = number extends A['length'] ? DefaultsSet<O, A[number]> : A extends [infer L, ...infer Rest] ? Defaults<DefaultsSet<O, L>, Rest> : O;
const defaults: <const O extends Record<K, V>, const A extends S[], const S extends Record<K, V>, const V, K extends PropertyKey = PropertyKey, R extends Defaults<O, A> = Defaults<O, A>>(target: O, ...sources: Readonly<A>) => R;
type DefaultsSet<O, S> = O extends object ? S extends object ? {
    [k in keyof O | keyof S]: k extends keyof O ? k extends keyof S ? O[k] extends undefined ? S[k] : O[k] : O[k] : k extends keyof S ? S[k] : never;
} : {
    [k in keyof O]: O[k];
} : never;
const dotCase: (input: string) => string;
const drop: <T>(list: Readonly<ArrayLike<T>>, n?: number) => T[];
const dropLast: <T>(list: Readonly<ArrayLike<T>>, n?: number) => T[];
const dropLastWhile: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean) => T[];
const dropWhile: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean) => T[];
const endsWith: (input: string, suffix: string, position?: number) => boolean;
const entries: <K extends string = string, V = unknown>(obj: Record<K, V>) => [K, V][];
const every: <T extends V, V = unknown>(arr: readonly T[], predicate: (v: V, i: number, list: readonly V[]) => boolean) => boolean;
const F: () => false;
const filter: <T extends V, V = unknown>(array: T[], fn: (v: V, i: number, list: V[]) => boolean) => T[];
const find: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean, fromIndex?: number) => T | undefined;
const findIndex: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean, fromIndex?: number) => number;
const findLast: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, list: Readonly<ArrayLike<V>>) => boolean, fromIndex?: number) => T | undefined;
const findLastIndex: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean, fromIndex?: number) => number;
const first: <T>(list: Readonly<ArrayLike<T>>) => T | undefined;
const floor: (n: number, precision?: number | undefined) => number;
const forEach: <A extends ArrayLike<V>, V = A[number]>(list: Readonly<A>, cb: (v: V, i: number, a: ArrayLike<V>) => void, fromIndex?: number, end?: A["length"]) => A;
const forEachRight: <A extends ArrayLike<V>, V = A[number]>(list: Readonly<A>, cb: (v: V, i: number, a: ArrayLike<V>) => void, fromIndex?: number, endIndex?: number) => A;
const forIn: <O extends Record<PropertyKey, V>, V = O[keyof O]>(obj: O, cb: (v: V, i: keyof O & string, a: O) => void) => O;
const fork: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, condition: (item: V, index: number, list: Readonly<ArrayLike<V>>) => boolean) => [T[], T[]];
const forOwn: <O extends Record<PropertyKey, V>, V = O[keyof O]>(obj: O, cb: (v: V, i: keyof O, a: O) => void) => O;
const groupBy: <T extends V, V = unknown, K extends PropertyKey = PropertyKey>(list: Readonly<ArrayLike<T>>, iteratee: (v: V, index: number, list: Readonly<ArrayLike<V>>) => K) => Partial<Record<K, T[]>>;
const hasOwn: <O extends object, K extends string>(obj: O, key: K) => key is K & keyof O;
const inArray: <T, V>(list: Readonly<ArrayLike<T>>, value: V) => boolean;
const indexOf: <T, V>(list: Readonly<ArrayLike<T>>, value: V, fromIndex?: number) => number;
type Invert<O extends Record<keyof O, PropertyKey>> = O extends unknown ? _Invert<O> : never;
const invert: <O extends Record<keyof O, PropertyKey>>(object: Readonly<O>) => Invert<O>;
const isArray: <T>(x: unknown) => x is T[];
const isArrayLike: (value: unknown) => value is ArrayLike<unknown>;
const isBoolean: (x: unknown) => x is boolean;
const isDate: (it: unknown) => it is Date;
const isDefined: <T>(value: T) => value is Exclude<T, undefined>;
const isError: (x: unknown) => x is Error;
const isFalsy: <T>(x: T) => x is T & FalsyValue;
const isFinite_2: (value: unknown) => value is number;
export { isFinite_2 as isFinite }
const isFunction: (x: unknown) => x is Function;
const isInteger: (it: unknown) => it is number;
const isLength: (value: unknown) => value is number;
const isMap: <K, V>(it: unknown) => it is Map<K, V>;
const isMapLike: (it: unknown) => it is Pick<Map<unknown, unknown>, "get" | "set" | "has" | "clear">;
const isNaN_2: (x: unknown) => boolean;
export { isNaN_2 as isNaN }
const isNative: (x: unknown) => x is Function;
const isNil: (x: unknown) => x is null | undefined;
const isNull: (x: unknown) => x is null;
const isNumber: (v: unknown) => v is number;
const isNumeric: (x: unknown) => x is number | `${number}`;
const isObjectLike: (value: unknown) => value is object;
const isPlainObject: (v: unknown) => v is object;
const isPrimitive: (x: unknown) => x is string | number | bigint | boolean | symbol | null | undefined;
const isPromise: (it: unknown) => it is Promise<unknown>;
const isPromiseLike: (x: unknown) => x is PromiseLike<unknown>;
const isRegExp: <T>(value: T) => value is T & RegExp;
const isSafeInteger: (value: unknown) => value is number;
const isScalar: (x: unknown) => x is string | number | boolean;
const isSet: <T>(it: unknown) => it is Set<T>;
const isString: (v: unknown) => v is string;
const isSymbol: (value: unknown) => value is symbol;
const isThenable: (x: unknown) => x is PromiseLike<unknown>;
const isTruthy: <T>(x: T) => x is Exclude<T, FalsyValue>;
const isUndefined: (v: unknown) => v is undefined;
const keys: <T>(x: T) => string[];
const keysIn: <T>(x: T) => (keyof T & string)[];
type KindMap = {
    Array: unknown[];
    ArrayBuffer: ArrayBuffer;
    Arguments: IArguments;
    BigInt64Array: BigInt64Array;
    BigUint64Array: BigUint64Array;
    Boolean: boolean | Boolean;
    Date: Date;
    Float32Array: Float32Array;
    Float64Array: Float64Array;
    Function: Function;
    Int16Array: Int16Array;
    Int32Array: Int32Array;
    Int8Array: Int8Array;
    Map: Map<unknown, unknown>;
    Null: null;
    Number: number | Number;
    Promise: Promise<unknown>;
    RegExp: RegExp;
    Set: Set<unknown>;
    String: string | String;
    Uint16Array: Uint16Array;
    Uint32Array: Uint32Array;
    Uint8Array: Uint8Array;
    Uint8ClampedArray: Uint8ClampedArray;
    Undefined: undefined;
    WeakMap: WeakMap<object, unknown>;
    WeakSet: WeakSet<object>;
};
type KindOf<V, O extends object = KindMap> = V extends O[keyof O] ? {
    [k in keyof O]: V extends O[k] ? k : never;
}[keyof O] : string;
const kindOf: <V>(v: V) => KindOf<V, KindMap>;
const last: <T>(list: Readonly<ArrayLike<T>>) => T | undefined;
const map: <T extends V, R, V = unknown>(list: readonly T[], fn: (v: V, i: number, list: Readonly<ArrayLike<V>>) => R) => R[];
const o: <R2, R1, T>(f: (b: R1) => R2, g: (a: T) => R1) => (a: T) => R2;
const omit: <O extends Record<K, unknown>, K extends string = string>(it: O, names: K | K[]) => OmitUnion<O, K>;
const omitBy: <O extends T, V = unknown, K extends string = string, T extends Record<K, V> = Record<K, V>>(obj: Readonly<O>, predicate: (v: V, k: K, o: Readonly<T>) => boolean) => Partial<O>;
type OmitUnion<T, K extends PropertyKey> = T extends void ? never : Pick<T, Exclude<keyof T, Extract<keyof T, K>>>;
const pad: (input: string, length: number, chars?: string) => string;
const padEnd: (input: string, length: number, chars?: string) => string;
const padStart: (input: string, length: number, chars?: string) => string;
const pascalCase: (input: string) => string;
const pathCase: (input: string) => string;
const pick: <T extends Record<K, unknown>, K extends PropertyKey = PropertyKey>(obj: T, names: K[]) => PickUnion<T, K>;
const pickBy: <O extends T, V = unknown, K extends string = string, T extends Record<K, V> = Record<K, V>>(obj: Readonly<O>, predicate: (v: V, k: K, o: Readonly<T>) => boolean) => Partial<O>;
type PickUnion<T, K extends PropertyKey> = T extends unknown ? Pick<T, Extract<keyof T, K>> : never;
type Pluck<A extends readonly unknown[], K, R extends readonly unknown[]> = A['length'] extends 0 ? R : A['length'] extends 1 ? Push<R, Prop<A[0], K>> : A extends readonly [infer T, ...infer Rest] ? Pluck<Rest, K, Push<R, Prop<T, K>>> : (R[number] | Prop<A[number], K>)[];
const pluck: <const A extends Readonly<[O] | O[]>, K extends PropertyKey, const O extends Partial<Record<K, V>>, V = unknown>(list: A, key: K) => Pluck<A, K, []>;
type Prop<O, P> = P extends keyof O ? O[P] : undefined;
const prop: <const O extends Partial<Record<K, V>>, const K extends PropertyKey, V = unknown>(obj: O, name: K) => Prop<O, K>;
type Props<O, PS extends readonly unknown[], Res extends readonly unknown[] = []> = number extends PS['length'] ? Prop<O, PS[number]>[] : PS extends readonly [] ? Res : PS extends readonly [infer K] ? Push<Res, Prop<O, K>> : PS extends readonly [infer P, ...infer Rest] ? Props<O, Rest, Push<Res, Prop<O, P>>> : Push<Res, Prop<O, PS[number]>>;
const props: <const O extends Partial<Record<K, V>>, const A extends [K] | K[], const V, K extends PropertyKey = PropertyKey>(obj: O, names: Readonly<A>) => Props<O, A, []>;
type Push<A extends readonly unknown[], T> = number extends A['length'] ? (A[number] | T)[] : [...A, T];
const reject: <T extends V, V = unknown>(list: T[], condition: (item: V, index: number, list: readonly V[]) => boolean) => T[];
const round: (n: number, precision?: number | undefined) => number;
const shake: <O extends Record<string, T>, T extends V, V = undefined>(obj: Readonly<O>, predicate?: (value: V, k: string, O: Readonly<Record<string, V>>) => boolean) => Partial<O>;
const snakeCase: (input: string) => string;
const some: <T extends V, V = unknown>(list: readonly T[], predicate: (v: V, i: number, list: Readonly<ArrayLike<V>>) => boolean) => boolean;
const startsWith: (input: string, prefix: string, position?: number) => boolean;
const swapCase: (input: string) => string;
const T: () => true;
const take: <T>(list: Readonly<ArrayLike<T>>, n?: number) => T[];
const takeLast: <T>(list: Readonly<ArrayLike<T>>, n?: number) => T[];
const takeLastWhile: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean) => T[];
const takeWhile: <T extends V, V = unknown>(list: Readonly<ArrayLike<T>>, predicate: (v: V, i: number, a: Readonly<ArrayLike<V>>) => boolean) => T[];
const throttle: <F extends (...args: unknown[]) => unknown>(fn: F, wait: number) => (...args: Parameters<F>) => void;
const times: Times;
const titleCase: (input: string) => string;
const toFinite: (value: unknown) => number;
const toInteger: (value: unknown) => number;
const toLength: (value: unknown) => number;
const toLower: (str: string) => string;
const toNumber: (value: unknown) => number;
const toSafeInteger: (value: unknown) => number;
const toUpper: (str: string) => string;
const trim: (input: string, chars?: string | RegExp, strictMode?: boolean) => string;
const trimEnd: (input: string, chars?: string | RegExp | ((c: string) => boolean) | undefined, strictMode?: boolean) => string;
const trimStart: (input: string, chars?: string | RegExp | ((c: string) => boolean) | undefined, strictMode?: boolean) => string;
const trunc: (x: number) => number;
const truncate: (input: string, length?: number, end?: string) => string;
const tryRun: <R, R2 = undefined>(fn: () => R, defVal?: R2 | undefined) => R | R2 | undefined;
const values: <K extends string = string, V = unknown>(obj: Record<K, V>) => V[];