@hairy/utils 1.23.0 → 1.25.0

package/dist/index.cjs

@@ -86,6 +86,7 @@ __export(index_exports, {
   isPhantomJS: () => isPhantomJS,
   isPlainObject: () => isPlainObject_default,
   isString: () => isString_default,
+  isTruthy: () => isTruthy,
   isTypeof: () => isTypeof,
   isUndefined: () => isUndefined_default,
   isWeex: () => isWeex,
@@ -103,7 +104,6 @@ __export(index_exports, {
   noop: () => noop2,
   numerfix: () => numerfix,
   objectToForm: () => objectToForm,
-  pPipe: () => pPipe,
   parseNumeric: () => parseNumeric,
   pascalCase: () => pascalCase,
   pascalSnakeCase: () => pascalSnakeCase,
@@ -3147,8 +3147,24 @@ function isTypeof(target, type) {
   return getTypeof(target) === type;
 }
 
+// src/util/compose-promise.ts
+function pCompose(...fns) {
+  if (fns.length === 0)
+    throw new Error("Expected at least one argument");
+  return async (input) => {
+    let value = input;
+    for (const fn of fns.reverse())
+      value = await fn(value);
+    return value;
+  };
+}
+
 // src/util/compose.ts
-var compose = (...fns) => fns.reduceRight((v, f) => f(v));
+function compose(...fns) {
+  const fn = fns.pop();
+  return fns.reduceRight((v, f) => f(v), fn);
+}
+compose.promise = pCompose;
 
 // src/util/converts.ts
 function formToObject(formData) {
@@ -3208,6 +3224,7 @@ var isFF = () => typeof UA() === "string" && UA().match(/firefox\/(\d+)/);
 var isMobile = () => isBrowser() && navigator.userAgent.toLowerCase().includes("mobile");
 var isFormData = (value) => isObject_default(value) && isBrowser() && value instanceof FormData;
 var isWindow = (value) => typeof window !== "undefined" && toString.call(value) === "[object Window]";
+var isTruthy = (value) => Boolean(value);
 
 // src/util/json.ts
 function jsonTryParse(text) {
@@ -3218,20 +3235,23 @@ function jsonTryParse(text) {
   }
 }
 
-// src/util/p-pipe.ts
-function pPipe(...functions) {
-  if (functions.length === 0)
+// src/util/pipe-promise.ts
+function pPipe(...fns) {
+  if (fns.length === 0)
     throw new Error("Expected at least one argument");
   return async (input) => {
-    let currentValue = input;
-    for (const function_ of functions)
-      currentValue = await function_(currentValue);
-    return currentValue;
+    let value = input;
+    for (const fn of fns)
+      value = await fn(value);
+    return value;
   };
 }
 
 // src/util/pipe.ts
-var pipe = (...fns) => fns.reduce((v, f) => f(v));
+function pipe(...fns) {
+  return fns.reduce((v, f) => f(v));
+}
+pipe.promise = pPipe;
 
 // src/util/random.ts
 function randomNumer(min, max) {
@@ -3327,6 +3347,7 @@ function whenever(value, callback) {
   isPhantomJS,
   isPlainObject,
   isString,
+  isTruthy,
   isTypeof,
   isUndefined,
   isWeex,
@@ -3344,7 +3365,6 @@ function whenever(value, callback) {
   noop,
   numerfix,
   objectToForm,
-  pPipe,
   parseNumeric,
   pascalCase,
   pascalSnakeCase,

package/dist/index.d.ts

@@ -118,7 +118,7 @@ type Awaitable<T> = T | PromiseLike<T>;
 type Arrayable<T> = T | T[];
 type Nullable<T> = T | null | undefined;
 type ElementOf<T> = T extends (infer E)[] ? E : never;
-type Fn<T = void> = () => T;
+type Fn$1<T = void> = () => T;
 type AnyFn = (...args: any[]) => any;
 type PromiseFn = (...args: any[]) => Promise<any>;
 type Constructor<T = void> = new (...args: any[]) => T;
@@ -253,7 +253,84 @@ declare function getTypeof(target: any): Typeof;
  */
 declare function isTypeof(target: any, type: Typeof): boolean;
 
-declare const compose: (...fns: any[]) => any;
+type UF$1<VT, RT> = (value: VT) => RT | PromiseLike<RT>;
+type Composed<VT, RT> = (value?: VT) => Promise<RT>;
+/**
+ * Compose promise-returning & async fns into a reusable pipeline.
+ *
+ * @param ...fns - Iterated over sequentially when returned `function` is called.
+ * @returns The `fns` are applied from right to left.
+ *
+ * @example
+ * ```
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = pCompose(addRainbow, addUnicorn);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * ```
+ */
+declare function pCompose<VT, RT>(f1: UF$1<VT, RT>): Composed<VT, RT>;
+declare function pCompose<VT, R1, RT>(f1: UF$1<R1, RT>, f2: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, RT>(f1: UF$1<R2, RT>, f2: UF$1<R1, R2>, f3: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, RT>(f1: UF$1<R3, RT>, f2: UF$1<R2, R3>, f3: UF$1<R1, R2>, f4: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, RT>(f1: UF$1<R4, RT>, f2: UF$1<R3, R4>, f3: UF$1<R2, R3>, f4: UF$1<R1, R2>, f5: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, RT>(f1: UF$1<R5, RT>, f2: UF$1<R4, R5>, f3: UF$1<R3, R4>, f4: UF$1<R2, R3>, f5: UF$1<R1, R2>, f6: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, R6, RT>(f1: UF$1<R6, RT>, f2: UF$1<R5, R6>, f3: UF$1<R4, R5>, f4: UF$1<R3, R4>, f5: UF$1<R2, R3>, f6: UF$1<R1, R2>, f7: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, R6, R7, RT>(f1: UF$1<R7, RT>, f2: UF$1<R6, R7>, f3: UF$1<R5, R6>, f4: UF$1<R4, R5>, f5: UF$1<R3, R4>, f6: UF$1<R2, R3>, f7: UF$1<R1, R2>, f8: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, R6, R7, R8, RT>(f1: UF$1<R8, RT>, f2: UF$1<R7, R8>, f3: UF$1<R6, R7>, f4: UF$1<R5, R6>, f5: UF$1<R4, R5>, f6: UF$1<R3, R4>, f7: UF$1<R2, R3>, f8: UF$1<R1, R2>, f9: UF$1<VT, R1>): Composed<VT, RT>;
+
+type Fn<V, R> = (x: V) => R;
+type Q<T, V> = (...args: T) => V;
+/**
+ * Performs function composition in RTL (Right To Left) direction.
+ *
+ * Our `compose` and `compose.promise` implementation supports N arguments. But you can use only 10 in
+ * TypeScript, because it doesn't support **Variadic Kinds** and we explicitly
+ * have to define the type of all the possible usages as method overloads.
+ *
+ * @example
+ * const normalizeWhiteSpaces = text => name.replace(/\s+/g, ' ').trim();
+ *
+ * const getInitials = compose(
+ *   initials => initials.join('').toLocaleUpperCase(),
+ *   name => name.split(' ').map(name => name.charAt(0)),
+ *   normalizeWhiteSpaces
+ * );
+ *
+ * getInitials('Vitor Luiz Cavalcanti');
+ * //=> "VLC"
+ *
+ * @param fn - An arity 1 function, except the last one which can have arity N.
+ * @param fns - Functions of arity 1. Each one's result is next's argument.
+ *
+ * @example
+ *
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = compose.promise(addRainbow, addUnicorn);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * @param ...fns - Iterated over sequentially when returned `function` is called.
+ * @returns The `fns` functions are applied from right to left.
+ */
+declare function compose<T, V0, V1>(fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V1>;
+declare function compose<T, V0, V1, V2>(fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V2>;
+declare function compose<T, V0, V1, V2, V3>(fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V3>;
+declare function compose<T, V0, V1, V2, V3, V4>(fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V4>;
+declare function compose<T, V0, V1, V2, V3, V4, V5>(fn5: Fn<V4, V5>, fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V5>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6>(fn6: Fn<V5, V6>, fn5: Fn<V4, V5>, fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V6>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7>(fn7: Fn<V6, V7>, fn6: Fn<V5, V6>, fn5: Fn<V4, V5>, fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V7>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8>(fn8: Fn<V7, V8>, fn7: Fn<V6, V7>, fn6: Fn<V5, V6>, fn5: Fn<V4, V5>, fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V8>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9>(fn9: Fn<V8, V9>, fn8: Fn<V7, V8>, fn7: Fn<V6, V7>, fn6: Fn<V5, V6>, fn5: Fn<V4, V5>, fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V9>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10>(fn10: Fn<V9, V10>, fn9: Fn<V8, V9>, fn8: Fn<V7, V8>, fn7: Fn<V6, V7>, fn6: Fn<V5, V6>, fn5: Fn<V4, V5>, fn4: Fn<V3, V4>, fn3: Fn<V2, V3>, fn2: Fn<V1, V2>, fn1: Fn<V0, V1>, fn0: Q<T, V0>): Q<T, V10>;
+declare namespace compose {
+    var promise: typeof pCompose;
+}
 
 /**
  * formData to object
@@ -288,43 +365,88 @@ 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 isTruthy: <T>(value: T) => value is NonNullable<T>;
 
 declare function jsonTryParse(text: string | undefined | null): any;
 
 declare const noop: (...args: any) => any;
 
-type UnaryFunction<ValueType, ReturnType> = (value: ValueType) => ReturnType | PromiseLike<ReturnType>;
-type Pipeline<ValueType, ReturnType> = (value?: ValueType) => Promise<ReturnType>;
+type UF<VT, RT> = (value: VT) => RT | PromiseLike<RT>;
+type Pipeline<VT, RT> = (value?: VT) => Promise<RT>;
 /**
-Compose promise-returning & async functions into a reusable pipeline.
+Compose promise-returning & async fns into a reusable pipeline.
 
 @param ...input - Iterated over sequentially when returned `function` is called.
-@returns The `input` functions are applied from left to right.
+@returns The `input` fns 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);
+const pipeline = pipe.promise(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 function pPipe<VT, RT>(f1: UF<VT, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, RT>(f1: UF<VT, R1>, f2: UF<R1, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, R6, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, R6>, f7: UF<R6, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, R6, R7, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, R6>, f7: UF<R6, R7>, f8: UF<R7, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, R6, R7, R8, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, R6>, f7: UF<R6, R7>, f8: UF<R7, R8>, f9: UF<R8, RT>): Pipeline<VT, RT>;
 
-declare const pipe: (...fns: any[]) => any;
+/**
+ * Performs function composition in LTR (Left To Right) direction.
+ *
+ * Our `pipe` and  `pipe.promise` implementation supports N arguments. But you can use only 10 in
+ * TypeScript, because it doesn't support **Variadic Kinds** and we explicitly
+ * have to define the type of all the possible usages as method overloads.
+ *
+ * @example
+ * const normalizeWhiteSpaces = text => name.replace(/\s+/g, ' ').trim();
+ *
+ * const getInitials = pipe(
+ *   normalizeWhiteSpaces,
+ *   name => name.split(' ').map(name => name.charAt(0)),
+ *   initials => initials.join('').toLocaleUpperCase()
+ * );
+ *
+ * getInitials('Vitor Luiz Cavalcanti');
+ * //=> "VLC"
+ *
+ * @param fn - An arity N function. Its result is the argument of next one.
+ * @param fns - Functions of arity 1. Each one's result is next's argument.
+ *
+ * @example
+ *
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = pipe.promise(addUnicorn, addRainbow);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * @param ...input - Iterated over sequentially when returned `function` is called.
+ * @returns The `input` functions are applied from left to right.
+ */
+declare function pipe<Args extends unknown[], T0>(...fns: [(...xs: Args) => T0]): (...xs: Args) => T0;
+declare function pipe<Args extends unknown[], T0, T1>(...fns: [(...xs: Args) => T0, (x: T0) => T1]): (...xs: Args) => T1;
+declare function pipe<Args extends unknown[], T0, T1, T2>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2]): (...xs: Args) => T2;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3]): (...xs: Args) => T3;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4]): (...xs: Args) => T4;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5]): (...xs: Args) => T5;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6]): (...xs: Args) => T6;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6, T7>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6, (x: T6) => T7]): (...xs: Args) => T7;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6, T7, T8>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6, (x: T6) => T7, (x: T7) => T8]): (...xs: Args) => T8;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6, (x: T6) => T7, (x: T7) => T8, (x: T8) => T9]): (...xs: Args) => T9;
+declare namespace pipe {
+    var promise: typeof pPipe;
+}
 
 declare function randomNumer(min: number, max: number): number;
 declare function randomArray<T>(array: T[]): T;
@@ -335,4 +457,4 @@ 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 AnyFn, type ArgumentsType, type Arrayable, type Awaitable, BIG_INTS, BigNum, type BooleanLike, type Constructor, type DecimalOptions, type DeepKeyof, type DeepMerge, type DeepPartial, type DeepReadonly, type DeepReplace, type DeepRequired, Deferred, type Delimiter, type Dimension, type DynamicObject, type ElementOf, type Fn, type FormatGroupOptions, type FormatNumericOptions, type Key, type MergeInsertions, type Noop, type Nullable, type NumberObject, type Numberish, type Numeric, type NumericObject, type Option, type Pipeline, type PromiseFn, type PromiseType, 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, jsonTryParse, kebabCase, loop, lt, lte, noCase, noop, numerfix, objectToForm, pPipe, parseNumeric, pascalCase, pascalSnakeCase, pathCase, percentage, pipe, plus, randomArray, randomNumer, riposte, sentenceCase, snakeCase, trainCase, unwrap, whenever, zerofill, zeromove };
+export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, BIG_INTS, BigNum, type BooleanLike, type Constructor, type DecimalOptions, type DeepKeyof, type DeepMerge, type DeepPartial, type DeepReadonly, type DeepReplace, type DeepRequired, Deferred, type Delimiter, type Dimension, type DynamicObject, type ElementOf, type Fn$1 as Fn, type FormatGroupOptions, type FormatNumericOptions, type Key, type MergeInsertions, type Noop, type Nullable, type NumberObject, type Numberish, type Numeric, type NumericObject, type Option, type PromiseFn, type PromiseType, type StringObject, type SymbolObject, type Typeof, 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, isTruthy, isTypeof, isWeex, isWindow, jsonTryParse, kebabCase, loop, lt, lte, noCase, noop, numerfix, objectToForm, parseNumeric, pascalCase, pascalSnakeCase, pathCase, percentage, pipe, plus, randomArray, randomNumer, riposte, sentenceCase, snakeCase, trainCase, unwrap, whenever, zerofill, zeromove };

package/dist/index.global.js

@@ -4361,8 +4361,24 @@
     return getTypeof(target) === type;
   }
 
+  // src/util/compose-promise.ts
+  function pCompose(...fns) {
+    if (fns.length === 0)
+      throw new Error("Expected at least one argument");
+    return async (input) => {
+      let value = input;
+      for (const fn of fns.reverse())
+        value = await fn(value);
+      return value;
+    };
+  }
+
   // src/util/compose.ts
-  var compose = (...fns) => fns.reduceRight((v, f) => f(v));
+  function compose(...fns) {
+    const fn = fns.pop();
+    return fns.reduceRight((v, f) => f(v), fn);
+  }
+  compose.promise = pCompose;
 
   // src/util/converts.ts
   function formToObject(formData) {
@@ -4422,6 +4438,7 @@
   var isMobile = () => isBrowser() && navigator.userAgent.toLowerCase().includes("mobile");
   var isFormData = (value) => isObject_default(value) && isBrowser() && value instanceof FormData;
   var isWindow = (value) => typeof window !== "undefined" && toString.call(value) === "[object Window]";
+  var isTruthy = (value) => Boolean(value);
 
   // src/util/json.ts
   function jsonTryParse(text) {
@@ -4432,20 +4449,23 @@
     }
   }
 
-  // src/util/p-pipe.ts
-  function pPipe(...functions) {
-    if (functions.length === 0)
+  // src/util/pipe-promise.ts
+  function pPipe(...fns) {
+    if (fns.length === 0)
       throw new Error("Expected at least one argument");
     return async (input) => {
-      let currentValue = input;
-      for (const function_ of functions)
-        currentValue = await function_(currentValue);
-      return currentValue;
+      let value = input;
+      for (const fn of fns)
+        value = await fn(value);
+      return value;
     };
   }
 
   // src/util/pipe.ts
-  var pipe = (...fns) => fns.reduce((v, f) => f(v));
+  function pipe(...fns) {
+    return fns.reduce((v, f) => f(v));
+  }
+  pipe.promise = pPipe;
 
   // src/util/random.ts
   function randomNumer(min, max) {

package/dist/index.js

@@ -3016,8 +3016,24 @@ function isTypeof(target, type) {
   return getTypeof(target) === type;
 }
 
+// src/util/compose-promise.ts
+function pCompose(...fns) {
+  if (fns.length === 0)
+    throw new Error("Expected at least one argument");
+  return async (input) => {
+    let value = input;
+    for (const fn of fns.reverse())
+      value = await fn(value);
+    return value;
+  };
+}
+
 // src/util/compose.ts
-var compose = (...fns) => fns.reduceRight((v, f) => f(v));
+function compose(...fns) {
+  const fn = fns.pop();
+  return fns.reduceRight((v, f) => f(v), fn);
+}
+compose.promise = pCompose;
 
 // src/util/converts.ts
 function formToObject(formData) {
@@ -3077,6 +3093,7 @@ var isFF = () => typeof UA() === "string" && UA().match(/firefox\/(\d+)/);
 var isMobile = () => isBrowser() && navigator.userAgent.toLowerCase().includes("mobile");
 var isFormData = (value) => isObject_default(value) && isBrowser() && value instanceof FormData;
 var isWindow = (value) => typeof window !== "undefined" && toString.call(value) === "[object Window]";
+var isTruthy = (value) => Boolean(value);
 
 // src/util/json.ts
 function jsonTryParse(text) {
@@ -3087,20 +3104,23 @@ function jsonTryParse(text) {
   }
 }
 
-// src/util/p-pipe.ts
-function pPipe(...functions) {
-  if (functions.length === 0)
+// src/util/pipe-promise.ts
+function pPipe(...fns) {
+  if (fns.length === 0)
     throw new Error("Expected at least one argument");
   return async (input) => {
-    let currentValue = input;
-    for (const function_ of functions)
-      currentValue = await function_(currentValue);
-    return currentValue;
+    let value = input;
+    for (const fn of fns)
+      value = await fn(value);
+    return value;
   };
 }
 
 // src/util/pipe.ts
-var pipe = (...fns) => fns.reduce((v, f) => f(v));
+function pipe(...fns) {
+  return fns.reduce((v, f) => f(v));
+}
+pipe.promise = pPipe;
 
 // src/util/random.ts
 function randomNumer(min, max) {
@@ -3195,6 +3215,7 @@ export {
   isPhantomJS,
   isPlainObject_default as isPlainObject,
   isString_default as isString,
+  isTruthy,
   isTypeof,
   isUndefined_default as isUndefined,
   isWeex,
@@ -3212,7 +3233,6 @@ export {
   noop2 as noop,
   numerfix,
   objectToForm,
-  pPipe,
   parseNumeric,
   pascalCase,
   pascalSnakeCase,

package/package.json

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