rambda 10.1.0 → 10.3.0

package/index.d.cts

@@ -95,10 +95,10 @@ type Flatten<T> = T extends object
 				[K in keyof T]-?: NonNullable<T[K]> extends infer V
 					? V extends object
 						? V extends readonly any[]
-							? never 
+							? never
 							: Flatten<V>
 						: V
-					: never 
+					: never
 			}
 	: T;
 
@@ -109,17 +109,17 @@ export type FlattenObject<T extends object> = object extends T
           x: NonNullable<T[K]> extends infer V
             ? V extends object
               ? V extends readonly any[]
-                ? never 
+                ? never
                 : Flatten<V> extends infer FV
                   ? {
                       [P in keyof FV as `${Extract<K, string>}.${Extract<P, string>}`]: FV[P]
                     }
-                  : never 
+                  : never
               : Pick<T, K>
-            : never 
+            : never
         ) => void
       } extends Record<keyof T, (y: infer O) => void>
-    ? O 
+    ? O
     : never;
 
 /**
@@ -295,6 +295,8 @@ export function dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean): (list: T
 export function dropWhile<T>(predicate: (x: T, index: number) => boolean): (list: T[]) => T[];
 export function dropWhile<T>(predicate: (x: T) => boolean): (list: T[]) => T[];
 
+export function duplicateBy<T, U>(fn: (x: T) => U): (list: T[]) => T[];
+
 export function eqBy<T>(fn: (x: T) => unknown, a: T): (b: T) => boolean;
 
 /**
@@ -340,6 +342,10 @@ export function filter<T>(
 	predicate: (value: T) => boolean,
 ): (list: T[]) => T[];
 
+export function filterAsync<T>(
+	predicate: (value: T) => Promise<boolean>,
+): (list: T[]) => Promise<T[]>;
+
 /**
  * It loops over each property of `obj` and returns a new object with only those properties that satisfy the `predicate`.
  */
@@ -408,13 +414,13 @@ export function groupBy<T, K extends string = string>(fn: (x: T) => K): (list: T
 /**
  * It returns the first element of list or string `input`. It returns `undefined` if array has length of 0.
  */
-export function head<T>(listOrString: T): T extends string ? string : 
-	T extends [] ? undefined: 
-		T extends readonly [infer F, ...infer R] ? F : 
+export function head<T>(listOrString: T): T extends string ? string :
+	T extends [] ? undefined:
+		T extends readonly [infer F, ...infer R] ? F :
 			T extends readonly [infer F] ? F :
 				T extends [infer F] ? F :
-					T extends [infer F, ...infer R] ? F : 
-						T extends unknown[] ? T[number] : 
+					T extends [infer F, ...infer R] ? F :
+						T extends unknown[] ? T[number] :
 							undefined;
 
 /**
@@ -425,6 +431,19 @@ export function head<T>(listOrString: T): T extends string ? string :
 export function includes<T extends string>(valueToFind: T): (input: string) => boolean;
 export function includes<T>(valueToFind: T): (input: T[]) => boolean;
 
+/**
+ * It transforms list of objects to object using specified property as the base for the returned object.
+ */
+export function indexBy<T, K extends keyof T>(
+  property: K
+): (list: readonly T[]) => Record<string, T>;
+export function indexBy<T, K extends keyof T>(
+  property: K
+): (list: T[]) => Record<string, T>;
+
+// API_MARKER_END
+// ============================================
+
 /**
  * It uses `R.equals` for list of objects/arrays or native `indexOf` for any other case.
  */
@@ -449,10 +468,6 @@ export function innerJoin<T1, T2>(
  */
 export function interpolate(inputWithTags: string): (templateArguments: object) => string;
 
-
-// API_MARKER_END
-// ===========================================
-
 /**
  * It loops through `listA` and `listB` and returns the intersection of the two according to `R.equals`.
  */
@@ -471,13 +486,13 @@ export function join<T>(glue: string): (list: T[]) => string;
 /**
  * It returns the last element of `input`, as the `input` can be either a string or an array. It returns `undefined` if array has length of 0.
  */
-export function last<T>(listOrString: T): T extends string ? string : 
-  T extends [] ? undefined : 
-    T extends readonly [...infer R, infer L] ? L : 
+export function last<T>(listOrString: T): T extends string ? string :
+  T extends [] ? undefined :
+    T extends readonly [...infer R, infer L] ? L :
       T extends readonly [infer L] ? L :
         T extends [infer L] ? L :
-          T extends [...infer R, infer L] ? L : 
-            T extends unknown[] ? T[number] : 
+          T extends [...infer R, infer L] ? L :
+            T extends unknown[] ? T[number] :
               undefined;
 
 /**
@@ -518,14 +533,6 @@ export function mapAsync<T extends IterableContainer, U>(
 export function mapAsync<T extends IterableContainer, U>(
   fn: (value: T[number]) => Promise<U>,
 ): (data: T) => Promise<Mapped<T, U>>;
-export function mapAsync<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
-export function mapAsync<T extends IterableContainer, U>(
-  fn: (value: T[number]) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
 
 /**
  * It returns a copy of `obj` with keys transformed by `fn`.
@@ -557,14 +564,19 @@ export function mapParallelAsync<T extends IterableContainer, U>(
 export function mapParallelAsync<T extends IterableContainer, U>(
   fn: (value: T[number]) => Promise<U>,
 ): (data: T) => Promise<Mapped<T, U>>;
-export function mapParallelAsync<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
-export function mapParallelAsync<T extends IterableContainer, U>(
-  fn: (value: T[number]) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
+
+/**
+ * It maps over a property of object that is a list.
+ */
+export function mapPropObject<T extends object, K extends keyof T, Value>(
+  valueMapper: (
+    value: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
+    data: T[K],
+  ) => Value,
+    prop: K,
+): (data: T) => T[K] extends ReadonlyArray<any>
+  ? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
+  : never;
 
 /**
  * Curried version of `String.prototype.match` which returns empty array, when there is no match.
@@ -597,6 +609,123 @@ export function minBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
  */
 export function modifyItemAtIndex<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
 
+/**
+ * It changes a property of object on the base of provided path and transformer function.
+ */
+export function modifyPath<U, T>(path: [], fn: (value: U) => T): (obj: U) => T;
+export function modifyPath<
+  K0 extends keyof U,
+  U,
+  T
+>(path: [K0], fn: (value: U[K0]) => T): (obj: U) => DeepModify<[K0], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  U,
+  T
+>(path: `${K0}`, fn: (value: U[K0]) => T): (obj: U) => DeepModify<[K0], U, T>;
+export function modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  U,
+  T
+>(path: [K0, K1], fn: (value: U[K0][K1]) => T): (obj: U) => DeepModify<[K0, K1], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  K1 extends string & keyof U[K0],
+  U,
+  T
+>(path: `${K0}.${K1}`, fn: (value: U[K0][K1]) => T): (obj: U) => DeepModify<[K0, K1], U, T>;
+export function modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  K2 extends keyof U[K0][K1],
+  U,
+  T
+>(path: [K0, K1, K2], fn: (value: U[K0][K1][K2]) => T): (obj: U) => DeepModify<[K0, K1, K2], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  K1 extends string & keyof U[K0],
+  K2 extends string & keyof U[K0][K1],
+  U,
+  T
+>(path: `${K0}.${K1}.${K2}`, fn: (value: U[K0][K1][K2]) => T): (obj: U) => DeepModify<[K0, K1, K2], U, T>;
+export function modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  K2 extends keyof U[K0][K1],
+  K3 extends keyof U[K0][K1][K2],
+  U,
+  T
+>(path: [K0, K1, K2, K3], fn: (value: U[K0][K1][K2][K3]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  K1 extends string & keyof U[K0],
+  K2 extends string & keyof U[K0][K1],
+  K3 extends string & keyof U[K0][K1][K2],
+  U,
+  T
+>(path: `${K0}.${K1}.${K2}.${K3}`, fn: (value: U[K0][K1][K2][K3]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3], U, T>;
+export function modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  K2 extends keyof U[K0][K1],
+  K3 extends keyof U[K0][K1][K2],
+  K4 extends keyof U[K0][K1][K2][K3],
+  U,
+  T
+>(path: [K0, K1, K2, K3, K4], fn: (value: U[K0][K1][K2][K3][K4]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3, K4], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  K1 extends string & keyof U[K0],
+  K2 extends string & keyof U[K0][K1],
+  K3 extends string & keyof U[K0][K1][K2],
+  K4 extends string & keyof U[K0][K1][K2][K3],
+  U,
+  T
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}`, fn: (value: U[K0][K1][K2][K3][K4]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3, K4], U, T>;
+export function modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  K2 extends keyof U[K0][K1],
+  K3 extends keyof U[K0][K1][K2],
+  K4 extends keyof U[K0][K1][K2][K3],
+  K5 extends keyof U[K0][K1][K2][K3][K4],
+  U,
+  T
+>(path: [K0, K1, K2, K3, K4, K5], fn: (value: U[K0][K1][K2][K3][K4][K5]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3, K4, K5], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  K1 extends string & keyof U[K0],
+  K2 extends string & keyof U[K0][K1],
+  K3 extends string & keyof U[K0][K1][K2],
+  K4 extends string & keyof U[K0][K1][K2][K3],
+  K5 extends string & keyof U[K0][K1][K2][K3][K4],
+  U,
+  T
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}`, fn: (value: U[K0][K1][K2][K3][K4][K5]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3, K4, K5], U, T>;
+export function modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  K2 extends keyof U[K0][K1],
+  K3 extends keyof U[K0][K1][K2],
+  K4 extends keyof U[K0][K1][K2][K3],
+  K5 extends keyof U[K0][K1][K2][K3][K4],
+  K6 extends keyof U[K0][K1][K2][K3][K4][K5],
+  U,
+  T
+>(path: [K0, K1, K2, K3, K4, K5, K6], fn: (value: U[K0][K1][K2][K3][K4][K5][K6]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3, K4, K5, K6], U, T>;
+export function modifyPath<
+  K0 extends string & keyof U,
+  K1 extends string & keyof U[K0],
+  K2 extends string & keyof U[K0][K1],
+  K3 extends string & keyof U[K0][K1][K2],
+  K4 extends string & keyof U[K0][K1][K2][K3],
+  K5 extends string & keyof U[K0][K1][K2][K3][K4],
+  K6 extends string & keyof U[K0][K1][K2][K3][K4][K5],
+  U,
+  T
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}`, fn: (value: U[K0][K1][K2][K3][K4][K5][K6]) => T): (obj: U) => DeepModify<[K0, K1, K2, K3, K4, K5, K6], U, T>;
+
 /**
  * It changes a property with the result of transformer function.
  */
@@ -1450,7 +1579,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M>(
   fn10: (x: Awaited<K>) => L,
   fn11: (x: Awaited<L>) => M,
 ): M;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1467,7 +1595,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
   fn11: (x: Awaited<L>) => M,
   fn12: (x: Awaited<M>) => N,
 ): N;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1485,7 +1612,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
   fn12: (x: Awaited<M>) => N,
   fn13: (x: Awaited<N>) => O,
 ): O;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1504,7 +1630,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
   fn13: (x: Awaited<N>) => O,
   fn14: (x: Awaited<O>) => P,
 ): P;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1524,7 +1649,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
   fn14: (x: Awaited<O>) => P,
   fn15: (x: Awaited<P>) => Q,
 ): Q;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1545,7 +1669,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
   fn15: (x: Awaited<P>) => Q,
   fn16: (x: Awaited<Q>) => R,
 ): R;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1567,7 +1690,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R,
   fn16: (x: Awaited<Q>) => R,
   fn17: (x: Awaited<R>) => S,
 ): S;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1590,7 +1712,6 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R,
   fn17: (x: Awaited<R>) => S,
   fn18: (x: Awaited<S>) => T,
 ): T;
-
 export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
   input: A,
   fn0: (x: Awaited<A>) => B,
@@ -1620,6 +1741,10 @@ export function pipeAsync<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R,
  * Basically, this is `R.map(R.prop(property))`.
  */
 export function pluck<T, K extends keyof T>(property: K): (list: T[]) => T[K][];
+export function pluck<K extends PropertyKey>(prop: K): {
+  <U extends O[keyof O], UK extends keyof U, O extends Record<string, any>>(obj: K extends UK ? O : never): { [OK in keyof O]: O[OK][K] };
+  <U extends readonly unknown[] | Record<K, any>>(list: readonly U[]): U extends readonly (infer T)[] ? T[] : U extends Record<K, infer T> ? T[] : never;
+};
 
 /**
  * It adds element `x` at the beginning of `list`.
@@ -1696,6 +1821,11 @@ export function rejectObject<T extends object>(
  */
 export function replace(strOrRegex: RegExp | string, replacer: RegExp | string): (str: string) => string;
 
+/**
+ * Same as `R.replace` but it accepts array of string and regular expressions instead of a single value.
+ */
+export function replaceAll(patterns: (RegExp | string)[], replacer: string): (input: string) => string;
+
 /**
  * It returns a randomized copy of array.
  */
@@ -2114,6 +2244,11 @@ export function tap<T>(fn: (x: T) => void): (input: T) => T;
  */
 export function test(regExpression: RegExp): (str: string) => boolean;
 
+export function transformPropObject<T extends object, K extends keyof T, Value>(
+  valueMapper: (value: T[K]) => Value,
+  prop: K,
+): (data: T) => MergeTypes<Omit<T, K> & { [P in K]: Value }>;
+
 /**
  * It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result.
  */