@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/conditional.d.cts

@@ -1,217 +1,2 @@
-/**
- * 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;
-
-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>>;
-
-export { conditionalPlus as conditional };
+import { conditionalPlus } from "./conditional-BivA0O7M.cjs";
+export { conditionalPlus as conditional };

package/dist/conditional.d.ts

@@ -1,217 +1,2 @@
-/**
- * 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;
-
-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>>;
-
-export { conditionalPlus as conditional };
+import { conditionalPlus } from "./conditional-BW7TbnuD.js";
+export { conditionalPlus as conditional };

package/dist/conditional.js

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

package/dist/constant-BoufjloF.d.ts

@@ -0,0 +1,32 @@
+//#region src/constant.d.ts
+/**
+ * A function that takes any arguments and returns the provided `value` on every
+ * invocation. This is useful to provide trivial implementations for APIs or in
+ * combination with a ternary or other conditional execution to allow to short-
+ * circuit more complex implementations for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `doNothing` - A function that doesn't return anything.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @param value - The constant value that would be returned on every invocation.
+ * The value is not copied/cloned on every invocation so care should be taken
+ * with mutable objects (like arrays, objects, Maps, etc...).
+ * @signature
+ *   P.constant(value);
+ * @example
+ *   P.map([1, 2, 3], P.constant('a')); // => ['a', 'a', 'a']
+ *   P.map(
+ *     [1, 2, 3],
+ *     isDemoMode ? P.add(1) : P.constant(0),
+ *   ); // => [2, 3, 4] or [0, 0, 0]
+ * @dataLast
+ * @category Function
+ */
+declare function constant<const T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
+//#endregion
+export { constant };
+//# sourceMappingURL=constant-BoufjloF.d.ts.map

package/dist/constant-BoufjloF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-BoufjloF.d.ts","names":[],"sources":["../src/constant.ts"],"sourcesContent":[],"mappings":";;AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,yBACP,kBACQ,iCAAiC,SAAS"}

package/dist/constant-BuIJ9GIn.cjs

@@ -0,0 +1 @@
+function e(e){return()=>e}Object.defineProperty(exports,`constant`,{enumerable:!0,get:function(){return e}});

package/dist/constant-DD3Fj3xH.d.cts

@@ -0,0 +1,32 @@
+//#region src/constant.d.ts
+/**
+ * A function that takes any arguments and returns the provided `value` on every
+ * invocation. This is useful to provide trivial implementations for APIs or in
+ * combination with a ternary or other conditional execution to allow to short-
+ * circuit more complex implementations for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `doNothing` - A function that doesn't return anything.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @param value - The constant value that would be returned on every invocation.
+ * The value is not copied/cloned on every invocation so care should be taken
+ * with mutable objects (like arrays, objects, Maps, etc...).
+ * @signature
+ *   P.constant(value);
+ * @example
+ *   P.map([1, 2, 3], P.constant('a')); // => ['a', 'a', 'a']
+ *   P.map(
+ *     [1, 2, 3],
+ *     isDemoMode ? P.add(1) : P.constant(0),
+ *   ); // => [2, 3, 4] or [0, 0, 0]
+ * @dataLast
+ * @category Function
+ */
+declare function constant<const T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
+//#endregion
+export { constant };
+//# sourceMappingURL=constant-DD3Fj3xH.d.cts.map

package/dist/constant-DD3Fj3xH.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-DD3Fj3xH.d.cts","names":[],"sources":["../src/constant.ts"],"sourcesContent":[],"mappings":";;AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,yBACP,kBACQ,iCAAiC,SAAS"}

package/dist/constant-DrpDXHc7.js

@@ -0,0 +1,2 @@
+function e(e){return()=>e}export{e as constant};
+//# sourceMappingURL=constant-DrpDXHc7.js.map

package/dist/constant-DrpDXHc7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-DrpDXHc7.js","names":[],"sources":["../src/constant.ts"],"sourcesContent":["/**\n * A function that takes any arguments and returns the provided `value` on every\n * invocation. This is useful to provide trivial implementations for APIs or in\n * combination with a ternary or other conditional execution to allow to short-\n * circuit more complex implementations for a specific case.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `doNothing` - A function that doesn't return anything.\n * `identity` - A function that returns the first argument it receives.\n *\n * @param value - The constant value that would be returned on every invocation.\n * The value is not copied/cloned on every invocation so care should be taken\n * with mutable objects (like arrays, objects, Maps, etc...).\n * @signature\n *   P.constant(value);\n * @example\n *   P.map([1, 2, 3], P.constant('a')); // => ['a', 'a', 'a']\n *   P.map(\n *     [1, 2, 3],\n *     isDemoMode ? P.add(1) : P.constant(0),\n *   ); // => [2, 3, 4] or [0, 0, 0]\n * @dataLast\n * @category Function\n */\nexport function constant<const T>(\n  value: T,\n): <Args extends ReadonlyArray<unknown>>(...args: Args) => T {\n  return () => value;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EAC2D,CAC3D,UAAa"}

package/dist/constant.cjs

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

package/dist/constant.d.cts

@@ -1,30 +1,2 @@
-/**
- * A function that takes any arguments and returns the provided `value` on every
- * invocation. This is useful to provide trivial implementations for APIs or in
- * combination with a ternary or other conditional execution to allow to short-
- * circuit more complex implementations for a specific case.
- *
- * Notice that this is a dataLast impl where the function needs to be invoked
- * to get the "do nothing" function.
- *
- * See also:
- * `doNothing` - A function that doesn't return anything.
- * `identity` - A function that returns the first argument it receives.
- *
- * @param value - The constant value that would be returned on every invocation.
- * The value is not copied/cloned on every invocation so care should be taken
- * with mutable objects (like arrays, objects, Maps, etc...).
- * @signature
- *   P.constant(value);
- * @example
- *   P.map([1, 2, 3], P.constant('a')); // => ['a', 'a', 'a']
- *   P.map(
- *     [1, 2, 3],
- *     isDemoMode ? P.add(1) : P.constant(0),
- *   ); // => [2, 3, 4] or [0, 0, 0]
- * @dataLast
- * @category Function
- */
-declare function constant<const T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
-
-export { constant };
+import { constant } from "./constant-DD3Fj3xH.cjs";
+export { constant };

package/dist/constant.d.ts

@@ -1,30 +1,2 @@
-/**
- * A function that takes any arguments and returns the provided `value` on every
- * invocation. This is useful to provide trivial implementations for APIs or in
- * combination with a ternary or other conditional execution to allow to short-
- * circuit more complex implementations for a specific case.
- *
- * Notice that this is a dataLast impl where the function needs to be invoked
- * to get the "do nothing" function.
- *
- * See also:
- * `doNothing` - A function that doesn't return anything.
- * `identity` - A function that returns the first argument it receives.
- *
- * @param value - The constant value that would be returned on every invocation.
- * The value is not copied/cloned on every invocation so care should be taken
- * with mutable objects (like arrays, objects, Maps, etc...).
- * @signature
- *   P.constant(value);
- * @example
- *   P.map([1, 2, 3], P.constant('a')); // => ['a', 'a', 'a']
- *   P.map(
- *     [1, 2, 3],
- *     isDemoMode ? P.add(1) : P.constant(0),
- *   ); // => [2, 3, 4] or [0, 0, 0]
- * @dataLast
- * @category Function
- */
-declare function constant<const T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
-
-export { constant };
+import { constant } from "./constant-BoufjloF.js";
+export { constant };

package/dist/constant.js

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