@vinicunca/perkakas 0.5.4 → 1.0.0

package/dist/clamp.d.cts

@@ -0,0 +1,39 @@
+interface Limits {
+    readonly max?: number;
+    readonly min?: number;
+}
+interface Limits {
+    readonly max?: number;
+    readonly min?: number;
+}
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ *
+ * @param value - The number.
+ * @param limits - The bounds limits.
+ * @signature
+ *    P.clamp(value, { min, max });
+ * @example
+ *    clamp(10, { min: 20 }) // => 20
+ *    clamp(10, { max: 5 }) // => 5
+ *    clamp(10, { max: 20, min: 5 }) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function clamp(value: number, limits: Limits): number;
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ *
+ * @param limits - The bounds limits.
+ * @signature
+ *    P.clamp({ min, max })(value);
+ * @example
+ *    clamp({ min: 20 })(10) // => 20
+ *    clamp({ max: 5 })(10) // => 5
+ *    clamp({ max: 20, min: 5 })(10) // => 10
+ * @dataLast
+ * @category Number
+ */
+declare function clamp(limits: Limits): (value: number) => number;
+
+export { clamp };

package/dist/clamp.d.ts

@@ -0,0 +1,39 @@
+interface Limits {
+    readonly max?: number;
+    readonly min?: number;
+}
+interface Limits {
+    readonly max?: number;
+    readonly min?: number;
+}
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ *
+ * @param value - The number.
+ * @param limits - The bounds limits.
+ * @signature
+ *    P.clamp(value, { min, max });
+ * @example
+ *    clamp(10, { min: 20 }) // => 20
+ *    clamp(10, { max: 5 }) // => 5
+ *    clamp(10, { max: 20, min: 5 }) // => 10
+ * @dataFirst
+ * @category Number
+ */
+declare function clamp(value: number, limits: Limits): number;
+/**
+ * Clamp the given value within the inclusive min and max bounds.
+ *
+ * @param limits - The bounds limits.
+ * @signature
+ *    P.clamp({ min, max })(value);
+ * @example
+ *    clamp({ min: 20 })(10) // => 20
+ *    clamp({ max: 5 })(10) // => 5
+ *    clamp({ max: 20, min: 5 })(10) // => 10
+ * @dataLast
+ * @category Number
+ */
+declare function clamp(limits: Limits): (value: number) => number;
+
+export { clamp };

package/dist/clamp.js

@@ -0,0 +1 @@
+import{a}from"./chunk-UO2ELCGC.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as clamp};

package/dist/clone.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkU3YJZ66Ocjs = require('./chunk-U3YJZ66O.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.clone = _chunkU3YJZ66Ocjs.a;

package/dist/clone.d.cts

@@ -0,0 +1,27 @@
+/**
+ * Creates a deep copy of the value. Supported types. Functions are assigned by
+ * reference rather than copied.
+ *
+ * @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. Functions are assigned by
+ * reference rather than copied.
+ *
+ * @signature
+ *   P.clone()(data)
+ * @example
+ *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
+ * @dataLast
+ * @category Object
+ */
+declare function clone(): <T>(data: T) => T;
+
+export { clone };

package/dist/clone.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Creates a deep copy of the value. Supported types. Functions are assigned by
+ * reference rather than copied.
+ *
+ * @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. Functions are assigned by
+ * reference rather than copied.
+ *
+ * @signature
+ *   P.clone()(data)
+ * @example
+ *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
+ * @dataLast
+ * @category Object
+ */
+declare function clone(): <T>(data: T) => T;
+
+export { clone };

package/dist/clone.js

@@ -0,0 +1 @@
+import{a}from"./chunk-5XZK5BDM.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as clone};

package/dist/concat.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJ2THP74Pcjs = require('./chunk-J2THP74P.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.concat = _chunkJ2THP74Pcjs.a;

package/dist/concat.d.cts

@@ -0,0 +1,39 @@
+import { I as IterableContainer } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * 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];
+
+export { concat };

package/dist/concat.d.ts

@@ -0,0 +1,39 @@
+import { I as IterableContainer } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * 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];
+
+export { concat };

package/dist/concat.js

@@ -0,0 +1 @@
+import{a}from"./chunk-QU5PCAYZ.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as concat};

package/dist/conditional.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkDQPVQH4Hcjs = require('./chunk-DQPVQH4H.cjs');exports.conditional = _chunkDQPVQH4Hcjs.a;

package/dist/conditional.d.cts

@@ -0,0 +1,121 @@
+type Case<In, Out, Thru extends In = In> = readonly [
+    when: ((data: In) => boolean) | ((data: In) => data is Thru),
+    then: (data: Thru) => Out
+];
+declare const conditionalPlus: typeof conditional & {
+    defaultCase: typeof defaultCase;
+};
+
+/**
+ * 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.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * 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.
+ *
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @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;
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.conditional.defaultCase(
+ *         (something) => `Hello something (${JSON.stringify(something)})`,
+ *       ),
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * 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.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * 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.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @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;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(data: T, case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * A simplified case that accepts all data. Put this as the last case to
+ * prevent an exception from being thrown when none of the previous cases
+ * match.
+ * If this is not the last case it will short-circuit anything after it.
+ *
+ * @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}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ */
+declare function defaultCase(): Case<unknown, undefined>;
+declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
+
+export { conditionalPlus as conditional };

package/dist/conditional.d.ts

@@ -0,0 +1,121 @@
+type Case<In, Out, Thru extends In = In> = readonly [
+    when: ((data: In) => boolean) | ((data: In) => data is Thru),
+    then: (data: Thru) => Out
+];
+declare const conditionalPlus: typeof conditional & {
+    defaultCase: typeof defaultCase;
+};
+
+/**
+ * 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.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * 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.
+ *
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @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;
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.conditional.defaultCase(
+ *         (something) => `Hello something (${JSON.stringify(something)})`,
+ *       ),
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * 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.
+ *
+ * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
+ * Ramda, this implementation does **NOT** return a default/fallback
+ * `undefined` value when none of the cases match; and instead will **throw** an
+ * exception in those cases.
+ * To add a default case use the `conditional.defaultCase` helper as the final
+ * case of your implementation. By default it returns `undefined`, but could be
+ * provided a transformer in order to return something else.
+ *
+ * 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.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
+ * consists of a predicate (or a type-predicate) and a transformer function that
+ * processes the data if its case matches.
+ * @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;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(data: T, case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
+/**
+ * A simplified case that accepts all data. Put this as the last case to
+ * prevent an exception from being thrown when none of the previous cases
+ * match.
+ * If this is not the last case it will short-circuit anything after it.
+ *
+ * @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}`],
+ *     P.conditional.defaultCase(
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3'
+ */
+declare function defaultCase(): Case<unknown, undefined>;
+declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
+
+export { conditionalPlus as conditional };

package/dist/conditional.js

@@ -0,0 +1 @@
+import{a}from"./chunk-2G3P6PPR.js";export{a as conditional};

package/dist/constant.cjs

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

package/dist/constant.d.cts

@@ -0,0 +1,30 @@
+/**
+ * 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<T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
+
+export { constant };

package/dist/constant.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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<T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
+
+export { constant };

package/dist/constant.js

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

package/dist/curry-order-rules-BOMf1JS7.d.cts

@@ -0,0 +1,37 @@
+declare const COMPARATORS: {
+    readonly asc: <T>(x: T, y: T) => boolean;
+    readonly desc: <T_1>(x: T_1, y: T_1) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = {
+    [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+    toString: () => string;
+} | {
+    valueOf: () => ComparablePrimitive;
+} | ComparablePrimitive;
+type ComparablePrimitive = bigint | boolean | number | string;
+
+export type { OrderRule as O };

package/dist/curry-order-rules-BOMf1JS7.d.ts

@@ -0,0 +1,37 @@
+declare const COMPARATORS: {
+    readonly asc: <T>(x: T, y: T) => boolean;
+    readonly desc: <T_1>(x: T_1, y: T_1) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = {
+    [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+    toString: () => string;
+} | {
+    valueOf: () => ComparablePrimitive;
+} | ComparablePrimitive;
+type ComparablePrimitive = bigint | boolean | number | string;
+
+export type { OrderRule as O };

package/dist/curry.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkY74ER22Ocjs = require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.curry = _chunkY74ER22Ocjs.a;