@1k/shared

types

``ts
const eq: (value: T, other?: unknown) => other is T;

const kindOf: (thing: T) => string;

const isArguments: (it?: unknown) => it is IArguments;

const isArray: (it: unknown) => it is T[];

const isArrayBuffer: (value?: unknown) => value is ArrayBuffer;

const isArrayBufferView: (it: unknown) => it is ArrayBufferView;

const isArrayLike: (value: unknown) => value is ArrayLike;

const isArrayLikeObject: (value: unknown) => value is ArrayLike & object;

const isBigInt: (it: unknown) => it is bigint;

const isBlob: (x: unknown) => x is Blob;

const isBoolean: (x: unknown) => x is boolean;

const isDate: (x: unknown) => x is Date;

const isDefined: (it: T | undefined) => it is Exclude;

const isError: (x: unknown) => x is Error;

const isEven: (x: unknown) => x is number;

type Falsy = T & (false | 0 | 0n | '' | null | undefined);

const isFalsy: (x: T) => x is Falsy;

const isFile: (x: unknown) => x is File;

const isFinite: (n: unknown) => n is number;

const isFunction: (value: unknown) => value is Function;

const isInteger: (n: unknown) => n is number;

type JsonValue = string | number | boolean | null | JsonObject | JsonArray;

type JsonArray = JsonValue[];

type JsonObject = {
[key: string]: JsonValue;
};

type EqualityComparer = (a: T, b: U) => boolean;

function isJsonValue(value: unknown): value is JsonValue;

function isJsonArray(value: unknown): value is JsonArray;

function isJsonObject(obj: unknown): obj is JsonObject;

const isLength: (value: unknown) => value is number;

const isMap: (it: unknown) => it is Map;

const isNil: (it: unknown) => it is null | undefined;

type NAN = typeof NaN;

const isNaN: (x: unknown) => x is NAN;

const isNative: (value: unknown) => value is Function;

function isNegative(it: N): it is number & N;

const isNull: (x: unknown) => x is null;

const isNumber: (v: unknown) => v is number;

const isNumeric: (n: unknown) => n is string | number;

const isObject: (it: unknown) => it is Record;

function isObjectLike(value: unknown): value is object;

const isOdd: (x: unknown) => x is number;

const isPlainObject: (value: unknown) => value is Record;

function isPositive(it: N): it is number & N;

const isPresent: (it: T | null | undefined) => it is NonNullable;

const isPrimitive: (value: unknown) => value is null | undefined | string | number | boolean | symbol | bigint;

type Printable = string | number | boolean | bigint | null | undefined;

const isPrintable: (x: unknown) => x is Printable;

const isPromise: (it: unknown) => it is Promise;

const isPromiseLike: (x: unknown) => x is PromiseLike;

const isRegExp: (x: T) => x is T & RegExp;

const isSafeInteger: (n: unknown) => n is number;

const isScalar: (it: unknown) => it is string | number | boolean;

const isSet: (it: unknown) => it is Set;

const isString: (it: unknown) => it is string;

const isSymbol: (it: unknown) => it is symbol;

type Truthy = Exclude;

const isTruthy: (it: T) => it is Truthy;

const isTypedArray: (x: unknown) => x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array;

const isUndefined: (it: unknown) => it is undefined;

const isUrlSearchParams: (x: unknown) => x is URLSearchParams;

const isWeakMap: (value: unknown) => value is WeakMap;

const isWeakSet: (value: unknown) => value is WeakSet;

const isWellFormed: (str: string) => boolean;

const isWindow: (it: unknown) => it is Window;

const now: () => number;

const chunk: (arr: readonly T[], size: number) => T[][];

const compact: (arr: ArrayLike) => Truthy[];

const countBy: (
list: ArrayLike, getKey: (item: T, i: number, list: ArrayLike) => K) => Record;

const drop: (arr: readonly T[], itemsCount: number) => T[];

const dropLast: (arr: readonly T[], itemsCount: number) => T[];

const dropLastWhile: (
list: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => boolean) => T[];

const dropWhile: (arr: readonly T[], canContinueDropping: (item: T, index: number, arr: readonly T[]) => boolean) => T[];

function fill(array: unknown[], value: T): T[];
function fill(array: Array, value: U, start: number): Array;
function fill(array: Array, value: U, start: number, end: number): Array;

function first(arr: readonly [T, ...T[]]): T;
function first(arr: readonly T[]): T | undefined;

const groupBy: (
list: ArrayLike, getKeyFromItem: (item: T, i: number, list: ArrayLike) => K) => Record;

interface Partition {
(
list: ArrayLike, isTruthy: (item: U, i: number, list: ArrayLike) => item is T): [truthy: T[], falsy: Exclude[]];

(
list: ArrayLike, isTruthy: (item: T, i: number, list: ArrayLike) => boolean): [truthy: T[], falsy: T[]];

}
const partition: Partition;

const keyBy: (
list: ArrayLike, getKeyFromItem: (item: T, i: number, list: ArrayLike) => K) => Record;

function last(arr: readonly [...T[], T]): T;
function last(arr: readonly T[]): T | undefined;

function maxBy(items: readonly [T, ...T[]], getValue: (el: T, i: number, items: ArrayLike) => number): T;

function maxBy(items: ArrayLike, getValue: (el: T, i: number, items: ArrayLike) => number): T | undefined;

function minBy(items: readonly [T, ...T[]], getValue: (el: T, i: number, items: ArrayLike) => number): T;

function minBy(items: ArrayLike, getValue: (el: T, i: number, items: ArrayLike) => number): T | undefined;

const sample: (arr: readonly T[]) => T;

const shuffle: (arr: readonly T[]) => T[];

const take: (arr: readonly T[], count: number) => T[];

const takeLast: (arr: readonly T[], count?: number) => T[];

const takeLastWhile: (arr: readonly T[], shouldContinueTaking: (item: T) => boolean) => T[];

const takeWhile: (arr: readonly T[], shouldContinueTaking: (element: T) => boolean) => T[];

function contains(array: ArrayLike, value: U, equalityComparer?: EqualityComparer): boolean;

function every(
list: T[],
predicate: (element: T, index: number, list: ArrayLike) => element is U
): list is U[];
function every(
list: readonly T[],
predicate: (element: T, index: number, list: ArrayLike) => element is U
): list is readonly U[];
function every(
list: ArrayLike,
predicate: (element: T, index: number, list: ArrayLike) => boolean
): boolean;

function filter(
array: ArrayLike | null | undefined,
f: (x: T, i: number, list: ArrayLike) => x is U,
startIndex?: number,
limit?: number ): U[];
function filter(
list: ArrayLike | null | undefined,
f: (x: T, i: number, list: ArrayLike) => boolean,
startIndex?: number,
limit?: number ): T[];

function find(
array: readonly T[] | null | undefined,
predicate: (value: T, index: number,
list: ArrayLike) => value is U,
startIndex?: number,
limit?: number ): U | undefined;

function find(
list: ArrayLike | null | undefined,
predicate: (value: T, index: number, list: ArrayLike) => boolean,
startIndex?: number,
limit?: number ): T | undefined;

const findIndex: (
list: ArrayLike | null | undefined,
predicate: (v: T, i: number, a: ArrayLike) => boolean,
startIndex?: number,
limit?: number ) => number;

function findLast(
array: readonly T[] | null | undefined,
predicate: (value: T, index: number, list: ArrayLike) => value is U,
startIndex?: number,
limit?: number ): U | undefined;

function findLast(
list: ArrayLike | null | undefined,
predicate: (v: T, i: number, list: ArrayLike) => boolean,
startIndex?: number,
limit?: number ): T | undefined;

const findLastIndex: (
list: ArrayLike | null | undefined,
predicate: (v: T, i: number, a: ArrayLike) => boolean,
startIndex?: number,
limit?: number ) => number;

function each(
list: ArrayLike | null | undefined,
iterate: (element: T, index: number, list: ArrayLike) => unknown,
startIndex?: number,
limit?: number): ArrayLike | null | undefined;

function eachLast(
list: ArrayLike | null | undefined,
iterate: (element: T, index: number, list: ArrayLike) => unknown,
startIndex?: number,
limit?: number): ArrayLike | null | undefined;

const includes: (
list: readonly T[] | { includes(el: T, fromIndex?: number): boolean; },
el: T,
fromIndex?: number) => boolean;

const indexOf: (
list: ArrayLike | string | null | undefined,
value: T | string,
startIndex?: number) => number;

const lastIndexOf: (
list: ArrayLike | string | undefined | null, value: T | string, fromIndex?: number) => number;

function map(
list: ArrayLike): T[];

function map(array: readonly T[], mapFn: (x: T, i: number, list: ArrayLike) => U, startIndex?: number, limit?: number): readonly U[];

function map(
list: ArrayLike, mapFn: (x: T, i: number, list: ArrayLike) => U, startIndex?: number, limit?: number): U[];

function reduce(array: readonly T[], f: (memo: U, value: T, i: number) => U, initial: U, start?: number, count?: number): U;

function reduce(array: readonly T[], f: (memo: T, value: T, i: number) => T, initial: T): T;

function reduce(array: readonly T[], f: (memo: T, value: T, i: number) => T): T | undefined;

function reject(
list: ArrayLike,
f: (x: T, i: number, list: ArrayLike) => boolean,
startIndex?: number,
limit?: number): T[];

function some(
list: ArrayLike,
predicate: (value: T, index: number, list: ArrayLike) => boolean
): boolean;

const after: (
n: number,
func: (...args: A) => R
) => (...args: A) => R | undefined;

const ary: (
func: (this: This, ...args: A) => R, n: number
) => (this: This, ...args: A) => R;

const attempt: (
func: (...args: A) => R, ...args: A
) => R | Error;

const always: (value: T) => () => T;

const alwaysTrue: () => true;

const alwaysFalse: () => false;

const before: (
n: number,
func: (...args: A) => R
) => (...args: A) => R | undefined;

interface DebounceOptions {
signal?: AbortSignal;
edges?: Array<'leading' | 'trailing'>;
}

const debounce: (
func: (this: Me, ...args: A) => unknown,
debounceMs: number,
options?: DebounceOptions
) => ((this: Me, ...args: A) => void) & {
schedule: () => void;
cancel: () => void;
flush: () => void;
};

function flow(f: () => R): () => R;
function flow(f1: (...args: A) => R): (...args: A) => R;
function flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;
function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;
function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;

function flowLast(f: () => R): () => R;
function flowLast(f1: (...args: A) => R): (...args: A) => R;
function flowLast(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2;
function flowLast(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3;
function flowLast(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4;
function flowLast(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5;
function flowLast(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any;

const identity: (x: T) => T;

const negate: (func: (...args: A) => unknown) => (...args: A) => unknown;

const noop: () => void;

function once any>(func: F): F;

function once void>(func: F): F;

const rest: any>(func: F, startIndex?: number) => (...args: any[]) => ReturnType;

const spread: any>(func: F) => (argsArr: Parameters) => ReturnType;

interface ThrottleOptions {
signal?: AbortSignal;
edges?: Array<'leading' | 'trailing'>;
}
const throttle: (
func: (this: Me, ...args: A) => unknown,
throttleMs: number,
options?: ThrottleOptions
) => ((this: Me, ...args: A) => void) & {
cancel: () => void;
flush: () => void;
};

const unary: any>(func: F) => (...args: any[]) => ReturnType;

const hook: (
fn: (this: Ctx, ...args: Args) => R,
pre?: null | ((this: Ctx, args: Args) => Args | undefined | null | void),
post?: (this: Ctx, res: R, args: Args, rawArgs?: Args) => R
) => (this: Ctx, ...args: Args) => R;

const clamp: (value: number, minimum: number, maximum?: number) => number;

function inRange(value: number, maximum: number): boolean;

function inRange(value: number, minimum: number, maximum: number): boolean;

const mean: (nums: readonly number[]) => number;

const meanBy: (items: readonly T[], getValue: (element: T) => number) => number;

const median: (nums: readonly number[]) => number;

const medianBy: (items: readonly T[], getValue: (element: T) => number) => number;

const gt: (a: T, b: T) => boolean;

const gte: (a: T, b: T) => boolean;

const lt: (a: T, b: T) => boolean;

const lte: (a: T, b: T) => boolean;

const neq: (a: unknown, b: unknown) => boolean;

const random: (minimum?: number, maximum?: number) => number;

function randomInt(maximum: number): number;
function randomInt(minimum: number, maximum: number): number;

function range(end: number): number[];
function range(start: number, end: number): number[];
function range(start: number, end: number, step: number): number[];

function rangeRight(end: number): number[];
function rangeRight(start: number, end: number): number[];
function rangeRight(start: number, end: number, step: number): number[];

const floor: (value: number, precision?: number) => number;

const ceil: (value: number, precision?: number) => number;

const round: (value: number, precision?: number) => number;

const sum: (nums: readonly number[]) => number;

const sumBy: (items: readonly T[], getValue: (element: T) => number) => number;

const trunc: (value: number, precision?: number) => number;

const sign: (x: number) => number;

const defaults: >(target: Partial, ...sources: readonly Partial[]) => Partial;

const defaultTo: (value: T, defaultValue: V) => T | V;

const entries: ( | ArrayLike, K extends keyof O & string = keyof O & string, V extends O[K] = O[K]>(obj: O) => [K, V][]) | {
(o: {
[s: string]: T;

} | ArrayLike): [string, T][];

(o: {}): [string, any][];

};

const forIn: (obj: { [k in K]: V; }, iterate: (val: V, key: K, obj: { [k in K]: V; }) => unknown) => { [k in K]: V; };

const forOwn: (obj: { [k in K]: V; }, iterate: (val: V, key: K, obj: { [k in K]: V; }) => unknown) => { [k in K]: V; };

const findKey: (obj: T,
predicate: (value: T[K], key: K, obj: T) => boolean) => K | undefined;

const has: (target: object | null | undefined, propKey: K) => target is { [k in K]: unknown; };

const hasOwn: (obj: unknown, key: unknown) => boolean;

const invert: >(obj: O) => Inverted;

const keys: (x: T | null | undefined) => string[];

const omit: , K extends keyof T>(obj: T, keys: readonly K[]) => Omit;

const omitBy: >(obj: T, shouldOmit: (value: T[keyof T], key: keyof T) => boolean) => Partial;

const pick: , K extends keyof T>(obj: T, keys: readonly K[]) => Pick;

const pickBy: >(obj: T, shouldPick: (value: T[keyof T], key: keyof T) => boolean) => Partial;

type Prop = {
(obj: null | undefined, name: string | number | symbol): undefined;

(obj: O, name: K): O[K & keyof O];

};

const prop: Prop;

type GetValue = K extends keyof O ? O[K] : undefined;

type AddValue = number extends A['length'] ? (A[number] | T)[] : [...A, T];

type GetValues = number extends PS['length'] ? GetValue[] : PS extends readonly [] ? Res : PS extends readonly [infer K] ? AddValue> : PS extends readonly [infer P, ...infer Rest] ? GetValues>> : AddValue>;

const props: , const A extends readonly K[] | readonly [K], const V, K extends PropertyKey = PropertyKey>(obj: Partial, names: A) => GetValues;

const shake: (obj: T, test?: (value: unknown, key: keyof T, obj: T) => boolean) => Partial;

const values: {
(o: {
[s: string]: T;

} | ArrayLike): T[];

(o: {}): any[];

};

const camelCase: (str: string) => string;

const capitalize: (str: T) => Capitalize;

type Capitalize = T extends ${infer F}${infer R} ? ${Uppercase}${Lowercase} : T;

const constCase: (str: string) => string;

const endsWith: (str: string, suffix: string, endPosition?: number | boolean, ignoreCase?: boolean) => boolean;

const htmlEncode: (str: string) => string;

type DataValue = string | number | boolean | bigint | null | undefined;

type DataObject = Readonly>;

type DataArray = readonly DataValue[];

function format(tpl: string, data: DataObject): string;

function format(tpl: string, data: DataArray): string;

function format(tpl: string, ...values: DataValue[]): string;

function format(tpl: string, ...values: [DataObject | DataArray | DataValue, ...DataValue[]]): string;

const dashCase: (str: string) => string;

const dotCase: (str: string) => string;

const lowerFirst: (str: string) => string;

const pad: (str: string, length: number, chars?: string) => string;

const padStart: (input: string, length: number, chars?: string) => string;

const padEnd: (input: string, length: number, chars?: string) => string;

const pascalCase: (str: string) => string;

const pathCase: (str: string) => string;

const snakeCase: (str: string) => string;

const startCase: (str: string) => string;

const swapCase: (input: string) => string;

const trim: (str: string, chars?: string | string[]) => string;

const trimEnd: (str: string, chars?: string | string[]) => string;

const trimStart: (str: string, chars?: string | string[]) => string;

const toLower: (str: string) => string;

const toUpper: (str: string) => string;

const htmlDecode: (str: string) => string;

const upperFirst: (str: string) => string;

const toFinite: (value?: unknown) => number;

const toInteger: (value?: unknown) => number;

const toLength: (value?: unknown) => number;

function toNumber(value?: unknown): number;

const toSafeInteger: (value?: unknown) => number;

function parse(queryStr: string): Record;

function stringify(queryObj: Record, prefix?: string | boolean): string;

interface MemoizeCache {
set(key: K, value: V): void;

get(key: K): V | undefined;

has(key: K): boolean;

delete(key: K): boolean | void;

clear(): void;

size: number;

}
type MemoizeOptions = {
cache?: MemoizeCache;

getKey?: (this: Me, ...args: A) => K;

};

type Memoized = {
(this: Me, ...args: A): R;

cache: MemoizeCache;

};

const memoize: (fn: (this: Me, ...args: A) => R, options?: MemoizeOptions) => Memoized;

const defer: (func: (...args: A) => unknown, ...args: A) => ReturnType;

interface RetryOptions {
multiplier?: number;

maxTimeout?: number;

maxAttempts?: number;

minTimeout?: number;

jitter?: number;

}
function retry(fn: (() => Promise) | (() => T), options?: RetryOptions): Promise;

const sleep: (ms: number) => Promise;

function timeout(ms: number): Promise;

const withTimeout: (run: () => Promise, ms: number) => Promise;

interface AssertTruthy {
(condition: T, errMsg?: string | Error): asserts condition is Truthy;

}
const assertTruthy: AssertTruthy;

``