@vinicunca/perkakas 1.5.0 → 1.7.0

package/dist/conditional.d.cts

@@ -8,9 +8,12 @@
 type GuardType<T, Fallback = never> = T extends (x: any, ...rest: any) => x is infer U ? U : Fallback;
 
 type Case<In, Out, When extends (x: In) => boolean = (x: In) => boolean> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];
-declare const conditionalPlus: typeof conditional & {
-    defaultCase: typeof defaultCase;
-};
+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,
@@ -19,13 +22,18 @@ declare const conditionalPlus: typeof conditional & {
  * corresponding transformer, and returns, ignoring any further cases, even if
  * they would match.
  *
- * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
- * Ramda, this implementation does **NOT** return a default/fallback
- * `undefined` value when none of the cases match; and instead will **throw** an
- * exception in those cases.
- * To add a default case use the `conditional.defaultCase` helper as the final
- * case of your implementation. By default it returns `undefined`, but could be
- * provided a transformer in order to return something else.
+ * 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
@@ -33,30 +41,62 @@ declare const conditionalPlus: typeof conditional & {
  * is recommended for more precise type control when such type narrowing is
  * needed.
  *
- * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
- * consists of a predicate (or a type-predicate) and a transformer function that
- * processes the data if its case matches.
+ * !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;
+ *   const nameOrId = 3 as string | number | boolean;
+ *
  *   P.pipe(
  *     nameOrId,
  *     P.conditional(
  *       [P.isString, (name) => `Hello ${name}`],
  *       [P.isNumber, (id) => `Hello ID: ${id}`],
- *       P.conditional.defaultCase(
- *         (something) => `Hello something (${JSON.stringify(something)})`,
- *       ),
  *     ),
- *   ); //=> 'Hello ID: 3'
+ *   ); //=> '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, 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 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = 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>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+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
@@ -64,13 +104,18 @@ declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T
  * corresponding transformer, and returns, ignoring any further cases, even if
  * they would match.
  *
- * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
- * Ramda, this implementation does **NOT** return a default/fallback
- * `undefined` value when none of the cases match; and instead will **throw** an
- * exception in those cases.
- * To add a default case use the `conditional.defaultCase` helper as the final
- * case of your implementation. By default it returns `undefined`, but could be
- * provided a transformer in order to return something else.
+ * 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
@@ -78,34 +123,76 @@ declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T
  * 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) tuples, each defining a case. Each tuple
- * consists of a predicate (or a type-predicate) and a transformer function that
- * processes the data if its case matches.
+ * @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;
+ *   const nameOrId = 3 as string | number | boolean;
+ *
  *   P.conditional(
  *     nameOrId,
  *     [P.isString, (name) => `Hello ${name}`],
  *     [P.isNumber, (id) => `Hello ID: ${id}`],
- *     P.conditional.defaultCase(
- *       (something) => `Hello something (${JSON.stringify(something)})`,
- *     ),
- *   ); //=> 'Hello ID: 3'
+ *   ); //=> '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, 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 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = 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>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+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>;
 /**
- * A simplified case that accepts all data. Put this as the last case to
- * prevent an exception from being thrown when none of the previous cases
- * match.
- * If this is not the last case it will short-circuit anything after it.
+ *! **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
@@ -116,12 +203,15 @@ declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T
  *     nameOrId,
  *     [P.isString, (name) => `Hello ${name}`],
  *     [P.isNumber, (id) => `Hello ID: ${id}`],
- *     P.conditional.defaultCase(
- *       (something) => `Hello something (${JSON.stringify(something)})`,
- *     ),
+ *     // 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(): Case<unknown, undefined>;
 declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
 
 export { conditionalPlus as conditional };

package/dist/conditional.d.ts

@@ -8,9 +8,12 @@
 type GuardType<T, Fallback = never> = T extends (x: any, ...rest: any) => x is infer U ? U : Fallback;
 
 type Case<In, Out, When extends (x: In) => boolean = (x: In) => boolean> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];
-declare const conditionalPlus: typeof conditional & {
-    defaultCase: typeof defaultCase;
-};
+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,
@@ -19,13 +22,18 @@ declare const conditionalPlus: typeof conditional & {
  * corresponding transformer, and returns, ignoring any further cases, even if
  * they would match.
  *
- * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
- * Ramda, this implementation does **NOT** return a default/fallback
- * `undefined` value when none of the cases match; and instead will **throw** an
- * exception in those cases.
- * To add a default case use the `conditional.defaultCase` helper as the final
- * case of your implementation. By default it returns `undefined`, but could be
- * provided a transformer in order to return something else.
+ * 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
@@ -33,30 +41,62 @@ declare const conditionalPlus: typeof conditional & {
  * is recommended for more precise type control when such type narrowing is
  * needed.
  *
- * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
- * consists of a predicate (or a type-predicate) and a transformer function that
- * processes the data if its case matches.
+ * !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;
+ *   const nameOrId = 3 as string | number | boolean;
+ *
  *   P.pipe(
  *     nameOrId,
  *     P.conditional(
  *       [P.isString, (name) => `Hello ${name}`],
  *       [P.isNumber, (id) => `Hello ID: ${id}`],
- *       P.conditional.defaultCase(
- *         (something) => `Hello something (${JSON.stringify(something)})`,
- *       ),
  *     ),
- *   ); //=> 'Hello ID: 3'
+ *   ); //=> '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, 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 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = 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>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+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
@@ -64,13 +104,18 @@ declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T
  * corresponding transformer, and returns, ignoring any further cases, even if
  * they would match.
  *
- * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
- * Ramda, this implementation does **NOT** return a default/fallback
- * `undefined` value when none of the cases match; and instead will **throw** an
- * exception in those cases.
- * To add a default case use the `conditional.defaultCase` helper as the final
- * case of your implementation. By default it returns `undefined`, but could be
- * provided a transformer in order to return something else.
+ * 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
@@ -78,34 +123,76 @@ declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T
  * 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) tuples, each defining a case. Each tuple
- * consists of a predicate (or a type-predicate) and a transformer function that
- * processes the data if its case matches.
+ * @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;
+ *   const nameOrId = 3 as string | number | boolean;
+ *
  *   P.conditional(
  *     nameOrId,
  *     [P.isString, (name) => `Hello ${name}`],
  *     [P.isNumber, (id) => `Hello ID: ${id}`],
- *     P.conditional.defaultCase(
- *       (something) => `Hello something (${JSON.stringify(something)})`,
- *     ),
- *   ); //=> 'Hello ID: 3'
+ *   ); //=> '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, 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 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = 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>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+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>;
 /**
- * A simplified case that accepts all data. Put this as the last case to
- * prevent an exception from being thrown when none of the previous cases
- * match.
- * If this is not the last case it will short-circuit anything after it.
+ *! **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
@@ -116,12 +203,15 @@ declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T
  *     nameOrId,
  *     [P.isString, (name) => `Hello ${name}`],
  *     [P.isNumber, (id) => `Hello ID: ${id}`],
- *     P.conditional.defaultCase(
- *       (something) => `Hello something (${JSON.stringify(something)})`,
- *     ),
+ *     // 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(): Case<unknown, undefined>;
 declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
 
 export { conditionalPlus as conditional };

package/dist/conditional.js

@@ -1 +1 @@
-import{a}from"./chunk-A2PAJNYA.js";export{a as conditional};
+import{a}from"./chunk-4Y6KJJOW.js";import"./chunk-EK7ODJWE.js";export{a as conditional};

package/dist/constant.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkWLNQOMKLcjs = require('./chunk-WLNQOMKL.cjs');exports.constant = _chunkWLNQOMKLcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkWLNQOMKLcjs = require('./chunk-WLNQOMKL.cjs');require('./chunk-MBGSSEZN.cjs');exports.constant = _chunkWLNQOMKLcjs.a;

package/dist/constant.js

@@ -1 +1 @@
-import{a}from"./chunk-T5XG33UI.js";export{a as constant};
+import{a}from"./chunk-T5XG33UI.js";import"./chunk-EK7ODJWE.js";export{a as constant};

package/dist/count-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkPIF5X7RQcjs = require('./chunk-PIF5X7RQ.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');exports.countBy = _chunkPIF5X7RQcjs.a;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk22AQJBPWcjs = require('./chunk-22AQJBPW.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.countBy = _chunk22AQJBPWcjs.a;

package/dist/count-by.d.cts

@@ -1,6 +1,7 @@
-import { E as ExactRecord } from './exact-record-_isi2JMR.cjs';
-import './if-bounded-record-Drd4UbBU.cjs';
+import { B as BoundedPartial } from './bounded-partial-BqwRN49U.cjs';
+import './if-D4QIikQ1.cjs';
 import 'type-fest';
+import './is-bounded-record-C9WAwfA8.cjs';
 
 /**
  * Categorize and count elements in an array using a defined callback function.
@@ -19,7 +20,7 @@ import 'type-fest';
  * @dataFirst
  * @category Array
  */
-declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): ExactRecord<K, number>;
+declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
 /**
  * Categorize and count elements in an array using a defined callback function.
  * The callback function is applied to each element in the array to determine
@@ -36,6 +37,6 @@ declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categ
  * @dataLast
  * @category Array
  */
-declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => ExactRecord<K, number>;
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
 
 export { countBy };

package/dist/count-by.d.ts

@@ -1,6 +1,7 @@
-import { E as ExactRecord } from './exact-record-Dhbe_K-E.js';
-import './if-bounded-record-Drd4UbBU.js';
+import { B as BoundedPartial } from './bounded-partial-BzynYDVs.js';
+import './if-D4QIikQ1.js';
 import 'type-fest';
+import './is-bounded-record-C9WAwfA8.js';
 
 /**
  * Categorize and count elements in an array using a defined callback function.
@@ -19,7 +20,7 @@ import 'type-fest';
  * @dataFirst
  * @category Array
  */
-declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): ExactRecord<K, number>;
+declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
 /**
  * Categorize and count elements in an array using a defined callback function.
  * The callback function is applied to each element in the array to determine
@@ -36,6 +37,6 @@ declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categ
  * @dataLast
  * @category Array
  */
-declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => ExactRecord<K, number>;
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
 
 export { countBy };

package/dist/count-by.js

@@ -1 +1 @@
-import{a}from"./chunk-BOOMUHPG.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";export{a as countBy};
+import{a}from"./chunk-CTGIT5TY.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as countBy};