@vinicunca/perkakas 1.7.0 → 1.8.0

package/dist/conditional-BivA0O7M.d.cts

@@ -0,0 +1,221 @@
+//#region src/internal/types/guard-type.d.ts
+/**
+ * Extracts a type predicate from a type guard function for the first argument.
+ *
+ * @example
+ * type TypeGuardFn = (x: unknown) => x is string;
+ * type Result = GuardType<TypeGuardFn>; // `string`
+ */
+type GuardType<T, Fallback = never> = T extends ((x: any, ...rest: any) => x is infer U) ? U : Fallback;
+//#endregion
+//#region src/conditional.d.ts
+type Case<In, Out, When extends (x: In) => boolean = (x: In) => boolean> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];
+type DefaultCase<In, Out> = (x: In) => Out;
+interface Utilities {
+  readonly defaultCase: typeof defaultCase;
+}
+type WithUtils<T> = T & Utilities;
+declare const conditionalPlus: WithUtils<typeof conditional>;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * NOTE*: Some type-predicates may fail to narrow the param type of their
+ * transformer; in such cases wrap your type-predicate in an anonymous arrow
+ * function: e.g., instead of
+ * `conditional(..., [myTypePredicate, myTransformer], ...)`, use
+ * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.
+ *
+ * To add a a default, catch-all, case you can provide a single callback
+ * function (instead of a 2-tuple) as the last case. This is equivalent to
+ * adding a case with a trivial always-true predicate as it's condition (see
+ * example).
+ *
+ * For simpler cases you should also consider using `when` instead.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this
+ * implementation **doesn't** implicitly return `undefined` as a fallback when
+ * when none of the cases match; and instead **throws** an exception in those
+ * cases! You have to explicitly provide a default case, and can use
+ * `constant(undefined)` as your last case to replicate that behavior.
+ *
+ * @param cases - A list of (up to 10) cases. Each case can be either:
+ * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer
+ *   function that processes the data if the predicate matches.
+ * - A single callback function that acts as a default fallback case.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(...cases)(data);
+ * @example
+ *   const nameOrId = 3 as string | number | boolean;
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.constant(undefined),
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Fn0 extends (x: T) => boolean, Return0, Fallback = never>(case0: Case<T, Return0, Fn0>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Return0, Return1, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Return0, Return1, Return2, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Fn9 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Return9, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, case9: Case<T, Return9, Fn9>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9 | Fallback;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * NOTE*: Some type-predicates may fail to narrow the param type of their
+ * transformer; in such cases wrap your type-predicate in an anonymous arrow
+ * function: e.g., instead of
+ * `conditional(..., [myTypePredicate, myTransformer], ...)`, use
+ * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.
+ *
+ * To add a a default, catch-all, case you can provide a single callback
+ * function (instead of a 2-tuple) as the last case. This is equivalent to
+ * adding a case with a trivial always-true predicate as it's condition (see
+ * example).
+ *
+ * For simpler cases you should also consider using `when` instead.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this
+ * implementation **doesn't** implicitly return `undefined` as a fallback when
+ * when none of the cases match; and instead **throws** an exception in those
+ * cases! You have to explicitly provide a default case, and can use
+ * `constant(undefined)` as your last case to replicate that behavior.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) cases. Each case can be either:
+ * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer
+ *   function that processes the data if the predicate matches.
+ * - A single callback function that acts as a default fallback case.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(data, ...cases);
+ * @example
+ *   const nameOrId = 3 as string | number | boolean;
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.constant(undefined),
+ *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     (something) => `Hello something (${JSON.stringify(something)})`,
+ *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Fn0 extends (x: T) => boolean, Return0, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, fallback?: DefaultCase<T, Fallback>): Return0 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Return0, Return1, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Return0, Return1, Return2, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Fn9 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Return9, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, case9: Case<T, Return9, Fn9>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9 | Fallback;
+/**
+ *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Use `constant(undefined)` as your last case instead (see example).
+ *
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     // Was: `P.conditional.defaultCase(),`, Now:
+ *     constant(undefined),
+ *   ); //=> 'Hello ID: 3'
+ * @deprecated `conditional` now accepts a default, catch-all, callback
+ * directly and no longer needs this utility wrapper. Use `constant(undefined)`
+ * as your last case instead (see example).
+ */
+declare function defaultCase(): Case<unknown, undefined>;
+/**
+ *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Simply put your `then` callback as the last case (see example).
+ *
+ * @param then - You only need to provide the transformer, the predicate is
+ * implicit. @default () => undefined, which is how Lodash and Ramda handle
+ * the final fallback case.
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     // Was: `P.conditional.defaultCase(
+ *     //  (something) => `Hello something (${JSON.stringify(something)})`,
+ *     //),`, Now:
+ *     (something) => `Hello something (${JSON.stringify(something)})`
+ *   ); //=> 'Hello ID: 3'
+ * @deprecated `conditional` now accepts a default, catch-all, callback
+ * directly and no longer needs this utility wrapper. Simply put your `then`
+ * callback as the last case.
+ */
+declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
+//# sourceMappingURL=conditional.d.ts.map
+
+//#endregion
+export { conditionalPlus };
+//# sourceMappingURL=conditional-BivA0O7M.d.cts.map

package/dist/conditional-BivA0O7M.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-BivA0O7M.d.cts","names":[],"sources":["../src/internal/types/guard-type.ts","../src/conditional.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/conditional-ClGfJoeu.js

@@ -0,0 +1,2 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}const t=Object.assign(n,{defaultCase:a});function n(...t){return e(i,r,t)}function r(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function i(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}function a(e=s){return[o,e]}function o(){return!0}function s(){}export{t as conditionalPlus};
+//# sourceMappingURL=conditional-ClGfJoeu.js.map

package/dist/conditional-ClGfJoeu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-ClGfJoeu.js","names":["conditionalPlus: WithUtils<typeof conditional>"],"sources":["../src/internal/curry-on.ts","../src/conditional.ts"],"sourcesContent":["/**\n * Utility for currying functions based on a predicate for the first argument.\n *\n * This is useful for currying functions with a variadic argument list.\n */\nexport function curryOn<T>(\n  isArg: (firstArg: unknown) => firstArg is T,\n  implementation: (\n    data: unknown,\n    firstArg: T,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    ...args: any\n  ) => unknown,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  return isArg(args[0])\n    // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n    ? (data: unknown) => implementation(data, ...args)\n    // @ts-expect-error [ts2556] - This is a low-level function that assumes the function declaration and setup is correct and won't result in typing issues when called dynamically.\n    : implementation(...args);\n}\n","/* eslint-disable jsdoc/check-param-names -- we don't document the case params, it'd be redundant */\n\nimport type { GuardType } from './internal/types/guard-type';\nimport { curryOn } from './internal/curry-on';\n\ntype Case<\n  In,\n  Out,\n  When extends (x: In) => boolean = (x: In) => boolean,\n> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];\n\ntype DefaultCase<In, Out> = (x: In) => Out;\n\n// For easier discovery and to allow us to have a single exported function we\n// merge a set of utilities with the function itself. This provides a namespace-\n// like structure where the function could be used directly by calling it, but\n// also as the container of additional utilities.\ninterface Utilities {\n  readonly defaultCase: typeof defaultCase;\n}\ntype WithUtils<T> = T & Utilities;\n\nconst conditionalPlus: WithUtils<typeof conditional> = Object.assign(\n  conditional,\n  { defaultCase } satisfies Utilities,\n);\nexport { conditionalPlus as conditional };\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   P.conditional(...cases)(data);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *       P.constant(undefined),\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   P.pipe(\n *     nameOrId,\n *     P.conditional(\n *       [P.isString, (name) => `Hello ${name}`],\n *       [P.isNumber, (id) => `Hello ID: ${id}`],\n *       (something) => `Hello something (${JSON.stringify(something)})`,\n *     ),\n *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.\n * @dataLast\n * @category Function\n */\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Return0,\n  Fallback = never,\n>(\n  // TODO [>2]: TypeScript has problems inferring narrowed types within the case tuples, making it hard to work with this utility. Removing the tuple wrappers solves these issues without impacting the API too much.\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  // TODO [>2]: Exclude previous guarded types from the next functions in the chain. Although this isn't a prefect solution, it's the common approach to compute the \"negation\" of a type-predicate, and would provide a more comfortable API for bigger chains for cases like discriminated unions. This TODO is at the first occurrence where it is relevant, but it should be applied to **all** subsequent overloads. p.s. don't forget to update the docs too!\n  Fn1 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Return3 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  fallback?: DefaultCase<T, Fallback>,\n): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Fn9 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Return9,\n  Fallback = never,\n>(\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  case9: Case<T, Return9, Fn9>,\n  fallback?: DefaultCase<T, Fallback>,\n): (\n  data: T,\n) =>\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Return9\n  | Fallback;\n\n/**\n * Executes a transformer function based on the first matching predicate,\n * functioning like a series of `if...else if...` statements. It sequentially\n * evaluates each case and, upon finding a truthy predicate, runs the\n * corresponding transformer, and returns, ignoring any further cases, even if\n * they would match.\n *\n * NOTE*: Some type-predicates may fail to narrow the param type of their\n * transformer; in such cases wrap your type-predicate in an anonymous arrow\n * function: e.g., instead of\n * `conditional(..., [myTypePredicate, myTransformer], ...)`, use\n * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.\n *\n * To add a a default, catch-all, case you can provide a single callback\n * function (instead of a 2-tuple) as the last case. This is equivalent to\n * adding a case with a trivial always-true predicate as it's condition (see\n * example).\n *\n * For simpler cases you should also consider using `when` instead.\n *\n * Due to TypeScript's inability to infer the result of negating a type-\n * predicate we can't refine the types used in subsequent cases based on\n * previous conditions. Using a `switch (true)` statement or ternary operators\n * is recommended for more precise type control when such type narrowing is\n * needed.\n *\n * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this\n * implementation **doesn't** implicitly return `undefined` as a fallback when\n * when none of the cases match; and instead **throws** an exception in those\n * cases! You have to explicitly provide a default case, and can use\n * `constant(undefined)` as your last case to replicate that behavior.\n *\n * @param data - The input data to be evaluated against the provided cases.\n * @param cases - A list of (up to 10) cases. Each case can be either:\n * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer\n *   function that processes the data if the predicate matches.\n * - A single callback function that acts as a default fallback case.\n * @returns The output of the matched transformer. If no cases match, an\n * exception is thrown. The return type is a union of the return types of all\n * provided transformers.\n * @signature\n *   P.conditional(data, ...cases);\n * @example\n *   const nameOrId = 3 as string | number | boolean;\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     P.constant(undefined),\n *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.\n *\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     (something) => `Hello something (${JSON.stringify(something)})`,\n *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.\n * @dataFirst\n * @category Function\n */\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Return0,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  fallback?: DefaultCase<T, Fallback>,\n): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Fallback;\n\nfunction conditional<\n  T,\n  Fn0 extends (x: T) => boolean,\n  Fn1 extends (x: T) => boolean,\n  Fn2 extends (x: T) => boolean,\n  Fn3 extends (x: T) => boolean,\n  Fn4 extends (x: T) => boolean,\n  Fn5 extends (x: T) => boolean,\n  Fn6 extends (x: T) => boolean,\n  Fn7 extends (x: T) => boolean,\n  Fn8 extends (x: T) => boolean,\n  Fn9 extends (x: T) => boolean,\n  Return0,\n  Return1,\n  Return2,\n  Return3,\n  Return4,\n  Return5,\n  Return6,\n  Return7,\n  Return8,\n  Return9,\n  Fallback = never,\n>(\n  data: T,\n  case0: Case<T, Return0, Fn0>,\n  case1: Case<T, Return1, Fn1>,\n  case2: Case<T, Return2, Fn2>,\n  case3: Case<T, Return3, Fn3>,\n  case4: Case<T, Return4, Fn4>,\n  case5: Case<T, Return5, Fn5>,\n  case6: Case<T, Return6, Fn6>,\n  case7: Case<T, Return7, Fn7>,\n  case8: Case<T, Return8, Fn8>,\n  case9: Case<T, Return9, Fn9>,\n  fallback?: DefaultCase<T, Fallback>,\n):\n  | Return0\n  | Return1\n  | Return2\n  | Return3\n  | Return4\n  | Return5\n  | Return6\n  | Return7\n  | Return8\n  | Return9\n  | Fallback;\n\nfunction conditional(...args: ReadonlyArray<unknown>): unknown {\n  return curryOn(isCase, conditionalImplementation, args);\n}\n\nfunction conditionalImplementation<In, Out>(\n  data: In,\n  ...cases: ReadonlyArray<Case<In, Out> | DefaultCase<In, Out>>\n): Out {\n  for (const current of cases) {\n    if (typeof current === 'function') {\n      return current(data);\n    }\n\n    const [when, then] = current;\n    if (when(data)) {\n      return then(data);\n    }\n  }\n\n  // TODO [>2]: When we built this function originally we didn't want to have to always return `undefined` and force users to always have to handle that case even when they knew it would never happen. In hindsight that was wrong and we can support this at the type-level without throwing. If users want to throw they can always have an explicit fallback that does that (and we might add a throw utility in v3 too!).\n  throw new Error('conditional: data failed for all cases');\n}\n\nfunction isCase(maybeCase: unknown): maybeCase is Case<unknown, unknown> {\n  if (!Array.isArray(maybeCase)) {\n    return false;\n  }\n\n  const [when, then, ...rest] = maybeCase as ReadonlyArray<unknown>;\n  return (\n    typeof when === 'function'\n    && when.length <= 1\n    && typeof then === 'function'\n    && then.length <= 1\n    && rest.length === 0\n  );\n}\n\n// TODO [2025-09-04]: Remove the deprecated `defaultCase` utility.\n/**\n *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Use `constant(undefined)` as your last case instead (see example).\n *\n * @example\n *   const nameOrId = 3 as string | number;\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     // Was: `P.conditional.defaultCase(),`, Now:\n *     constant(undefined),\n *   ); //=> 'Hello ID: 3'\n * @deprecated `conditional` now accepts a default, catch-all, callback\n * directly and no longer needs this utility wrapper. Use `constant(undefined)`\n * as your last case instead (see example).\n */\nfunction defaultCase(): Case<unknown, undefined>;\n\n/**\n *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Simply put your `then` callback as the last case (see example).\n *\n * @param then - You only need to provide the transformer, the predicate is\n * implicit. @default () => undefined, which is how Lodash and Ramda handle\n * the final fallback case.\n * @example\n *   const nameOrId = 3 as string | number;\n *   P.conditional(\n *     nameOrId,\n *     [P.isString, (name) => `Hello ${name}`],\n *     [P.isNumber, (id) => `Hello ID: ${id}`],\n *     // Was: `P.conditional.defaultCase(\n *     //  (something) => `Hello something (${JSON.stringify(something)})`,\n *     //),`, Now:\n *     (something) => `Hello something (${JSON.stringify(something)})`\n *   ); //=> 'Hello ID: 3'\n * @deprecated `conditional` now accepts a default, catch-all, callback\n * directly and no longer needs this utility wrapper. Simply put your `then`\n * callback as the last case.\n */\nfunction defaultCase<In, Then extends (param: In) => unknown>(\n  then: Then,\n): Case<In, ReturnType<Then>>;\nfunction defaultCase(\n  then: (data: unknown) => unknown = trivialDefaultCase,\n): Case<unknown, unknown> {\n  return [acceptAnything, then];\n}\n\n// We memoize this so it isn't recreated on every invocation of `defaultCase`.\nfunction acceptAnything(): boolean {\n  return true as const;\n}\n\n// Lodash and Ramda return `undefined` as the default case.\nfunction trivialDefaultCase(): undefined {\n  return undefined;\n}\n"],"mappings":"AAKA,SAAgB,EACd,EACA,EAMA,EACS,CACT,OAAO,EAAM,EAAK,GAAG,CAEhB,GAAkB,EAAe,EAAM,GAAG,EAAK,CAEhD,EAAe,GAAG,EAAK,CCG7B,MAAMA,EAAiD,OAAO,OAC5D,EACA,CAAE,cAAa,CAChB,CAssBD,SAAS,EAAY,GAAG,EAAuC,CAC7D,OAAO,EAAQ,EAAQ,EAA2B,EAAK,CAGzD,SAAS,EACP,EACA,GAAG,EACE,CACL,IAAK,IAAM,KAAW,EAAO,CAC3B,GAAI,OAAO,GAAY,WACrB,OAAO,EAAQ,EAAK,CAGtB,GAAM,CAAC,EAAM,GAAQ,EACrB,GAAI,EAAK,EAAK,CACZ,OAAO,EAAK,EAAK,CAKrB,MAAU,MAAM,yCAAyC,CAG3D,SAAS,EAAO,EAAyD,CACvE,GAAI,CAAC,MAAM,QAAQ,EAAU,CAC3B,MAAO,GAGT,GAAM,CAAC,EAAM,EAAM,GAAG,GAAQ,EAC9B,OACE,OAAO,GAAS,YACb,EAAK,QAAU,GACf,OAAO,GAAS,YAChB,EAAK,QAAU,GACf,EAAK,SAAW,EA+CvB,SAAS,EACP,EAAmC,EACX,CACxB,MAAO,CAAC,EAAgB,EAAK,CAI/B,SAAS,GAA0B,CACjC,MAAO,GAIT,SAAS,GAAgC"}

package/dist/conditional-DeaF48-8.d.ts

@@ -0,0 +1,221 @@
+//#region src/internal/types/guard-type.d.ts
+/**
+ * Extracts a type predicate from a type guard function for the first argument.
+ *
+ * @example
+ * type TypeGuardFn = (x: unknown) => x is string;
+ * type Result = GuardType<TypeGuardFn>; // `string`
+ */
+type GuardType<T, Fallback = never> = T extends ((x: any, ...rest: any) => x is infer U) ? U : Fallback;
+//#endregion
+//#region src/conditional.d.ts
+type Case<In, Out, When extends (x: In) => boolean = (x: In) => boolean> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];
+type DefaultCase<In, Out> = (x: In) => Out;
+interface Utilities {
+  readonly defaultCase: typeof defaultCase;
+}
+type WithUtils<T> = T & Utilities;
+declare const conditionalPlus: WithUtils<typeof conditional>;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * NOTE*: Some type-predicates may fail to narrow the param type of their
+ * transformer; in such cases wrap your type-predicate in an anonymous arrow
+ * function: e.g., instead of
+ * `conditional(..., [myTypePredicate, myTransformer], ...)`, use
+ * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.
+ *
+ * To add a a default, catch-all, case you can provide a single callback
+ * function (instead of a 2-tuple) as the last case. This is equivalent to
+ * adding a case with a trivial always-true predicate as it's condition (see
+ * example).
+ *
+ * For simpler cases you should also consider using `when` instead.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this
+ * implementation **doesn't** implicitly return `undefined` as a fallback when
+ * when none of the cases match; and instead **throws** an exception in those
+ * cases! You have to explicitly provide a default case, and can use
+ * `constant(undefined)` as your last case to replicate that behavior.
+ *
+ * @param cases - A list of (up to 10) cases. Each case can be either:
+ * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer
+ *   function that processes the data if the predicate matches.
+ * - A single callback function that acts as a default fallback case.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(...cases)(data);
+ * @example
+ *   const nameOrId = 3 as string | number | boolean;
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.constant(undefined),
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Fn0 extends (x: T) => boolean, Return0, Fallback = never>(case0: Case<T, Return0, Fn0>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Return0, Return1, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Return0, Return1, Return2, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Fn9 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Return9, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, case9: Case<T, Return9, Fn9>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9 | Fallback;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * NOTE*: Some type-predicates may fail to narrow the param type of their
+ * transformer; in such cases wrap your type-predicate in an anonymous arrow
+ * function: e.g., instead of
+ * `conditional(..., [myTypePredicate, myTransformer], ...)`, use
+ * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.
+ *
+ * To add a a default, catch-all, case you can provide a single callback
+ * function (instead of a 2-tuple) as the last case. This is equivalent to
+ * adding a case with a trivial always-true predicate as it's condition (see
+ * example).
+ *
+ * For simpler cases you should also consider using `when` instead.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this
+ * implementation **doesn't** implicitly return `undefined` as a fallback when
+ * when none of the cases match; and instead **throws** an exception in those
+ * cases! You have to explicitly provide a default case, and can use
+ * `constant(undefined)` as your last case to replicate that behavior.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) cases. Each case can be either:
+ * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer
+ *   function that processes the data if the predicate matches.
+ * - A single callback function that acts as a default fallback case.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(data, ...cases);
+ * @example
+ *   const nameOrId = 3 as string | number | boolean;
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.constant(undefined),
+ *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     (something) => `Hello something (${JSON.stringify(something)})`,
+ *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Fn0 extends (x: T) => boolean, Return0, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, fallback?: DefaultCase<T, Fallback>): Return0 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Return0, Return1, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Return0, Return1, Return2, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Fn9 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Return9, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, case9: Case<T, Return9, Fn9>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9 | Fallback;
+/**
+ *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Use `constant(undefined)` as your last case instead (see example).
+ *
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     // Was: `P.conditional.defaultCase(),`, Now:
+ *     constant(undefined),
+ *   ); //=> 'Hello ID: 3'
+ * @deprecated `conditional` now accepts a default, catch-all, callback
+ * directly and no longer needs this utility wrapper. Use `constant(undefined)`
+ * as your last case instead (see example).
+ */
+declare function defaultCase(): Case<unknown, undefined>;
+/**
+ *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Simply put your `then` callback as the last case (see example).
+ *
+ * @param then - You only need to provide the transformer, the predicate is
+ * implicit. @default () => undefined, which is how Lodash and Ramda handle
+ * the final fallback case.
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     // Was: `P.conditional.defaultCase(
+ *     //  (something) => `Hello something (${JSON.stringify(something)})`,
+ *     //),`, Now:
+ *     (something) => `Hello something (${JSON.stringify(something)})`
+ *   ); //=> 'Hello ID: 3'
+ * @deprecated `conditional` now accepts a default, catch-all, callback
+ * directly and no longer needs this utility wrapper. Simply put your `then`
+ * callback as the last case.
+ */
+declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
+//# sourceMappingURL=conditional.d.ts.map
+
+//#endregion
+export { conditionalPlus };
+//# sourceMappingURL=conditional-DeaF48-8.d.ts.map