@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/conditional-tssGt6Vy.d.cts

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

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

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

package/dist/conditional.cjs

@@ -1 +1 @@
-const e=require(`./conditional-81kit9Lg.cjs`);exports.conditional=e.conditionalPlus;
+const e=require(`./conditional-6ff4g8Sy.cjs`);exports.conditional=e.t;

package/dist/conditional.d.cts

@@ -1,2 +1,2 @@
-import { conditionalPlus } from "./conditional-BivA0O7M.cjs";
+import { t as conditionalPlus } from "./conditional-tssGt6Vy.cjs";
 export { conditionalPlus as conditional };

package/dist/conditional.d.ts

@@ -1,2 +1,2 @@
-import { conditionalPlus } from "./conditional-DeaF48-8.js";
+import { t as conditionalPlus } from "./conditional-F_nq8vtA.js";
 export { conditionalPlus as conditional };

package/dist/conditional.js

@@ -1 +1 @@
-import{conditionalPlus as e}from"./conditional-ClGfJoeu.js";export{e as conditional};
+import{t as e}from"./conditional-lp8ZHACd.js";export{e as conditional};

package/dist/constant.cjs

@@ -1 +1 @@
-const e=require(`./constant-BuIJ9GIn.cjs`);exports.constant=e.constant;
+function e(e){return()=>e}exports.constant=e;

package/dist/constant.d.cts

@@ -1,2 +1,32 @@
-import { constant } from "./constant-DD3Fj3xH.cjs";
-export { constant };
+//#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.d.cts.map

package/dist/constant.d.cts.map

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

package/dist/constant.d.ts

@@ -1,2 +1,32 @@
-import { constant } from "./constant-XCH8hVM0.js";
-export { constant };
+//#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.d.ts.map

package/dist/constant.d.ts.map

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

package/dist/constant.js

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

package/dist/constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.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/count-by.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./count-by-DUtzS9CI.cjs`);exports.countBy=e.countBy;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)}exports.countBy=t;

package/dist/count-by.d.cts

@@ -1,4 +1,42 @@
-import "./is-bounded-record-kpsb1wQA.cjs";
-import "./bounded-partial-A89bt7Kj.cjs";
-import { countBy } from "./count-by-CYv2OHvx.cjs";
-export { countBy };
+import { t as BoundedPartial } from "./bounded-partial-D6ouPlXl.cjs";
+
+//#region src/count-by.d.ts
+
+/**
+ * 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
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param data - The array.
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(data, categorizationFn)
+ * @example
+ *    P.countBy(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      toLowerCase
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataFirst
+ * @category Array
+ */
+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
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(categorizationFn)(data)
+ * @example
+ *    P.pipe(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      P.countBy(toLowerCase),
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataLast
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
+//#endregion
+export { countBy };
+//# sourceMappingURL=count-by.d.cts.map

package/dist/count-by.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by.d.cts","names":[],"sources":["../src/count-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;AAyBA;;;AAIwB,iBA7BR,OA6BQ,CAAA,CAAA,EAAA,UA7Ba,WA6Bb,CAAA,CAAA,IAAA,EA5BhB,aA4BgB,CA5BF,CA4BE,CAAA,EAAA,gBAAA,EAAA,CAAA,KAAA,EA1Bb,CA0Ba,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAxBd,aAwBc,CAxBA,CAwBA,CAAA,EAAA,GAvBjB,CAuBiB,GAAA,SAAA,CAAA,EAtBrB,cAsBqB,CAtBN,MAsBM,CAtBC,CAsBD,EAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;iBAJR,qBAAqB,uCAE1B,wBAED,cAAc,OACjB,uBACG,cAAc,OAAO,eAAe,OAAO"}

package/dist/count-by.d.ts

@@ -1,4 +1,42 @@
-import "./is-bounded-record-DCEYRY41.js";
-import "./bounded-partial-TshEjJC1.js";
-import { countBy } from "./count-by-oQGTg_br.js";
-export { countBy };
+import { t as BoundedPartial } from "./bounded-partial-DBIIClPU.js";
+
+//#region src/count-by.d.ts
+
+/**
+ * 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
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param data - The array.
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(data, categorizationFn)
+ * @example
+ *    P.countBy(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      toLowerCase
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataFirst
+ * @category Array
+ */
+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
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(categorizationFn)(data)
+ * @example
+ *    P.pipe(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      P.countBy(toLowerCase),
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataLast
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
+//#endregion
+export { countBy };
+//# sourceMappingURL=count-by.d.ts.map

package/dist/count-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by.d.ts","names":[],"sources":["../src/count-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;AAyBA;;;AAIwB,iBA7BR,OA6BQ,CAAA,CAAA,EAAA,UA7Ba,WA6Bb,CAAA,CAAA,IAAA,EA5BhB,aA4BgB,CA5BF,CA4BE,CAAA,EAAA,gBAAA,EAAA,CAAA,KAAA,EA1Bb,CA0Ba,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAxBd,aAwBc,CAxBA,CAwBA,CAAA,EAAA,GAvBjB,CAuBiB,GAAA,SAAA,CAAA,EAtBrB,cAsBqB,CAtBN,MAsBM,CAtBC,CAsBD,EAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;iBAJR,qBAAqB,uCAE1B,wBAED,cAAc,OACjB,uBACG,cAAc,OAAO,eAAe,OAAO"}

package/dist/count-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{countBy as e}from"./count-by-DZwTr8U_.js";export{e as countBy};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)}export{t as countBy};
+//# sourceMappingURL=count-by.js.map

package/dist/count-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by.js","names":[],"sources":["../src/count-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport { curry } from './curry';\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param data - The array.\n * @param categorizationFn - The categorization function.\n * @signature\n *   P.countBy(data, categorizationFn)\n * @example\n *    P.countBy(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      toLowerCase\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataFirst\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => K | undefined,\n): BoundedPartial<Record<K, number>>;\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param categorizationFn - The categorization function.\n * @signature\n *   P.countBy(categorizationFn)(data)\n * @example\n *    P.pipe(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      P.countBy(toLowerCase),\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataLast\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => K | undefined,\n): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;\n\nexport function countBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(countByImplementation, args);\n}\n\nfunction countByImplementation<T>(data: ReadonlyArray<T>, categorizationFn: (\n  value: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => PropertyKey | undefined): BoundedPartial<Record<PropertyKey, number>> {\n  const out = new Map<PropertyKey, number>();\n\n  for (const [index, item] of data.entries()) {\n    const category = categorizationFn(item, index, data);\n    if (category !== undefined) {\n      const count = out.get(category);\n      if (count === undefined) {\n        out.set(category, 1);\n      } else {\n        out.set(category, count + 1);\n      }\n    }\n  }\n\n  return Object.fromEntries(out);\n}\n"],"mappings":"wCAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAwB,EAIiB,CACzE,IAAM,EAAM,IAAI,IAEhB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAW,EAAiB,EAAM,EAAO,EAAK,CACpD,GAAI,IAAa,IAAA,GAAW,CAC1B,IAAM,EAAQ,EAAI,IAAI,EAAS,CAC3B,IAAU,IAAA,GACZ,EAAI,IAAI,EAAU,EAAE,CAEpB,EAAI,IAAI,EAAU,EAAQ,EAAE,EAKlC,OAAO,OAAO,YAAY,EAAI"}

package/dist/curry-B20xQM_9.d.cts

@@ -0,0 +1,68 @@
+//#region src/internal/types/lazy-result.d.ts
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+  done: boolean;
+  hasNext: false;
+  hasMany?: false | undefined;
+  next?: undefined;
+}
+interface LazyNext<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany?: false | undefined;
+  next: T;
+}
+interface LazyMany<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany: true;
+  next: ReadonlyArray<T>;
+}
+//#endregion
+//#region src/internal/types/lazy-evaluator.d.ts
+type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
+//#endregion
+//#region src/curry.d.ts
+/**
+ * Creates a function with `dataFirst` and `dataLast` signatures.
+ *
+ * `curry` is a dynamic function and it's not type safe. It should be wrapped by
+ * a function that have proper typings. Refer to the example below for correct
+ * usage.
+ *
+ * !IMPORTANT: functions that simply call `curry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn - The function to curry.
+ * @param args - The arguments.
+ * @param lazy - A lazy version of the function to curry.
+ * @signature P.curry(fn, args);
+ * @example
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex(...args: unknown[]) {
+ *      return P.curry(_findIndex, args);
+ *    }
+ * @category Function
+ */
+declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+//#endregion
+export { curry as t };
+//# sourceMappingURL=curry-B20xQM_9.d.cts.map

package/dist/curry-B20xQM_9.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-B20xQM_9.d.cts","names":[],"sources":["../src/internal/types/lazy-result.ts","../src/internal/types/lazy-evaluator.ts","../src/curry.ts"],"sourcesContent":[],"mappings":";KAAY,gBAAgB,YAAY,SAAS,KAAK,SAAS;AAA/D,UAEU,SAAA,CAFY;EAAM,IAAA,EAAA,OAAA;EAAqB,OAAA,EAAA,KAAA;EAAT,OAAA,CAAA,EAAA,KAAA,GAAA,SAAA;EAAuB,IAAA,CAAA,EAAA,SAAA;;UASrD,QAToD,CAAA,CAAA,CAAA,CAAA;EAEpD,IAAA,EAAA,OAAS;EAOT,OAAA,EAAA,IAAQ;EAOR,OAAA,CAAA,EAAA,KAAQ,GAAA,SAII;QAPd;;UAGE;ECdE,IAAA,EAAA,OAAA;EAA+B,OAAA,EAAA,IAAA;EACnC,OAAA,EAAA,IAAA;EAEc,IAAA,EDed,aCfc,CDeA,CCfA,CAAA;;;;ADLV,KCEA,aDFU,CAAA,IAAA,OAAA,EAAA,ICEqB,CDFrB,CAAA,GAAA,CAAA,IAAA,ECGd,CDHc,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,ECKd,aDLc,CCKA,CDLA,CAAA,EAAA,GCMjB,UDNiB,CCMN,CDNM,CAAA;;;AAAtB;;;;;;;AAAkE;AAE/C;AAWV;;;;ACXT;;;;;;;;;;;AC0CA;;;;;;;;;;;;;;;iBAAgB,KAAA,sCAER,iDACmB"}

package/dist/curry-BcQ8Up1_.js

@@ -0,0 +1,2 @@
+import{t as e}from"./lazy-data-last-impl-DW5TXWv8.js";function t(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e(t,n,r);throw Error(`Wrong number of arguments`)}export{t};
+//# sourceMappingURL=curry-BcQ8Up1_.js.map

package/dist/curry-BcQ8Up1_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-BcQ8Up1_.js","names":[],"sources":["../src/curry.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\n/**\n * Creates a function with `dataFirst` and `dataLast` signatures.\n *\n * `curry` is a dynamic function and it's not type safe. It should be wrapped by\n * a function that have proper typings. Refer to the example below for correct\n * usage.\n *\n * !IMPORTANT: functions that simply call `curry` and return the result (like\n * almost all functions in this library) should return `unknown` themselves if\n * an explicit return type is required. This is because we currently don't\n * provide a generic return type that is built from the input function, and\n * crafting one manually isn't worthwhile as we rely on function declaration\n * overloading to combine the types for dataFirst and dataLast invocations!\n *\n * @param fn - The function to curry.\n * @param args - The arguments.\n * @param lazy - A lazy version of the function to curry.\n * @signature P.curry(fn, args);\n * @example\n *    function _findIndex(array, fn) {\n *      for (let i = 0; i < array.length; i++) {\n *        if (fn(array[i])) {\n *          return i;\n *        }\n *      }\n *      return -1;\n *    }\n *\n *    // data-first\n *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;\n *\n *    // data-last\n *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;\n *\n *    function findIndex(...args: unknown[]) {\n *      return P.curry(_findIndex, args);\n *    }\n * @category Function\n */\nexport function curry(\n  fn: (...args: any) => unknown,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n): unknown {\n  const diff = fn.length - args.length;\n  if (diff === 0) {\n    return fn(...args);\n  }\n\n  if (diff === 1) {\n    return lazyDataLastImpl(fn, args, lazy);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"sDA4CA,SAAgB,EACd,EACA,EACA,EACS,CACT,IAAM,EAAO,EAAG,OAAS,EAAK,OAC9B,GAAI,IAAS,EACX,OAAO,EAAG,GAAG,EAAK,CAGpB,GAAI,IAAS,EACX,OAAO,EAAiB,EAAI,EAAM,EAAK,CAGzC,MAAU,MAAM,4BAA4B"}

package/dist/curry-BsY0Z8jH.cjs

@@ -0,0 +1 @@
+const e=require(`./lazy-data-last-impl-D4kLybyP.cjs`);function t(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e.t(t,n,r);throw Error(`Wrong number of arguments`)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});