@hairy/utils 1.6.1 → 1.6.2

package/dist/index.d.ts

@@ -0,0 +1,319 @@
+export { clone, cloneDeep, concat, debounce, find, isArray, isArrayLike, isBoolean, isDate, isEmpty, isEqual, isError, isFunction, isNaN, isNative, isNull, isNumber, isObject, isPlainObject, isString, isUndefined, join, keys, truncate, uniq, uniqBy, values } from 'lodash-es';
+import Bignumber from 'bignumber.js';
+export { default as Bignumber } from 'bignumber.js';
+
+/**
+ * Supported locale values. Use `false` to ignore locale.
+ * Defaults to `undefined`, which uses the host environment.
+ */
+type Locale = string[] | string | false | undefined;
+/**
+ * Options used for converting strings to pascal/camel case.
+ */
+interface PascalCaseOptions extends Options {
+    mergeAmbiguousCharacters?: boolean;
+}
+/**
+ * Options used for converting strings to any case.
+ */
+interface Options {
+    locale?: Locale;
+    split?: (value: string) => string[];
+    /** @deprecated Pass `split: splitSeparateNumbers` instead. */
+    separateNumbers?: boolean;
+    delimiter?: string;
+    prefixCharacters?: string;
+    suffixCharacters?: string;
+}
+/**
+ * Convert a string to space separated lower case (`foo bar`).
+ */
+declare function noCase(input: string, options?: Options): string;
+/**
+ * Convert a string to camel case (`fooBar`).
+ */
+declare function camelCase(input: string, options?: PascalCaseOptions): string;
+/**
+ * Convert a string to pascal case (`FooBar`).
+ */
+declare function pascalCase(input: string, options?: PascalCaseOptions): string;
+/**
+ * Convert a string to pascal snake case (`Foo_Bar`).
+ */
+declare function pascalSnakeCase(input: string, options?: Options): string;
+/**
+ * Convert a string to capital case (`Foo Bar`).
+ */
+declare function capitalCase(input: string, options?: Options): string;
+/**
+ * Convert a string to constant case (`FOO_BAR`).
+ */
+declare function constantCase(input: string, options?: Options): string;
+/**
+ * Convert a string to dot case (`foo.bar`).
+ */
+declare function dotCase(input: string, options?: Options): string;
+/**
+ * Convert a string to kebab case (`foo-bar`).
+ */
+declare function kebabCase(input: string, options?: Options): string;
+/**
+ * Convert a string to path case (`foo/bar`).
+ */
+declare function pathCase(input: string, options?: Options): string;
+/**
+ * Convert a string to path case (`Foo bar`).
+ */
+declare function sentenceCase(input: string, options?: Options): string;
+/**
+ * Convert a string to snake case (`foo_bar`).
+ */
+declare function snakeCase(input: string, options?: Options): string;
+/**
+ * Convert a string to header case (`Foo-Bar`).
+ */
+declare function trainCase(input: string, options?: Options): string;
+
+type Numeric = string | number | bigint;
+interface DynamicObject {
+    [key: string]: any;
+}
+interface NumericObject {
+    [key: string]: Numeric;
+}
+interface StringObject {
+    [key: string]: string;
+}
+interface NumberObject {
+    [key: string]: string;
+}
+interface SymbolObject {
+    [key: string]: symbol;
+}
+type Key = string | number | symbol;
+type BooleanLike = any;
+type Noop = (...args: any[]) => any;
+
+type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
+};
+type DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
+};
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type DeepReplace<T, K = unknown, V = unknown> = {
+    [P in keyof T]: K extends P ? V : DeepReplace<T[P], K, V>;
+};
+type DeepKeyof<T> = T extends object ? keyof T | DeepKeyof<T[keyof T]> : never;
+
+type Awaitable<T> = T | Promise<T>;
+type Arrayable<T> = T | T[];
+type Option<L extends Key = 'label', V extends Key = 'value', C extends Key = 'children'> = {
+    [P in L]?: string;
+} & {
+    [P in V]?: Numeric;
+} & {
+    [P in C]?: Option<L, V, C>[];
+};
+
+declare const BIG_INTS: {
+    t: {
+        v: number;
+        d: number;
+        n: string;
+    };
+    b: {
+        v: number;
+        d: number;
+        n: string;
+    };
+    m: {
+        v: number;
+        d: number;
+        n: string;
+    };
+    k: {
+        v: number;
+        d: number;
+        n: string;
+    };
+};
+/**
+ *  Any type that can be used where a big number is needed.
+ */
+type Numberish = Numeric | {
+    toString: (...args: any[]) => string;
+};
+type Delimiter = 'k' | 'm' | 'b' | 't';
+interface DecimalOptions {
+    d?: number;
+    r?: Bignumber.RoundingMode;
+}
+interface FormatGroupOptions {
+    size?: number;
+    symbol?: string;
+}
+interface FormatNumericOptions {
+    delimiters?: Delimiter[] | false;
+    rounding?: Bignumber.RoundingMode;
+    decimals?: number;
+    zeromove?: boolean;
+    format?: Bignumber.Format;
+}
+declare function unum(num?: Numeric): Bignumber;
+declare function gte(num: Numeric, n: Numeric): boolean;
+declare function gt(num: Numeric, n: Numeric): boolean;
+declare function lte(num: Numeric, n: Numeric): boolean;
+declare function lt(num: Numeric, n: Numeric): boolean;
+declare function plus(array: Numeric[], options?: DecimalOptions): string;
+declare function average(array: Numeric[], options?: DecimalOptions): string;
+/**
+ * calculate percentage
+ * @param total
+ * @param count
+ */
+declare function percentage(total: Numeric, count: Numeric, options?: DecimalOptions): string;
+/**
+ * leading zeros
+ * @param value
+ * @param n
+ * @param type
+ */
+declare function zerofill(value: Numberish, n?: number, type?: 'positive' | 'reverse'): Numberish;
+declare function zeromove(value: Numberish): string;
+declare function numerfix(value: any): string;
+/**
+ * format as a positive integer
+ * @param value
+ */
+declare function integer(value: Numberish): string;
+/**
+ * retain n decimal places
+ * @param value
+ * @param n
+ */
+declare function decimal(value: Numberish, n?: number): string;
+declare function parseNumeric(num: Numeric, delimiters?: Delimiter[]): {
+    v: number;
+    d: number;
+    n: string;
+};
+/**
+ * format number thousand separator and unit
+ * @param value
+ * @param options
+ * @returns
+ */
+declare function formatNumeric(value?: Numeric, options?: FormatNumericOptions): string;
+
+type Dimension = Numeric | [Numeric, Numeric] | {
+    width: Numeric;
+    height: Numeric;
+};
+declare function formatUnit(value: Numeric, unit?: string): string;
+declare function formatSize(dimension: Dimension, unit?: string): {
+    width: string;
+    height: string;
+};
+
+/**
+ * Intercept front and back characters, hide middle characters
+ * @param value
+ * @param mode
+ * @param symbol
+ */
+declare function cover(value: string, mode: [number, number, number], symbol?: string): string;
+
+type Typeof = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'null' | 'regexp';
+/**
+ * obtain data type
+ * @param target Detection object
+ */
+declare function getTypeof(target: any): Typeof;
+/**
+ * Detecting data types
+ * @param target Detection object
+ * @param type Data type
+ */
+declare function isTypeof(target: any, type: Typeof): boolean;
+
+declare const compose: (...fns: any[]) => any;
+
+/**
+ * formData to object
+ * @param formData
+ */
+declare function formToObject(formData: FormData): Record<string, string>;
+/**
+ * Object to formData
+ * @param object
+ */
+declare function objectToForm(object: Record<string, string | File>): FormData;
+
+declare class Deferred<T> extends Promise<T> {
+    resolve: (value: T) => Deferred<T>;
+    reject: (reason?: any) => Deferred<T>;
+    constructor();
+}
+
+declare function delay(ms: number): Promise<void>;
+
+declare const isBrowser: () => boolean;
+declare const isWeex: () => boolean;
+declare const isIE: () => boolean | "";
+declare const isIE9: () => boolean | "";
+declare const isIE11: () => boolean;
+declare const isEdge: () => boolean | "";
+declare const isAndroid: () => boolean;
+declare const isIOS: () => boolean;
+declare const isChrome: () => boolean | "";
+declare const isPhantomJS: () => boolean | "";
+declare const isFF: () => false | RegExpMatchArray | null;
+declare const isMobile: () => boolean;
+declare const isFormData: (value: any) => value is FormData;
+declare const isWindow: (value: any) => value is Window;
+
+declare const noop: (...args: any) => any;
+
+type UnaryFunction<ValueType, ReturnType> = (value: ValueType) => ReturnType | PromiseLike<ReturnType>;
+type Pipeline<ValueType, ReturnType> = (value?: ValueType) => Promise<ReturnType>;
+/**
+Compose promise-returning & async functions into a reusable pipeline.
+
+@param ...input - Iterated over sequentially when returned `function` is called.
+@returns The `input` functions are applied from left to right.
+
+@example
+```
+import { pPipe } from '@hairy/utils';
+
+const addUnicorn = async string => `${string} Unicorn`;
+const addRainbow = async string => `${string} Rainbow`;
+
+const pipeline = pPipe(addUnicorn, addRainbow);
+
+console.log(await pipeline('❤️'));
+//=> '❤️ Unicorn Rainbow'
+```
+ */
+declare function pPipe<ValueType, ReturnType>(f1: UnaryFunction<ValueType, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ResultValue3, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ResultValue3>, f4: UnaryFunction<ResultValue3, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ResultValue3, ResultValue4, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ResultValue3>, f4: UnaryFunction<ResultValue3, ResultValue4>, f5: UnaryFunction<ResultValue4, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ResultValue3, ResultValue4, ResultValue5, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ResultValue3>, f4: UnaryFunction<ResultValue3, ResultValue4>, f5: UnaryFunction<ResultValue4, ResultValue5>, f6: UnaryFunction<ResultValue5, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ResultValue3, ResultValue4, ResultValue5, ResultValue6, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ResultValue3>, f4: UnaryFunction<ResultValue3, ResultValue4>, f5: UnaryFunction<ResultValue4, ResultValue5>, f6: UnaryFunction<ResultValue5, ResultValue6>, f7: UnaryFunction<ResultValue6, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ResultValue3, ResultValue4, ResultValue5, ResultValue6, ResultValue7, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ResultValue3>, f4: UnaryFunction<ResultValue3, ResultValue4>, f5: UnaryFunction<ResultValue4, ResultValue5>, f6: UnaryFunction<ResultValue5, ResultValue6>, f7: UnaryFunction<ResultValue6, ResultValue7>, f8: UnaryFunction<ResultValue7, ReturnType>): Pipeline<ValueType, ReturnType>;
+declare function pPipe<ValueType, ResultValue1, ResultValue2, ResultValue3, ResultValue4, ResultValue5, ResultValue6, ResultValue7, ResultValue8, ReturnType>(f1: UnaryFunction<ValueType, ResultValue1>, f2: UnaryFunction<ResultValue1, ResultValue2>, f3: UnaryFunction<ResultValue2, ResultValue3>, f4: UnaryFunction<ResultValue3, ResultValue4>, f5: UnaryFunction<ResultValue4, ResultValue5>, f6: UnaryFunction<ResultValue5, ResultValue6>, f7: UnaryFunction<ResultValue6, ResultValue7>, f8: UnaryFunction<ResultValue7, ResultValue8>, f9: UnaryFunction<ResultValue8, ReturnType>): Pipeline<ValueType, ReturnType>;
+
+declare const pipe: (...fns: any[]) => any;
+
+declare function arange(x1: number, x2?: number, stp?: number, z?: number[], z0?: number): number[];
+declare function loop<T = void>(fn: (next: (ms: number) => Promise<T>) => Promise<T>): Promise<T>;
+declare function riposte<T>(...args: [cond: boolean, value: T][]): T;
+declare function unwrap<T extends object>(value: T | (() => T)): T;
+declare function whenever<T, C extends (value: Exclude<T, null | undefined>) => any>(value: T, callback: C): ReturnType<C> | undefined;
+
+export { type Arrayable, type Awaitable, BIG_INTS, type BooleanLike, type DecimalOptions, type DeepKeyof, type DeepPartial, type DeepReadonly, type DeepReplace, type DeepRequired, Deferred, type Delimiter, type Dimension, type DynamicObject, type FormatGroupOptions, type FormatNumericOptions, type Key, type Noop, type NumberObject, type Numberish, type Numeric, type NumericObject, type Option, type Pipeline, type StringObject, type SymbolObject, type Typeof, type UnaryFunction, arange, average, camelCase, capitalCase, compose, constantCase, cover, decimal, delay, dotCase, formToObject, formatNumeric, formatSize, formatUnit, getTypeof, gt, gte, integer, isAndroid, isBrowser, isChrome, isEdge, isFF, isFormData, isIE, isIE11, isIE9, isIOS, isMobile, isPhantomJS, isTypeof, isWeex, isWindow, kebabCase, loop, lt, lte, noCase, noop, numerfix, objectToForm, pPipe, parseNumeric, pascalCase, pascalSnakeCase, pathCase, percentage, pipe, plus, riposte, sentenceCase, snakeCase, trainCase, unum, unwrap, whenever, zerofill, zeromove };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hairy/utils",
   "type": "module",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Library for anywhere",
   "author": "Hairyf <wwu710632@gmail.com>",
   "license": "MIT",