@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/clone.d.ts

@@ -1,2 +1,35 @@
-import { clone } from "./clone-CY68Bkn3.js";
-export { clone };
+//#region src/clone.d.ts
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @param data - The object to clone.
+ * @signature
+ *   P.clone(data)
+ * @example
+ *   P.clone({foo: 'bar'}) // {foo: 'bar'}
+ * @dataFirst
+ * @category Object
+ */
+declare function clone<T>(data: T): T;
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @signature
+ *   P.clone()(data)
+ * @example
+ *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
+ * @dataLast
+ * @category Object
+ */
+declare function clone(): <T>(data: T) => T;
+//#endregion
+export { clone };
+//# sourceMappingURL=clone.d.ts.map

package/dist/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","names":[],"sources":["../src/clone.ts"],"sourcesContent":[],"mappings":";;AAiBA;AAgBA;;;;;;;;;;;;;iBAhBgB,eAAe,IAAI;;;;;;;;;;;;;;;iBAgBnB,KAAA,CAAA,aAAmB,MAAM"}

package/dist/clone.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{clone as e}from"./clone-BcAGB1C1.js";export{e as clone};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o>=0?n[o]:(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n))}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}export{t as clone};
+//# sourceMappingURL=clone.js.map

package/dist/clone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.js","names":["copiedValue: Record<PropertyKey, unknown>","copiedValue: Array<unknown>"],"sources":["../src/clone.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   P.clone(data)\n * @example\n *   P.clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   P.clone()(data)\n * @example\n *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: ReadonlyArray<unknown>): unknown {\n  return curry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: Array<unknown> = [],\n  refTo: Array<unknown> = [],\n): T {\n  if (typeof value === 'function') {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value)\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    && prototype !== null\n    && prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  /**\n   * In order to support cyclic/self-referential structures,\n   * and to support functions _within_ objects,\n   * we need to have our own cloning logic.\n   */\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx >= 0) {\n    return refTo[idx] as T;\n  }\n  /**\n   * And if we haven't, we add it to our list of seen values so that it is kept\n   * and clone the deep structure.\n   */\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  /**\n   * It's important to first push the cloned ref so that it's index is kept in\n   * sync with the ref to the original value in refFrom.\n   */\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends ReadonlyArray<unknown>>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Array<unknown> = [];\n\n  /**\n   * It's important to first push the cloned ref so that it's index is kept in\n   * sync with the ref to the original value in refFrom.\n   */\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"wCAmCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAA0B,EAAE,CAC5B,EAAwB,EAAE,CACvB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAG/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGlB,IAAc,MACd,IAAc,OAAO,UAKxB,OAAO,gBAAgB,EAAM,CAU/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CASlC,OARI,GAAO,EACF,EAAM,IAMf,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAG5C,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMA,EAA4C,EAAE,CAMpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMC,EAA8B,EAAE,CAMtC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}

package/dist/coerced-array-BKR9Bvsl.d.cts

@@ -0,0 +1,17 @@
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/coerced-array.d.ts
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
+//#endregion
+export { CoercedArray as t };
+//# sourceMappingURL=coerced-array-BKR9Bvsl.d.cts.map

package/dist/coerced-array-BKR9Bvsl.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerced-array-BKR9Bvsl.d.cts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}

package/dist/coerced-array-BfTLxqLo.d.ts

@@ -0,0 +1,17 @@
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/coerced-array.d.ts
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
+//#endregion
+export { CoercedArray as t };
+//# sourceMappingURL=coerced-array-BfTLxqLo.d.ts.map

package/dist/coerced-array-BfTLxqLo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerced-array-BfTLxqLo.d.ts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}

package/dist/concat.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./concat-Cg3I4d7x.cjs`);exports.concat=e.concat;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return[...e,...t]}exports.concat=t;

package/dist/concat.d.cts

@@ -1,3 +1,41 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { concat } from "./concat-BdgaaV6q.cjs";
-export { concat };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+
+//#region src/concat.d.ts
+
+/**
+ * Merge two or more arrays. This method does not change the existing arrays,
+ * but instead returns a new array, even if the other array is empty.
+ *
+ * @param data - The first items, these would be at the beginning of the new
+ * array.
+ * @param other - The remaining items, these would be at the end of the new
+ * array.
+ * @returns A new array with the items of the first array followed by the items
+ * of the second array.
+ * @signature
+ *    P.concat(data, other);
+ * @example
+ *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
+ * @dataFirst
+ * @category Array
+ */
+declare function concat<T1 extends IterableContainer, T2 extends IterableContainer>(data: T1, other: T2): [...T1, ...T2];
+/**
+ * Merge two or more arrays. This method does not change the existing arrays,
+ * but instead returns a new array, even if the other array is empty.
+ *
+ * @param other - The remaining items, these would be at the end of the new
+ * array.
+ * @returns A new array with the items of the first array followed by the items
+ * of the second array.
+ * @signature
+ *    P.concat(arr2)(arr1);
+ * @example
+ *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
+ * @dataLast
+ * @category Array
+ */
+declare function concat<T2 extends IterableContainer>(other: T2): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];
+//#endregion
+export { concat };
+//# sourceMappingURL=concat.d.cts.map

package/dist/concat.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.cts","names":[],"sources":["../src/concat.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;AAoBA;;;;;;;AAE4D,iBAtB5C,MAsB4C,CAAA,WArB/C,iBAqB+C,EAAA,WApB/C,iBAoB+C,CAAA,CAAA,IAAA,EAnBpD,EAmBoD,EAAA,KAAA,EAnBzC,EAmByC,CAAA,EAAA,CAAA,GAnBhC,EAmBgC,EAAA,GAnBzB,EAmByB,CAAA;;;;;;;;;;;;;;;;iBAF5C,kBAAkB,0BACzB,iBACM,yBAAyB,WAAW,OAAO"}

package/dist/concat.d.ts

@@ -1,3 +1,41 @@
-import "./iterable-container-F9CDF7ym.js";
-import { concat } from "./concat-BOAliAPo.js";
-export { concat };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+
+//#region src/concat.d.ts
+
+/**
+ * Merge two or more arrays. This method does not change the existing arrays,
+ * but instead returns a new array, even if the other array is empty.
+ *
+ * @param data - The first items, these would be at the beginning of the new
+ * array.
+ * @param other - The remaining items, these would be at the end of the new
+ * array.
+ * @returns A new array with the items of the first array followed by the items
+ * of the second array.
+ * @signature
+ *    P.concat(data, other);
+ * @example
+ *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
+ * @dataFirst
+ * @category Array
+ */
+declare function concat<T1 extends IterableContainer, T2 extends IterableContainer>(data: T1, other: T2): [...T1, ...T2];
+/**
+ * Merge two or more arrays. This method does not change the existing arrays,
+ * but instead returns a new array, even if the other array is empty.
+ *
+ * @param other - The remaining items, these would be at the end of the new
+ * array.
+ * @returns A new array with the items of the first array followed by the items
+ * of the second array.
+ * @signature
+ *    P.concat(arr2)(arr1);
+ * @example
+ *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
+ * @dataLast
+ * @category Array
+ */
+declare function concat<T2 extends IterableContainer>(other: T2): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];
+//#endregion
+export { concat };
+//# sourceMappingURL=concat.d.ts.map

package/dist/concat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","names":[],"sources":["../src/concat.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;AAoBA;;;;;;;AAE4D,iBAtB5C,MAsB4C,CAAA,WArB/C,iBAqB+C,EAAA,WApB/C,iBAoB+C,CAAA,CAAA,IAAA,EAnBpD,EAmBoD,EAAA,KAAA,EAnBzC,EAmByC,CAAA,EAAA,CAAA,GAnBhC,EAmBgC,EAAA,GAnBzB,EAmByB,CAAA;;;;;;;;;;;;;;;;iBAF5C,kBAAkB,0BACzB,iBACM,yBAAyB,WAAW,OAAO"}

package/dist/concat.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{concat as e}from"./concat-CVEXmYnw.js";export{e as concat};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return[...e,...t]}export{t as concat};
+//# sourceMappingURL=concat.js.map

package/dist/concat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    P.concat(data, other);\n * @example\n *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    P.concat(arr2)(arr1);\n * @example\n *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: ReadonlyArray<unknown>): unknown {\n  return curry(concatImplementation, args);\n}\n\nfunction concatImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] {\n  return [...arr1, ...arr2];\n};\n"],"mappings":"wCA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAIP,EACA,EACgB,CAChB,MAAO,CAAC,GAAG,EAAM,GAAG,EAAK"}

package/dist/conditional-6ff4g8Sy.cjs

@@ -0,0 +1 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}const t=Object.assign(n,{defaultCase:a});function n(...t){return e(i,r,t)}function r(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function i(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}function a(e=s){return[o,e]}function o(){return!0}function s(){}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

package/dist/conditional-Br0uqqc9.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-Br0uqqc9.d.cts.map

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

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