@nlozgachev/pipelined 0.64.0 → 0.65.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/Core-BDXRLmMa.cjs +6147 -0
- package/dist/Core-BHN87zoB.mjs +6010 -0
- package/dist/InternalTypes-B1Lh9uw_.d.cts +143 -0
- package/dist/InternalTypes-DzDey5Do.d.ts +143 -0
- package/dist/composition.cjs +724 -632
- package/dist/composition.d.cts +453 -446
- package/dist/composition.d.ts +453 -446
- package/dist/composition.mjs +695 -577
- package/dist/core.cjs +24 -6580
- package/dist/core.d.cts +3 -2627
- package/dist/core.d.ts +3 -2627
- package/dist/core.mjs +2 -6532
- package/dist/data.cjs +2889 -3682
- package/dist/data.d.cts +1234 -1228
- package/dist/data.d.ts +1234 -1228
- package/dist/data.mjs +2880 -3647
- package/dist/index-B07Wr815.d.ts +4383 -0
- package/dist/index-Bs8En5LJ.d.cts +238 -0
- package/dist/index-Bs8En5LJ.d.ts +238 -0
- package/dist/index-DCK_VPog.d.cts +4383 -0
- package/dist/index.cjs +69 -9607
- package/dist/index.d.cts +6 -7
- package/dist/index.d.ts +6 -7
- package/dist/index.mjs +5 -9517
- package/dist/types.cjs +195 -225
- package/dist/types.d.cts +2 -58
- package/dist/types.d.ts +2 -58
- package/dist/types.mjs +192 -196
- package/package.json +24 -15
- package/dist/Duration-DeyxG6VQ.d.cts +0 -181
- package/dist/Duration-DeyxG6VQ.d.ts +0 -181
- package/dist/InternalTypes-CCXa8Kvr.d.ts +0 -142
- package/dist/InternalTypes-GFn4RTwD.d.cts +0 -142
- package/dist/Task-9SJCMtG4.d.ts +0 -1748
- package/dist/Task-C_goFYQ1.d.cts +0 -1748
package/dist/composition.d.cts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
|
|
1
|
+
import { n as Duration } from "./index-Bs8En5LJ.cjs";
|
|
2
|
+
import { a as Thenable, t as Awaitable } from "./InternalTypes-B1Lh9uw_.cjs";
|
|
3
|
+
//#region src/Composition/compose.d.ts
|
|
4
4
|
/**
|
|
5
5
|
* Composes functions from right to left, returning a new function.
|
|
6
6
|
* This is the traditional mathematical function composition: (f . g)(x) = f(g(x))
|
|
@@ -27,17 +27,18 @@ import { D as Duration } from './Duration-DeyxG6VQ.cjs';
|
|
|
27
27
|
*
|
|
28
28
|
* @see {@link flow} for left-to-right composition
|
|
29
29
|
*/
|
|
30
|
-
declare function compose<A, B>(ab: (a: A) => B): (a: A) => B;
|
|
31
|
-
declare function compose<A, B, C>(bc: (b: B) => C, ab: (a: A) => B): (a: A) => C;
|
|
32
|
-
declare function compose<A, B, C, D>(cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => D;
|
|
33
|
-
declare function compose<A, B, C, D, E>(de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => E;
|
|
34
|
-
declare function compose<A, B, C, D, E, F>(ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => F;
|
|
35
|
-
declare function compose<A, B, C, D, E, F, G>(fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => G;
|
|
36
|
-
declare function compose<A, B, C, D, E, F, G, H>(gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => H;
|
|
37
|
-
declare function compose<A, B, C, D, E, F, G, H, I>(hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => I;
|
|
38
|
-
declare function compose<A, B, C, D, E, F, G, H, I, J>(ij: (i: I) => J, hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => J;
|
|
39
|
-
declare function compose<A, B, C, D, E, F, G, H, I, J, K>(jk: (j: J) => K, ij: (i: I) => J, hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => K;
|
|
40
|
-
|
|
30
|
+
export declare function compose<A, B>(ab: (a: A) => B): (a: A) => B;
|
|
31
|
+
export declare function compose<A, B, C>(bc: (b: B) => C, ab: (a: A) => B): (a: A) => C;
|
|
32
|
+
export declare function compose<A, B, C, D>(cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => D;
|
|
33
|
+
export declare function compose<A, B, C, D, E>(de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => E;
|
|
34
|
+
export declare function compose<A, B, C, D, E, F>(ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => F;
|
|
35
|
+
export declare function compose<A, B, C, D, E, F, G>(fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => G;
|
|
36
|
+
export declare function compose<A, B, C, D, E, F, G, H>(gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => H;
|
|
37
|
+
export declare function compose<A, B, C, D, E, F, G, H, I>(hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => I;
|
|
38
|
+
export declare function compose<A, B, C, D, E, F, G, H, I, J>(ij: (i: I) => J, hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => J;
|
|
39
|
+
export declare function compose<A, B, C, D, E, F, G, H, I, J, K>(jk: (j: J) => K, ij: (i: I) => J, hi: (h: H) => I, gh: (g: G) => H, fg: (f: F) => G, ef: (e: E) => F, de: (d: D) => E, cd: (c: C) => D, bc: (b: B) => C, ab: (a: A) => B): (a: A) => K;
|
|
40
|
+
//#endregion
|
|
41
|
+
//#region src/Composition/converge.d.ts
|
|
41
42
|
/**
|
|
42
43
|
* Applies an input to several transformer functions independently, then passes all results to a
|
|
43
44
|
* combining function.
|
|
@@ -55,10 +56,11 @@ declare function compose<A, B, C, D, E, F, G, H, I, J, K>(jk: (j: J) => K, ij: (
|
|
|
55
56
|
* toNameRecord(" Alice Bob "); // { trimmed: "Alice Bob", initials: "AB" }
|
|
56
57
|
* ```
|
|
57
58
|
*/
|
|
58
|
-
declare function converge<A, B, C, R>(f: (b: B, c: C) => R, transformers: [(a: A) => B, (a: A) => C]): (a: A) => R;
|
|
59
|
-
declare function converge<A, B, C, D, R>(f: (b: B, c: C, d: D) => R, transformers: [(a: A) => B, (a: A) => C, (a: A) => D]): (a: A) => R;
|
|
60
|
-
declare function converge<A, B, C, D, E, R>(f: (b: B, c: C, d: D, e: E) => R, transformers: [(a: A) => B, (a: A) => C, (a: A) => D, (a: A) => E]): (a: A) => R;
|
|
61
|
-
|
|
59
|
+
export declare function converge<A, B, C, R>(f: (b: B, c: C) => R, transformers: [(a: A) => B, (a: A) => C]): (a: A) => R;
|
|
60
|
+
export declare function converge<A, B, C, D, R>(f: (b: B, c: C, d: D) => R, transformers: [(a: A) => B, (a: A) => C, (a: A) => D]): (a: A) => R;
|
|
61
|
+
export declare function converge<A, B, C, D, E, R>(f: (b: B, c: C, d: D, e: E) => R, transformers: [(a: A) => B, (a: A) => C, (a: A) => D, (a: A) => E]): (a: A) => R;
|
|
62
|
+
//#endregion
|
|
63
|
+
//#region src/Composition/curry.d.ts
|
|
62
64
|
/**
|
|
63
65
|
* Converts a multi-argument function into a curried function.
|
|
64
66
|
* The inverse of `uncurry`.
|
|
@@ -78,7 +80,7 @@ declare function converge<A, B, C, D, E, R>(f: (b: B, c: C, d: D, e: E) => R, tr
|
|
|
78
80
|
* @see {@link curry3} for 3-argument functions
|
|
79
81
|
* @see {@link curry4} for 4-argument functions
|
|
80
82
|
*/
|
|
81
|
-
declare const curry: <A, B, C>(f: (a: A, b: B) => C) => (a: A) => (b: B) => C;
|
|
83
|
+
export declare const curry: <A, B, C>(f: (a: A, b: B) => C) => (a: A) => (b: B) => C;
|
|
82
84
|
/**
|
|
83
85
|
* Converts a 3-argument function into a curried function.
|
|
84
86
|
*
|
|
@@ -89,7 +91,7 @@ declare const curry: <A, B, C>(f: (a: A, b: B) => C) => (a: A) => (b: B) => C;
|
|
|
89
91
|
* curriedAdd3(1)(2)(3); // 6
|
|
90
92
|
* ```
|
|
91
93
|
*/
|
|
92
|
-
declare const curry3: <A, B, C, D>(f: (a: A, b: B, c: C) => D) => (a: A) => (b: B) => (c: C) => D;
|
|
94
|
+
export declare const curry3: <A, B, C, D>(f: (a: A, b: B, c: C) => D) => (a: A) => (b: B) => (c: C) => D;
|
|
93
95
|
/**
|
|
94
96
|
* Converts a 4-argument function into a curried function.
|
|
95
97
|
*
|
|
@@ -100,8 +102,9 @@ declare const curry3: <A, B, C, D>(f: (a: A, b: B, c: C) => D) => (a: A) => (b:
|
|
|
100
102
|
* curriedAdd4(1)(2)(3)(4); // 10
|
|
101
103
|
* ```
|
|
102
104
|
*/
|
|
103
|
-
declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A) => (b: B) => (c: C) => (d: D) => E;
|
|
104
|
-
|
|
105
|
+
export declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A) => (b: B) => (c: C) => (d: D) => E;
|
|
106
|
+
//#endregion
|
|
107
|
+
//#region src/Composition/flip.d.ts
|
|
105
108
|
/**
|
|
106
109
|
* Flips the order of arguments for a curried binary function.
|
|
107
110
|
* Converts a data-last function to data-first.
|
|
@@ -121,28 +124,9 @@ declare const curry4: <A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E) => (a: A
|
|
|
121
124
|
*
|
|
122
125
|
* @see {@link uncurry} for converting curried functions to multi-argument functions
|
|
123
126
|
*/
|
|
124
|
-
declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
declare function safe$1<A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
|
|
128
|
-
declare function safe$1<A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
|
|
129
|
-
declare function safe$1<A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
|
|
130
|
-
declare function safe$1<A, B, C, D, E, F>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
|
|
131
|
-
declare function safe$1<A, B, C, D, E, F, G>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
|
|
132
|
-
declare function safe$1<A, B, C, D, E, F, G, H>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
|
|
133
|
-
declare function safe$1<A, B, C, D, E, F, G, H, I>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): (a: A) => I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
|
|
134
|
-
declare function safe$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): (a: A) => J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
|
|
135
|
-
declare function safe$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
|
|
136
|
-
declare function async$1<A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
|
|
137
|
-
declare function async$1<A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
|
|
138
|
-
declare function async$1<A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
|
|
139
|
-
declare function async$1<A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
|
|
140
|
-
declare function async$1<A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
|
|
141
|
-
declare function async$1<A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
|
|
142
|
-
declare function async$1<A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
|
|
143
|
-
declare function async$1<A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
|
|
144
|
-
declare function async$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
|
|
145
|
-
declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
|
|
127
|
+
export declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
|
|
128
|
+
//#endregion
|
|
129
|
+
//#region src/Composition/flow.d.ts
|
|
146
130
|
/**
|
|
147
131
|
* Composes functions from left to right, returning a new function.
|
|
148
132
|
* Unlike `pipe`, `flow` doesn't take an initial value - it creates
|
|
@@ -185,153 +169,172 @@ declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitabl
|
|
|
185
169
|
*
|
|
186
170
|
* @see {@link pipe} for immediate value transformation
|
|
187
171
|
*/
|
|
188
|
-
declare function flow<A extends ReadonlyArray<unknown>, B>(ab: (...a: A) => B): (...a: A) => B;
|
|
189
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
|
|
190
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
|
|
191
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
|
|
192
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
|
|
193
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
|
|
194
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): (...a: A) => H;
|
|
195
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (...a: A) => I;
|
|
196
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;
|
|
197
|
-
declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J, K>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): (...a: A) => K;
|
|
198
|
-
declare namespace flow {
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
172
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B>(ab: (...a: A) => B): (...a: A) => B;
|
|
173
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C>(ab: (...a: A) => B, bc: (b: B) => C): (...a: A) => C;
|
|
174
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...a: A) => D;
|
|
175
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): (...a: A) => E;
|
|
176
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): (...a: A) => F;
|
|
177
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): (...a: A) => G;
|
|
178
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): (...a: A) => H;
|
|
179
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): (...a: A) => I;
|
|
180
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): (...a: A) => J;
|
|
181
|
+
export declare function flow<A extends ReadonlyArray<unknown>, B, C, D, E, F, G, H, I, J, K>(ab: (...a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): (...a: A) => K;
|
|
182
|
+
export declare namespace flow {
|
|
183
|
+
export var when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
|
|
184
|
+
export var unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
|
|
185
|
+
export var either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
|
|
186
|
+
export var struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
|
|
187
|
+
export var safe: {
|
|
188
|
+
<A, B>(ab: (a: NonNullable<A>) => B): (a: A) => B | Extract<A, null | undefined>;
|
|
189
|
+
<A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
|
|
190
|
+
<A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
|
|
191
|
+
<A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
|
|
192
|
+
<A, B, C, D, E, F>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
|
|
193
|
+
<A, B, C, D, E, F, G>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
|
|
194
|
+
<A, B, C, D, E, F, G, H>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
|
|
195
|
+
<A, B, C, D, E, F, G, H, I>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): (a: A) => I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
|
|
196
|
+
<A, B, C, D, E, F, G, H, I, J>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): (a: A) => J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
|
|
197
|
+
<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
|
|
198
|
+
};
|
|
199
|
+
export var async: {
|
|
200
|
+
<A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
|
|
201
|
+
<A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
|
|
202
|
+
<A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
|
|
203
|
+
<A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
|
|
204
|
+
<A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
|
|
205
|
+
<A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
|
|
206
|
+
<A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
|
|
207
|
+
<A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
|
|
208
|
+
<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
|
|
209
|
+
<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
|
|
210
|
+
};
|
|
211
|
+
var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
|
|
212
|
+
export { _a as try };
|
|
229
213
|
}
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
214
|
+
declare function safe$1<A, B>(ab: (a: NonNullable<A>) => B): (a: A) => B | Extract<A, null | undefined>;
|
|
215
|
+
declare function safe$1<A, B, C>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): (a: A) => C | Extract<A | B, null | undefined>;
|
|
216
|
+
declare function safe$1<A, B, C, D>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): (a: A) => D | Extract<A | B | C, null | undefined>;
|
|
217
|
+
declare function safe$1<A, B, C, D, E>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): (a: A) => E | Extract<A | B | C | D, null | undefined>;
|
|
218
|
+
declare function safe$1<A, B, C, D, E, F>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F): (a: A) => F | Extract<A | B | C | D | E, null | undefined>;
|
|
219
|
+
declare function safe$1<A, B, C, D, E, F, G>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G): (a: A) => G | Extract<A | B | C | D | E | F, null | undefined>;
|
|
220
|
+
declare function safe$1<A, B, C, D, E, F, G, H>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H): (a: A) => H | Extract<A | B | C | D | E | F | G, null | undefined>;
|
|
221
|
+
declare function safe$1<A, B, C, D, E, F, G, H, I>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): (a: A) => I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
|
|
222
|
+
declare function safe$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): (a: A) => J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
|
|
223
|
+
declare function safe$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): (a: A) => K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
|
|
224
|
+
declare function async$1<A, B>(ab: (a: A) => Awaitable<B>): (a: Awaitable<A>) => Promise<B>;
|
|
225
|
+
declare function async$1<A, B, C>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): (a: Awaitable<A>) => Promise<C>;
|
|
226
|
+
declare function async$1<A, B, C, D>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): (a: Awaitable<A>) => Promise<D>;
|
|
227
|
+
declare function async$1<A, B, C, D, E>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): (a: Awaitable<A>) => Promise<E>;
|
|
228
|
+
declare function async$1<A, B, C, D, E, F>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): (a: Awaitable<A>) => Promise<F>;
|
|
229
|
+
declare function async$1<A, B, C, D, E, F, G>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): (a: Awaitable<A>) => Promise<G>;
|
|
230
|
+
declare function async$1<A, B, C, D, E, F, G, H>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): (a: Awaitable<A>) => Promise<H>;
|
|
231
|
+
declare function async$1<A, B, C, D, E, F, G, H, I>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): (a: Awaitable<A>) => Promise<I>;
|
|
232
|
+
declare function async$1<A, B, C, D, E, F, G, H, I, J>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): (a: Awaitable<A>) => Promise<J>;
|
|
233
|
+
declare function async$1<A, B, C, D, E, F, G, H, I, J, K>(ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): (a: Awaitable<A>) => Promise<K>;
|
|
234
|
+
export interface flow {
|
|
235
|
+
/**
|
|
236
|
+
* Executes a function on the piped value if a predicate is met, otherwise returns the value unchanged.
|
|
237
|
+
*
|
|
238
|
+
* @example
|
|
239
|
+
* ```ts
|
|
240
|
+
* const doubleIfEven = flow.when(
|
|
241
|
+
* (n: number) => n % 2 === 0,
|
|
242
|
+
* n => n * 2
|
|
243
|
+
* );
|
|
244
|
+
* doubleIfEven(4); // 8
|
|
245
|
+
* doubleIfEven(5); // 5
|
|
246
|
+
* ```
|
|
247
|
+
*/
|
|
248
|
+
readonly when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
|
|
249
|
+
/**
|
|
250
|
+
* Executes a function on the piped value if a predicate is NOT met, otherwise returns the value unchanged.
|
|
251
|
+
*
|
|
252
|
+
* @example
|
|
253
|
+
* ```ts
|
|
254
|
+
* const doubleIfOdd = flow.unless(
|
|
255
|
+
* (n: number) => n % 2 === 0,
|
|
256
|
+
* n => n * 2
|
|
257
|
+
* );
|
|
258
|
+
* doubleIfOdd(5); // 10
|
|
259
|
+
* doubleIfOdd(4); // 4
|
|
260
|
+
* ```
|
|
261
|
+
*/
|
|
262
|
+
readonly unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
|
|
263
|
+
/**
|
|
264
|
+
* Executes one of two functions based on a predicate, acting as a functional if-else/ternary helper.
|
|
265
|
+
*
|
|
266
|
+
* @example
|
|
267
|
+
* ```ts
|
|
268
|
+
* const formatNumber = flow.either(
|
|
269
|
+
* (n: number) => n >= 0,
|
|
270
|
+
* n => `+${n}`,
|
|
271
|
+
* n => `${n}`
|
|
272
|
+
* );
|
|
273
|
+
* formatNumber(5); // "+5"
|
|
274
|
+
* formatNumber(-3); // "-3"
|
|
275
|
+
* ```
|
|
276
|
+
*/
|
|
277
|
+
readonly either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
|
|
278
|
+
/**
|
|
279
|
+
* Creates a pipeline step that wraps a throwing function in a try/catch, returning a fallback value if an error occurs.
|
|
280
|
+
*
|
|
281
|
+
* @example
|
|
282
|
+
* ```ts
|
|
283
|
+
* const safeParse = flow.try(
|
|
284
|
+
* (s: string) => JSON.parse(s),
|
|
285
|
+
* (_err, _s) => null
|
|
286
|
+
* );
|
|
287
|
+
* safeParse('{"a":1}'); // { a: 1 }
|
|
288
|
+
* safeParse('invalid'); // null
|
|
289
|
+
* ```
|
|
290
|
+
*/
|
|
291
|
+
readonly try: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
|
|
292
|
+
/**
|
|
293
|
+
* Builds an object by applying a record of field-level transformer functions to the piped input.
|
|
294
|
+
*
|
|
295
|
+
* @example
|
|
296
|
+
* ```ts
|
|
297
|
+
* type User = { name: string; age: number };
|
|
298
|
+
* const summarizeUser = flow.struct<User, { name: string; isAdult: boolean }>({
|
|
299
|
+
* name: u => u.name,
|
|
300
|
+
* isAdult: u => u.age >= 18,
|
|
301
|
+
* });
|
|
302
|
+
* summarizeUser({ name: "Alice", age: 25 }); // { name: "Alice", isAdult: true }
|
|
303
|
+
* ```
|
|
304
|
+
*/
|
|
305
|
+
readonly struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
|
|
306
|
+
/**
|
|
307
|
+
* Pipes a value through a sequence of operations, short-circuiting and propagating
|
|
308
|
+
* null or undefined immediately if any intermediate step evaluates to nil.
|
|
309
|
+
*
|
|
310
|
+
* @example
|
|
311
|
+
* ```ts
|
|
312
|
+
* const getCityLength = flow.safe(
|
|
313
|
+
* (user: { address?: { city?: string } }) => user.address,
|
|
314
|
+
* address => address.city,
|
|
315
|
+
* city => city.length
|
|
316
|
+
* );
|
|
317
|
+
* getCityLength({ address: { city: "Paris" } }); // 5
|
|
318
|
+
* getCityLength({}); // undefined
|
|
319
|
+
* ```
|
|
320
|
+
*/
|
|
321
|
+
readonly safe: typeof safe$1;
|
|
322
|
+
/**
|
|
323
|
+
* Pipes a value through a sequence of operations, supporting asynchronous transitions at any step.
|
|
324
|
+
*
|
|
325
|
+
* @example
|
|
326
|
+
* ```ts
|
|
327
|
+
* const processId = flow.async(
|
|
328
|
+
* (id: number) => Promise.resolve(`user-${id}`),
|
|
329
|
+
* name => name.toUpperCase()
|
|
330
|
+
* );
|
|
331
|
+
* await processId(42); // "USER-42"
|
|
332
|
+
* ```
|
|
333
|
+
*/
|
|
334
|
+
readonly async: typeof async$1;
|
|
333
335
|
}
|
|
334
|
-
|
|
336
|
+
//#endregion
|
|
337
|
+
//#region src/Composition/fn.d.ts
|
|
335
338
|
/**
|
|
336
339
|
* Returns the value unchanged. The identity function.
|
|
337
340
|
*
|
|
@@ -341,7 +344,7 @@ interface flow {
|
|
|
341
344
|
* pipe(Maybe.make.some(5), Maybe.fold(() => 0, identity)); // 5
|
|
342
345
|
* ```
|
|
343
346
|
*/
|
|
344
|
-
declare const identity: <A>(a: A) => A;
|
|
347
|
+
export declare const identity: <A>(a: A) => A;
|
|
345
348
|
/**
|
|
346
349
|
* Creates a function that always returns the given value, ignoring its argument.
|
|
347
350
|
*
|
|
@@ -352,7 +355,7 @@ declare const identity: <A>(a: A) => A;
|
|
|
352
355
|
* [1, 2, 3].map(constant("x")); // ["x", "x", "x"]
|
|
353
356
|
* ```
|
|
354
357
|
*/
|
|
355
|
-
declare const constant: <A>(a: A) => () => A;
|
|
358
|
+
export declare const constant: <A>(a: A) => () => A;
|
|
356
359
|
/**
|
|
357
360
|
* Always returns `true`.
|
|
358
361
|
*
|
|
@@ -361,7 +364,7 @@ declare const constant: <A>(a: A) => () => A;
|
|
|
361
364
|
* constTrue(); // true
|
|
362
365
|
* ```
|
|
363
366
|
*/
|
|
364
|
-
declare const constTrue: () => true;
|
|
367
|
+
export declare const constTrue: () => true;
|
|
365
368
|
/**
|
|
366
369
|
* Always returns `false`.
|
|
367
370
|
*
|
|
@@ -370,7 +373,7 @@ declare const constTrue: () => true;
|
|
|
370
373
|
* constFalse(); // false
|
|
371
374
|
* ```
|
|
372
375
|
*/
|
|
373
|
-
declare const constFalse: () => false;
|
|
376
|
+
export declare const constFalse: () => false;
|
|
374
377
|
/**
|
|
375
378
|
* Always returns `null`.
|
|
376
379
|
*
|
|
@@ -379,7 +382,7 @@ declare const constFalse: () => false;
|
|
|
379
382
|
* constNull(); // null
|
|
380
383
|
* ```
|
|
381
384
|
*/
|
|
382
|
-
declare const constNull: () => null;
|
|
385
|
+
export declare const constNull: () => null;
|
|
383
386
|
/**
|
|
384
387
|
* Always returns `undefined`.
|
|
385
388
|
*
|
|
@@ -388,7 +391,7 @@ declare const constNull: () => null;
|
|
|
388
391
|
* constUndefined(); // undefined
|
|
389
392
|
* ```
|
|
390
393
|
*/
|
|
391
|
-
declare const constUndefined: () => undefined;
|
|
394
|
+
export declare const constUndefined: () => undefined;
|
|
392
395
|
/**
|
|
393
396
|
* Always returns `void`.
|
|
394
397
|
*
|
|
@@ -397,7 +400,7 @@ declare const constUndefined: () => undefined;
|
|
|
397
400
|
* constVoid(); // undefined
|
|
398
401
|
* ```
|
|
399
402
|
*/
|
|
400
|
-
declare const constVoid: () => void;
|
|
403
|
+
export declare const constVoid: () => void;
|
|
401
404
|
/**
|
|
402
405
|
* Combines two predicates with logical AND.
|
|
403
406
|
*
|
|
@@ -412,7 +415,7 @@ declare const constVoid: () => void;
|
|
|
412
415
|
* isPositiveEven(3); // false
|
|
413
416
|
* ```
|
|
414
417
|
*/
|
|
415
|
-
declare const and: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean, p2: (...args: A) => boolean) => (...args: A) => boolean;
|
|
418
|
+
export declare const and: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean, p2: (...args: A) => boolean) => (...args: A) => boolean;
|
|
416
419
|
/**
|
|
417
420
|
* Combines two predicates with logical OR.
|
|
418
421
|
*
|
|
@@ -427,7 +430,7 @@ declare const and: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolea
|
|
|
427
430
|
* isNonPositive(1); // false
|
|
428
431
|
* ```
|
|
429
432
|
*/
|
|
430
|
-
declare const or: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean, p2: (...args: A) => boolean) => (...args: A) => boolean;
|
|
433
|
+
export declare const or: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean, p2: (...args: A) => boolean) => (...args: A) => boolean;
|
|
431
434
|
/**
|
|
432
435
|
* Creates a function that executes at most once.
|
|
433
436
|
* Subsequent calls return the cached result from the first execution.
|
|
@@ -441,7 +444,7 @@ declare const or: <A extends ReadonlyArray<unknown>>(p1: (...args: A) => boolean
|
|
|
441
444
|
* initOnce(); // "initialized", count === 1 (not called again)
|
|
442
445
|
* ```
|
|
443
446
|
*/
|
|
444
|
-
declare const once: <A>(f: () => A) => () => A;
|
|
447
|
+
export declare const once: <A>(f: () => A) => () => A;
|
|
445
448
|
/**
|
|
446
449
|
* Returns a fallback value if the input is null or undefined; otherwise returns the input value.
|
|
447
450
|
* Highly useful as a data-last default value step inside pipelines.
|
|
@@ -455,7 +458,7 @@ declare const once: <A>(f: () => A) => () => A;
|
|
|
455
458
|
* ); // returns string
|
|
456
459
|
* ```
|
|
457
460
|
*/
|
|
458
|
-
declare const defaultTo: <B>(fallback: B) => <A>(a: A) => NonNullable<A> | B;
|
|
461
|
+
export declare const defaultTo: <B>(fallback: B) => <A>(a: A) => NonNullable<A> | B;
|
|
459
462
|
/**
|
|
460
463
|
* Converts a function taking multiple arguments into a function taking a single tuple argument.
|
|
461
464
|
*
|
|
@@ -466,7 +469,7 @@ declare const defaultTo: <B>(fallback: B) => <A>(a: A) => NonNullable<A> | B;
|
|
|
466
469
|
* addTuple([2, 3]); // 5
|
|
467
470
|
* ```
|
|
468
471
|
*/
|
|
469
|
-
declare const tuple: <Args extends readonly unknown[], R>(f: (...args: Args) => R) => (args: Args) => R;
|
|
472
|
+
export declare const tuple: <Args extends readonly unknown[], R>(f: (...args: Args) => R) => (args: Args) => R;
|
|
470
473
|
/**
|
|
471
474
|
* Converts a function taking a single tuple argument into a function taking multiple arguments.
|
|
472
475
|
*
|
|
@@ -477,8 +480,9 @@ declare const tuple: <Args extends readonly unknown[], R>(f: (...args: Args) =>
|
|
|
477
480
|
* add(2, 3); // 5
|
|
478
481
|
* ```
|
|
479
482
|
*/
|
|
480
|
-
declare const untuple: <Args extends readonly unknown[], R>(f: (args: Args) => R) => (...args: Args) => R;
|
|
481
|
-
|
|
483
|
+
export declare const untuple: <Args extends readonly unknown[], R>(f: (args: Args) => R) => (...args: Args) => R;
|
|
484
|
+
//#endregion
|
|
485
|
+
//#region src/Composition/juxt.d.ts
|
|
482
486
|
/**
|
|
483
487
|
* Applies an input to an array of functions and collects the results into a tuple.
|
|
484
488
|
*
|
|
@@ -492,11 +496,12 @@ declare const untuple: <Args extends readonly unknown[], R>(f: (args: Args) => R
|
|
|
492
496
|
* nameParts("Alice Smith"); // ["Alice", "Smith"]
|
|
493
497
|
* ```
|
|
494
498
|
*/
|
|
495
|
-
declare function juxt<A, B, C>(fns: [(a: A) => B, (a: A) => C]): (a: A) => [B, C];
|
|
496
|
-
declare function juxt<A, B, C, D>(fns: [(a: A) => B, (a: A) => C, (a: A) => D]): (a: A) => [B, C, D];
|
|
497
|
-
declare function juxt<A, B, C, D, E>(fns: [(a: A) => B, (a: A) => C, (a: A) => D, (a: A) => E]): (a: A) => [B, C, D, E];
|
|
498
|
-
declare function juxt<A, B>(fns: ReadonlyArray<(a: A) => B>): (a: A) => B[];
|
|
499
|
-
|
|
499
|
+
export declare function juxt<A, B, C>(fns: [(a: A) => B, (a: A) => C]): (a: A) => [B, C];
|
|
500
|
+
export declare function juxt<A, B, C, D>(fns: [(a: A) => B, (a: A) => C, (a: A) => D]): (a: A) => [B, C, D];
|
|
501
|
+
export declare function juxt<A, B, C, D, E>(fns: [(a: A) => B, (a: A) => C, (a: A) => D, (a: A) => E]): (a: A) => [B, C, D, E];
|
|
502
|
+
export declare function juxt<A, B>(fns: ReadonlyArray<(a: A) => B>): (a: A) => B[];
|
|
503
|
+
//#endregion
|
|
504
|
+
//#region src/Composition/memoize.d.ts
|
|
500
505
|
/**
|
|
501
506
|
* Creates a memoized version of a function that caches results.
|
|
502
507
|
* Subsequent calls with the same argument return the cached result.
|
|
@@ -528,12 +533,12 @@ declare function juxt<A, B>(fns: ReadonlyArray<(a: A) => B>): (a: A) => B[];
|
|
|
528
533
|
* );
|
|
529
534
|
* ```
|
|
530
535
|
*/
|
|
531
|
-
declare const memoize: <A, B>(f: (a: A) => B, options?: {
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
536
|
+
export declare const memoize: <A, B>(f: (a: A) => B, options?: {
|
|
537
|
+
readonly key?: (a: A) => unknown;
|
|
538
|
+
/**
|
|
539
|
+
* Maximum number of entries to store in the cache before evicting the least recently used (LRU) entry.
|
|
540
|
+
*/
|
|
541
|
+
readonly maxSize?: number;
|
|
537
542
|
}) => (a: A) => B;
|
|
538
543
|
/**
|
|
539
544
|
* Creates a memoized version of a function using WeakMap.
|
|
@@ -555,8 +560,9 @@ declare const memoize: <A, B>(f: (a: A) => B, options?: {
|
|
|
555
560
|
* // When `user` is garbage collected, cached result is too
|
|
556
561
|
* ```
|
|
557
562
|
*/
|
|
558
|
-
declare const memoizeWeak: <A extends object, B>(f: (a: A) => B) => (a: A) => B;
|
|
559
|
-
|
|
563
|
+
export declare const memoizeWeak: <A extends object, B>(f: (a: A) => B) => (a: A) => B;
|
|
564
|
+
//#endregion
|
|
565
|
+
//#region src/Composition/not.d.ts
|
|
560
566
|
/**
|
|
561
567
|
* Negates a predicate function.
|
|
562
568
|
* Returns a new predicate that returns true when the original returns false, and vice versa.
|
|
@@ -583,8 +589,9 @@ declare const memoizeWeak: <A extends object, B>(f: (a: A) => B) => (a: A) => B;
|
|
|
583
589
|
* );
|
|
584
590
|
* ```
|
|
585
591
|
*/
|
|
586
|
-
declare const not: <A extends ReadonlyArray<unknown>>(predicate: (...args: A) => boolean) => (...args: A) => boolean;
|
|
587
|
-
|
|
592
|
+
export declare const not: <A extends ReadonlyArray<unknown>>(predicate: (...args: A) => boolean) => (...args: A) => boolean;
|
|
593
|
+
//#endregion
|
|
594
|
+
//#region src/Composition/on.d.ts
|
|
588
595
|
/**
|
|
589
596
|
* Applies a projection to both arguments of a binary function before calling it.
|
|
590
597
|
* Most useful for building comparators and equality checks over projected values.
|
|
@@ -596,30 +603,9 @@ declare const not: <A extends ReadonlyArray<unknown>>(predicate: (...args: A) =>
|
|
|
596
603
|
* ["banana", "fig", "apple"].sort(byLength); // ["fig", "apple", "banana"]
|
|
597
604
|
* ```
|
|
598
605
|
*/
|
|
599
|
-
declare const on: <A, B, C>(f: (b1: B, b2: B) => C, g: (a: A) => B) => (a: A, b: A) => C;
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
declare function safe<A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
|
|
603
|
-
declare function safe<A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
|
|
604
|
-
declare function safe<A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
|
|
605
|
-
declare function safe<A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
|
|
606
|
-
declare function safe<A, B, C, D, E, F>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F): F | Extract<A | B | C | D | E, null | undefined>;
|
|
607
|
-
declare function safe<A, B, C, D, E, F, G>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G): G | Extract<A | B | C | D | E | F, null | undefined>;
|
|
608
|
-
declare function safe<A, B, C, D, E, F, G, H>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H): H | Extract<A | B | C | D | E | F | G, null | undefined>;
|
|
609
|
-
declare function safe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
|
|
610
|
-
declare function safe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
|
|
611
|
-
declare function safe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
|
|
612
|
-
declare function async<A>(a: Awaitable<A>): Promise<A>;
|
|
613
|
-
declare function async<A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
|
|
614
|
-
declare function async<A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
|
|
615
|
-
declare function async<A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
|
|
616
|
-
declare function async<A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
|
|
617
|
-
declare function async<A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
|
|
618
|
-
declare function async<A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
|
|
619
|
-
declare function async<A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
|
|
620
|
-
declare function async<A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
|
|
621
|
-
declare function async<A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
|
|
622
|
-
declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
|
|
606
|
+
export declare const on: <A, B, C>(f: (b1: B, b2: B) => C, g: (a: A) => B) => (a: A, b: A) => C;
|
|
607
|
+
//#endregion
|
|
608
|
+
//#region src/Composition/pipe.d.ts
|
|
623
609
|
/**
|
|
624
610
|
* Pipes a value through a series of functions from left to right.
|
|
625
611
|
* Each function receives the output of the previous function.
|
|
@@ -658,147 +644,168 @@ declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a:
|
|
|
658
644
|
*
|
|
659
645
|
* @see {@link flow} for creating reusable pipelines without an initial value
|
|
660
646
|
*/
|
|
661
|
-
declare function pipe<A>(a: A): A;
|
|
662
|
-
declare function pipe<A, B>(a: A, ab: (a: A) => B): B;
|
|
663
|
-
declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
|
|
664
|
-
declare function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
|
|
665
|
-
declare function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
|
|
666
|
-
declare function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
|
|
667
|
-
declare function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
|
|
668
|
-
declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
|
|
669
|
-
declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
|
|
670
|
-
declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
|
|
671
|
-
declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
|
|
672
|
-
declare namespace pipe {
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
647
|
+
export declare function pipe<A>(a: A): A;
|
|
648
|
+
export declare function pipe<A, B>(a: A, ab: (a: A) => B): B;
|
|
649
|
+
export declare function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
|
|
650
|
+
export declare function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
|
|
651
|
+
export declare function pipe<A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
|
|
652
|
+
export declare function pipe<A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
|
|
653
|
+
export declare function pipe<A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
|
|
654
|
+
export declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
|
|
655
|
+
export declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
|
|
656
|
+
export declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
|
|
657
|
+
export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
|
|
658
|
+
export declare namespace pipe {
|
|
659
|
+
export var when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
|
|
660
|
+
export var unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
|
|
661
|
+
export var either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
|
|
662
|
+
export var struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
|
|
663
|
+
export var safe: {
|
|
664
|
+
<A>(a: A): A;
|
|
665
|
+
<A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
|
|
666
|
+
<A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
|
|
667
|
+
<A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
|
|
668
|
+
<A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
|
|
669
|
+
<A, B, C, D, E, F>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F): F | Extract<A | B | C | D | E, null | undefined>;
|
|
670
|
+
<A, B, C, D, E, F, G>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G): G | Extract<A | B | C | D | E | F, null | undefined>;
|
|
671
|
+
<A, B, C, D, E, F, G, H>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H): H | Extract<A | B | C | D | E | F | G, null | undefined>;
|
|
672
|
+
<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
|
|
673
|
+
<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
|
|
674
|
+
<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
|
|
675
|
+
};
|
|
676
|
+
export var async: {
|
|
677
|
+
<A>(a: Awaitable<A>): Promise<A>;
|
|
678
|
+
<A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
|
|
679
|
+
<A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
|
|
680
|
+
<A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
|
|
681
|
+
<A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
|
|
682
|
+
<A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
|
|
683
|
+
<A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
|
|
684
|
+
<A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
|
|
685
|
+
<A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
|
|
686
|
+
<A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
|
|
687
|
+
<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
|
|
688
|
+
};
|
|
689
|
+
var _a: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
|
|
690
|
+
export { _a as try };
|
|
705
691
|
}
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
692
|
+
declare function safe<A>(a: A): A;
|
|
693
|
+
declare function safe<A, B>(a: A, ab: (a: NonNullable<A>) => B): B | Extract<A, null | undefined>;
|
|
694
|
+
declare function safe<A, B, C>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C): C | Extract<A | B, null | undefined>;
|
|
695
|
+
declare function safe<A, B, C, D>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D): D | Extract<A | B | C, null | undefined>;
|
|
696
|
+
declare function safe<A, B, C, D, E>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E): E | Extract<A | B | C | D, null | undefined>;
|
|
697
|
+
declare function safe<A, B, C, D, E, F>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F): F | Extract<A | B | C | D | E, null | undefined>;
|
|
698
|
+
declare function safe<A, B, C, D, E, F, G>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G): G | Extract<A | B | C | D | E | F, null | undefined>;
|
|
699
|
+
declare function safe<A, B, C, D, E, F, G, H>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H): H | Extract<A | B | C | D | E | F | G, null | undefined>;
|
|
700
|
+
declare function safe<A, B, C, D, E, F, G, H, I>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I): I | Extract<A | B | C | D | E | F | G | H, null | undefined>;
|
|
701
|
+
declare function safe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J): J | Extract<A | B | C | D | E | F | G | H | I, null | undefined>;
|
|
702
|
+
declare function safe<A, B, C, D, E, F, G, H, I, J, K>(a: A, ab: (a: NonNullable<A>) => B, bc: (b: NonNullable<B>) => C, cd: (c: NonNullable<C>) => D, de: (d: NonNullable<D>) => E, ef: (e: NonNullable<E>) => F, fg: (f: NonNullable<F>) => G, gh: (g: NonNullable<G>) => H, hi: (h: NonNullable<H>) => I, ij: (i: NonNullable<I>) => J, jk: (j: J) => K): K | Extract<A | B | C | D | E | F | G | H | I | J, null | undefined>;
|
|
703
|
+
declare function async<A>(a: Awaitable<A>): Promise<A>;
|
|
704
|
+
declare function async<A, B>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>): Promise<B>;
|
|
705
|
+
declare function async<A, B, C>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>): Promise<C>;
|
|
706
|
+
declare function async<A, B, C, D>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>): Promise<D>;
|
|
707
|
+
declare function async<A, B, C, D, E>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>): Promise<E>;
|
|
708
|
+
declare function async<A, B, C, D, E, F>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>): Promise<F>;
|
|
709
|
+
declare function async<A, B, C, D, E, F, G>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>): Promise<G>;
|
|
710
|
+
declare function async<A, B, C, D, E, F, G, H>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>): Promise<H>;
|
|
711
|
+
declare function async<A, B, C, D, E, F, G, H, I>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>): Promise<I>;
|
|
712
|
+
declare function async<A, B, C, D, E, F, G, H, I, J>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => J): Promise<J>;
|
|
713
|
+
declare function async<A, B, C, D, E, F, G, H, I, J, K>(a: Awaitable<A>, ab: (a: A) => Awaitable<B>, bc: (b: B) => Awaitable<C>, cd: (c: C) => Awaitable<D>, de: (d: D) => Awaitable<E>, ef: (e: E) => Awaitable<F>, fg: (f: F) => Awaitable<G>, gh: (g: G) => Awaitable<H>, hi: (h: H) => Awaitable<I>, ij: (i: I) => Awaitable<J>, jk: (j: J) => Awaitable<K>): Promise<K>;
|
|
714
|
+
export interface pipe {
|
|
715
|
+
/**
|
|
716
|
+
* Executes a function on the piped value if a predicate is met, otherwise returns the value unchanged.
|
|
717
|
+
*
|
|
718
|
+
* @example
|
|
719
|
+
* ```ts
|
|
720
|
+
* pipe(
|
|
721
|
+
* 4,
|
|
722
|
+
* pipe.when(n => n % 2 === 0, n => n * 2)
|
|
723
|
+
* ); // 8
|
|
724
|
+
* ```
|
|
725
|
+
*/
|
|
726
|
+
readonly when: <A>(predicate: (a: A) => boolean, onTrue: (a: A) => A) => (a: A) => A;
|
|
727
|
+
/**
|
|
728
|
+
* Executes a function on the piped value if a predicate is NOT met, otherwise returns the value unchanged.
|
|
729
|
+
*
|
|
730
|
+
* @example
|
|
731
|
+
* ```ts
|
|
732
|
+
* pipe(
|
|
733
|
+
* 5,
|
|
734
|
+
* pipe.unless(n => n % 2 === 0, n => n * 2)
|
|
735
|
+
* ); // 10
|
|
736
|
+
* ```
|
|
737
|
+
*/
|
|
738
|
+
readonly unless: <A>(predicate: (a: A) => boolean, onFalse: (a: A) => A) => (a: A) => A;
|
|
739
|
+
/**
|
|
740
|
+
* Executes one of two functions based on a predicate, acting as a functional if-else/ternary helper.
|
|
741
|
+
*
|
|
742
|
+
* @example
|
|
743
|
+
* ```ts
|
|
744
|
+
* pipe(
|
|
745
|
+
* 5,
|
|
746
|
+
* pipe.either(n => n >= 0, n => `+${n}`, n => `${n}`)
|
|
747
|
+
* ); // "+5"
|
|
748
|
+
* ```
|
|
749
|
+
*/
|
|
750
|
+
readonly either: <A, B>(predicate: (a: A) => boolean, onTrue: (a: A) => B, onFalse: (a: A) => B) => (a: A) => B;
|
|
751
|
+
/**
|
|
752
|
+
* Creates a pipeline step that wraps a throwing function in a try/catch, returning a fallback value if an error occurs.
|
|
753
|
+
*
|
|
754
|
+
* @example
|
|
755
|
+
* ```ts
|
|
756
|
+
* pipe(
|
|
757
|
+
* '{"a":1}',
|
|
758
|
+
* pipe.try(s => JSON.parse(s), () => null)
|
|
759
|
+
* ); // { a: 1 }
|
|
760
|
+
* ```
|
|
761
|
+
*/
|
|
762
|
+
readonly try: <A, B, C>(f: (a: A) => B, onError: (error: unknown, value: A) => C) => (a: A) => B | C;
|
|
763
|
+
/**
|
|
764
|
+
* Builds an object by applying a record of field-level transformer functions to the piped input.
|
|
765
|
+
*
|
|
766
|
+
* @example
|
|
767
|
+
* ```ts
|
|
768
|
+
* pipe(
|
|
769
|
+
* { name: "Alice", age: 25 },
|
|
770
|
+
* pipe.struct({
|
|
771
|
+
* name: u => u.name,
|
|
772
|
+
* isAdult: u => u.age >= 18
|
|
773
|
+
* })
|
|
774
|
+
* ); // { name: "Alice", isAdult: true }
|
|
775
|
+
* ```
|
|
776
|
+
*/
|
|
777
|
+
readonly struct: <A, R extends Record<string, unknown>>(fields: { [K in keyof R]: (a: A) => R[K]; }) => (a: A) => R;
|
|
778
|
+
/**
|
|
779
|
+
* Pipes a value through a sequence of operations, short-circuiting and propagating
|
|
780
|
+
* null or undefined immediately if any intermediate step evaluates to nil.
|
|
781
|
+
*
|
|
782
|
+
* @example
|
|
783
|
+
* ```ts
|
|
784
|
+
* pipe.safe(
|
|
785
|
+
* { address: { city: "Paris" } },
|
|
786
|
+
* user => user.address,
|
|
787
|
+
* address => address.city,
|
|
788
|
+
* city => city.length
|
|
789
|
+
* ); // 5
|
|
790
|
+
* ```
|
|
791
|
+
*/
|
|
792
|
+
readonly safe: typeof safe;
|
|
793
|
+
/**
|
|
794
|
+
* Pipes a value through a sequence of operations, supporting asynchronous transitions at any step.
|
|
795
|
+
*
|
|
796
|
+
* @example
|
|
797
|
+
* ```ts
|
|
798
|
+
* await pipe.async(
|
|
799
|
+
* 42,
|
|
800
|
+
* n => Promise.resolve(`user-${n}`),
|
|
801
|
+
* name => name.toUpperCase()
|
|
802
|
+
* ); // "USER-42"
|
|
803
|
+
* ```
|
|
804
|
+
*/
|
|
805
|
+
readonly async: typeof async;
|
|
800
806
|
}
|
|
801
|
-
|
|
807
|
+
//#endregion
|
|
808
|
+
//#region src/Composition/tap.d.ts
|
|
802
809
|
/**
|
|
803
810
|
* Executes a side effect function and returns the original value unchanged.
|
|
804
811
|
* Useful for logging, debugging, or other side effects within a pipeline.
|
|
@@ -828,74 +835,75 @@ interface pipe {
|
|
|
828
835
|
*
|
|
829
836
|
* @see {@link Maybe.tap} for Maybe-specific tap that only runs on Some
|
|
830
837
|
*/
|
|
831
|
-
declare function tap<A>(f: (a: A) => void): (a: A) => A;
|
|
832
|
-
declare namespace tap {
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
838
|
+
export declare function tap<A>(f: (a: A) => void): (a: A) => A;
|
|
839
|
+
export declare namespace tap {
|
|
840
|
+
var log: <A>(options?: tap.LogOptions<A>) => (a: A) => A;
|
|
841
|
+
var inspect: <A>(options?: tap.InspectOptions) => (a: A) => A;
|
|
842
|
+
var async: <A>(fn: (a: A) => Thenable<unknown>, options?: tap.AsyncOptions) => (a: A) => A;
|
|
843
|
+
var time: <A>(fn: (a: A) => unknown, config: tap.TimeConfig) => (a: A) => A;
|
|
837
844
|
}
|
|
838
|
-
declare namespace tap {
|
|
845
|
+
export declare namespace tap {
|
|
846
|
+
/**
|
|
847
|
+
* Configuration options for {@link tap.log}.
|
|
848
|
+
*/
|
|
849
|
+
type LogOptions<A> = {
|
|
850
|
+
/**
|
|
851
|
+
* An optional label prefix for the log output (e.g., `[label]: value`).
|
|
852
|
+
*/
|
|
853
|
+
readonly label?: string;
|
|
854
|
+
/**
|
|
855
|
+
* The logging destination function. Defaults to `console.log`.
|
|
856
|
+
*/
|
|
857
|
+
readonly logger?: (message: string) => void;
|
|
858
|
+
/**
|
|
859
|
+
* A custom formatter function to convert the piped value to a string.
|
|
860
|
+
* Defaults to `JSON.stringify` for objects and `String(value)` for primitives.
|
|
861
|
+
*/
|
|
862
|
+
readonly formatter?: (value: A) => string;
|
|
863
|
+
};
|
|
864
|
+
/**
|
|
865
|
+
* Configuration options for {@link tap.inspect}.
|
|
866
|
+
*/
|
|
867
|
+
type InspectOptions = {
|
|
839
868
|
/**
|
|
840
|
-
*
|
|
869
|
+
* An optional label prefix for the inspect output (e.g., `[label]: value`).
|
|
841
870
|
*/
|
|
842
|
-
|
|
843
|
-
/**
|
|
844
|
-
* An optional label prefix for the log output (e.g., `[label]: value`).
|
|
845
|
-
*/
|
|
846
|
-
readonly label?: string;
|
|
847
|
-
/**
|
|
848
|
-
* The logging destination function. Defaults to `console.log`.
|
|
849
|
-
*/
|
|
850
|
-
readonly logger?: (message: string) => void;
|
|
851
|
-
/**
|
|
852
|
-
* A custom formatter function to convert the piped value to a string.
|
|
853
|
-
* Defaults to `JSON.stringify` for objects and `String(value)` for primitives.
|
|
854
|
-
*/
|
|
855
|
-
readonly formatter?: (value: A) => string;
|
|
856
|
-
};
|
|
871
|
+
readonly label?: string;
|
|
857
872
|
/**
|
|
858
|
-
*
|
|
873
|
+
* The maximum depth to recurse when formatting the object.
|
|
874
|
+
* Defaults to `null` (infinite depth).
|
|
859
875
|
*/
|
|
860
|
-
|
|
861
|
-
/**
|
|
862
|
-
* An optional label prefix for the inspect output (e.g., `[label]: value`).
|
|
863
|
-
*/
|
|
864
|
-
readonly label?: string;
|
|
865
|
-
/**
|
|
866
|
-
* The maximum depth to recurse when formatting the object.
|
|
867
|
-
* Defaults to `null` (infinite depth).
|
|
868
|
-
*/
|
|
869
|
-
readonly depth?: number;
|
|
870
|
-
/**
|
|
871
|
-
* Whether to colorize the output using ANSI color codes.
|
|
872
|
-
* Defaults to `true`.
|
|
873
|
-
*/
|
|
874
|
-
readonly colors?: boolean;
|
|
875
|
-
};
|
|
876
|
+
readonly depth?: number;
|
|
876
877
|
/**
|
|
877
|
-
*
|
|
878
|
+
* Whether to colorize the output using ANSI color codes.
|
|
879
|
+
* Defaults to `true`.
|
|
878
880
|
*/
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
};
|
|
881
|
+
readonly colors?: boolean;
|
|
882
|
+
};
|
|
883
|
+
/**
|
|
884
|
+
* Configuration options for {@link tap.async}.
|
|
885
|
+
*/
|
|
886
|
+
type AsyncOptions = {
|
|
886
887
|
/**
|
|
887
|
-
*
|
|
888
|
-
*
|
|
888
|
+
* A callback to handle exceptions thrown by the async side-effect.
|
|
889
|
+
* Defaults to logging via `console.error`.
|
|
889
890
|
*/
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
891
|
+
readonly onError?: (error: unknown) => void;
|
|
892
|
+
};
|
|
893
|
+
/**
|
|
894
|
+
* Configuration options for {@link tap.time}, enforcing mutual exclusivity
|
|
895
|
+
* between console logging and custom handlers.
|
|
896
|
+
*/
|
|
897
|
+
type TimeConfig = {
|
|
898
|
+
label: string;
|
|
899
|
+
onFinish?: never;
|
|
900
|
+
} | {
|
|
901
|
+
onFinish: (duration: Duration) => void;
|
|
902
|
+
label?: never;
|
|
903
|
+
};
|
|
897
904
|
}
|
|
898
|
-
|
|
905
|
+
//#endregion
|
|
906
|
+
//#region src/Composition/uncurry.d.ts
|
|
899
907
|
/**
|
|
900
908
|
* Converts a curried function into a multi-argument function.
|
|
901
909
|
* Useful when you want to call a curried function with all arguments at once.
|
|
@@ -924,9 +932,9 @@ declare namespace tap {
|
|
|
924
932
|
* @see {@link uncurry3} for 3-argument curried functions
|
|
925
933
|
* @see {@link uncurry4} for 4-argument curried functions
|
|
926
934
|
*/
|
|
927
|
-
declare function uncurry<C>(f: () => () => C): () => C;
|
|
928
|
-
declare function uncurry<A, C>(f: (a: A) => () => C): (a: A) => C;
|
|
929
|
-
declare function uncurry<A, B, C>(f: (a: A) => (b: B) => C): (a: A, b: B) => C;
|
|
935
|
+
export declare function uncurry<C>(f: () => () => C): () => C;
|
|
936
|
+
export declare function uncurry<A, C>(f: (a: A) => () => C): (a: A) => C;
|
|
937
|
+
export declare function uncurry<A, B, C>(f: (a: A) => (b: B) => C): (a: A, b: B) => C;
|
|
930
938
|
/**
|
|
931
939
|
* Converts a curried 3-argument function into a multi-argument function.
|
|
932
940
|
*
|
|
@@ -937,7 +945,7 @@ declare function uncurry<A, B, C>(f: (a: A) => (b: B) => C): (a: A, b: B) => C;
|
|
|
937
945
|
* add3(1, 2, 3); // 6
|
|
938
946
|
* ```
|
|
939
947
|
*/
|
|
940
|
-
declare const uncurry3: <A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D) => (a: A, b: B, c: C) => D;
|
|
948
|
+
export declare const uncurry3: <A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D) => (a: A, b: B, c: C) => D;
|
|
941
949
|
/**
|
|
942
950
|
* Converts a curried 4-argument function into a multi-argument function.
|
|
943
951
|
*
|
|
@@ -948,6 +956,5 @@ declare const uncurry3: <A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D) => (a:
|
|
|
948
956
|
* add4(1, 2, 3, 4); // 10
|
|
949
957
|
* ```
|
|
950
958
|
*/
|
|
951
|
-
declare const uncurry4: <A, B, C, D, E>(f: (a: A) => (b: B) => (c: C) => (d: D) => E) => (a: A, b: B, c: C, d: D) => E;
|
|
952
|
-
|
|
953
|
-
export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple };
|
|
959
|
+
export declare const uncurry4: <A, B, C, D, E>(f: (a: A) => (b: B) => (c: C) => (d: D) => E) => (a: A, b: B, c: C, d: D) => E;
|
|
960
|
+
//#endregion
|