@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/curry-CKDQ1osk.d.ts

@@ -0,0 +1,70 @@
+import { t as StrictFunction } from "./strict-function-BBgKFNUw.js";
+
+//#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: StrictFunction, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+//#endregion
+export { curry as t };
+//# sourceMappingURL=curry-CKDQ1osk.d.ts.map

package/dist/curry-CKDQ1osk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-CKDQ1osk.d.ts","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;UAErD,SAAA;;EAFE,OAAA,EAAA,KAAU;EAAM,OAAA,CAAA,EAAA,KAAA,GAAA,SAAA;EAAqB,IAAA,CAAA,EAAA,SAAA;;UASvC,QATqD,CAAA,CAAA,CAAA,CAAA;EAAT,IAAA,EAAA,OAAA;EAAQ,OAAA,EAAA,IAAA;EAEpD,OAAA,CAAA,EAAA,KAAS,GAAA,SAAA;EAOT,IAAA,EAIF,CAJE;AAID;UAGC;;;ECdE,OAAA,EAAA,IAAA;EAA+B,IAAA,EDkBnC,aClBmC,CDkBrB,CClBqB,CAAA;;;;KAA/B,+BAA+B,YACnC,wBAEA,cAAc,OACjB,WAAW;;;;ADNhB;;;;;;;AAAkE;AAE/C;AAWV;;;;ACXT;;;;;;;;;;;AC2CA;;;;;;;;;;;;;;iBAAgB,KAAA,KACV,sBACE,iDACmB"}

package/dist/curry-NmniqyJ0.js

@@ -0,0 +1,2 @@
+import{t as e}from"./lazy-data-last-impl-R05wr4K6.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-NmniqyJ0.js.map

package/dist/curry-NmniqyJ0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-NmniqyJ0.js","names":[],"sources":["../src/curry.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { StrictFunction } from './internal/types/strict-function';\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: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n): unknown {\n  const diff = fn.length - args.length;\n  if (diff === 0) {\n    // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n    // anything about `fn` so can't ensure that we are passing the correct\n    // arguments to it, we just have to trust that the caller knows what they\n    // are doing.\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":"sDA6CA,SAAgB,EACd,EACA,EACA,EACS,CACT,IAAM,EAAO,EAAG,OAAS,EAAK,OAC9B,GAAI,IAAS,EAKX,OAAO,EAAG,GAAG,EAAK,CAGpB,GAAI,IAAS,EACX,OAAO,EAAiB,EAAI,EAAM,EAAK,CAGzC,MAAU,MAAM,4BAA4B"}

package/dist/curry-from-lazy-BCGvmhyS.cjs

@@ -0,0 +1 @@
+const e=require(`./pipe-CB7Lufqv.cjs`);function t(t,n){let r=n.length-t.length;if(r===1){let[r,...i]=n;return e.t(r,{lazy:t,lazyArgs:i})}if(r===0){let r={lazy:t,lazyArgs:n};return Object.assign(t=>e.t(t,r),r)}throw Error(`Wrong number of arguments`)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

package/dist/curry-from-lazy-PQ0BbG-7.js

@@ -0,0 +1,2 @@
+import{t as e}from"./pipe-CZKusDA-.js";function t(t,n){let r=n.length-t.length;if(r===1){let[r,...i]=n;return e(r,{lazy:t,lazyArgs:i})}if(r===0){let r={lazy:t,lazyArgs:n};return Object.assign(t=>e(t,r),r)}throw Error(`Wrong number of arguments`)}export{t};
+//# sourceMappingURL=curry-from-lazy-PQ0BbG-7.js.map

package/dist/curry-from-lazy-PQ0BbG-7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-from-lazy-PQ0BbG-7.js","names":[],"sources":["../src/internal/curry-from-lazy.ts"],"sourcesContent":["import type { LazyDefinition } from './types/lazy-definition';\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport { pipe } from '../pipe';\n\n/**\n * A version of `curry` for cases where the only meaningful implementation is a\n * lazy one. This is useful for functions that don't have a built-in\n * implementation already, and that can't be optimized to take advantage of\n * having the complete array upfront.\n *\n * Under the hood the function uses `pipe` to utilize it's built-in lazy logic\n * and wraps the pipe with the required invocations to allow using the function\n * outside of pipes too.\n *\n * @param lazy - The main lazy implementation, it assumes that data is an\n * iterable (array-like).\n * @param args - The arguments passed to the overloaded invocation.\n * @see curry\n * @see pipe\n */\nexport function curryFromLazy(\n  // eslint-disable-next-line ts/no-explicit-any\n  lazy: (...args: any) => LazyEvaluator,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  const diff = args.length - lazy.length;\n\n  if (diff === 1) {\n    // dataFirst\n    const [data, ...rest] = args;\n    const lazyDefinition = { lazy, lazyArgs: rest } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    return pipe(data, lazyDefinition);\n  }\n\n  if (diff === 0) {\n    const lazyDefinition = { lazy, lazyArgs: args } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    const dataLast = (data: unknown): unknown => pipe(data, lazyDefinition);\n    return Object.assign(dataLast, lazyDefinition);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"uCAoBA,SAAgB,EAEd,EACA,EACS,CACT,IAAM,EAAO,EAAK,OAAS,EAAK,OAEhC,GAAI,IAAS,EAAG,CAEd,GAAM,CAAC,EAAM,GAAG,GAAQ,EAIxB,OAAO,EAAK,EAHW,CAAE,OAAM,SAAU,EAAM,CAGd,CAGnC,GAAI,IAAS,EAAG,CACd,IAAM,EAAiB,CAAE,OAAM,SAAU,EAAM,CAI/C,OAAO,OAAO,OADI,GAA2B,EAAK,EAAM,EAAe,CACxC,EAAe,CAGhD,MAAU,MAAM,4BAA4B"}

package/dist/curry-mh6BKSIA.d.cts

@@ -0,0 +1,70 @@
+import { t as StrictFunction } from "./strict-function-CPTwDgnZ.cjs";
+
+//#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: StrictFunction, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+//#endregion
+export { curry as t };
+//# sourceMappingURL=curry-mh6BKSIA.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curry-mh6BKSIA.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;UAErD,SAAA;;EAFE,OAAA,EAAA,KAAU;EAAM,OAAA,CAAA,EAAA,KAAA,GAAA,SAAA;EAAqB,IAAA,CAAA,EAAA,SAAA;;UASvC,QATqD,CAAA,CAAA,CAAA,CAAA;EAAT,IAAA,EAAA,OAAA;EAAQ,OAAA,EAAA,IAAA;EAEpD,OAAA,CAAA,EAAA,KAAS,GAAA,SAAA;EAOT,IAAA,EAIF,CAJE;AAID;UAGC;;;ECdE,OAAA,EAAA,IAAA;EAA+B,IAAA,EDkBnC,aClBmC,CDkBrB,CClBqB,CAAA;;;;KAA/B,+BAA+B,YACnC,wBAEA,cAAc,OACjB,WAAW;;;;ADNhB;;;;;;;AAAkE;AAE/C;AAWV;;;;ACXT;;;;;;;;;;;AC2CA;;;;;;;;;;;;;;iBAAgB,KAAA,KACV,sBACE,iDACmB"}

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

@@ -0,0 +1,48 @@
+//#region src/internal/curry-order-rules.d.ts
+declare const COMPARATORS: {
+  readonly asc: <T>(x: T, y: T) => boolean;
+  readonly desc: <T>(x: T, y: T) => 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 = ComparablePrimitive | {
+  [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+  toString: () => string;
+} | {
+  valueOf: () => ComparablePrimitive;
+};
+type ComparablePrimitive = bigint | boolean | number | string;
+/**
+ * Allows functions that want to handle a variadic number of order rules a
+ * a simplified API that hides most of the implementation details. The only
+ * thing users of this function need to do is provide a function that would take
+ * the data, and a compare function that can be used to determine the order
+ * between the items of the array.
+ * This functions takes care of the rest; it will parse rules, built the
+ * comparer, and manage the currying of the input arguments.
+ */
+//#endregion
+export { OrderRule as t };
+//# sourceMappingURL=curry-order-rules-BoF09Dq2.d.cts.map

package/dist/curry-order-rules-BoF09Dq2.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-BoF09Dq2.d.cts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAFI,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAM,CAAN,EAAA,GAAA,OAAA;EAAM,SAAA,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACL,CADK,EAAA,CAAA,EACC,CADD,EAAA,GAAA,OAAA;CACL;;;AAwBf;;;;;;;AAEgF;AAEvC;;;;;;AASC;;;;;KAb9B,eACN,WAAW,2BACW,WAAW,4BAA4B;KAE9D,oBAAoB,MAAM;KAK1B,UAAA,GACC;GACG,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/curry-order-rules-ClqHrs8_.cjs

@@ -0,0 +1 @@
+const e={asc:(e,t)=>e>t,desc:(e,t)=>e<t};function t(e,t){let[n,...a]=t;if(!i(n))return e(n,r(...a));let o=r(n,...a);return t=>e(t,o)}function n(e,[n,r,...a]){let o,s;return i(r)?(o=n,s=[r,...a]):(o=r,s=[n,...a]),t((...t)=>e(...t,o),s)}function r(t,n,...i){let a=typeof t==`function`?t:t[0],o=typeof t==`function`?`asc`:t[1],{[o]:s}=e,c=n===void 0?void 0:r(n,...i);return(e,t)=>{let n=a(e),r=a(t);return s(n,r)?1:s(r,n)?-1:c?.(e,t)??0}}function i(t){if(a(t))return!0;if(typeof t!=`object`||!Array.isArray(t))return!1;let[n,r,...i]=t;return a(n)&&typeof r==`string`&&r in e&&i.length===0}function a(e){return typeof e==`function`&&e.length===1}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

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

@@ -0,0 +1,48 @@
+//#region src/internal/curry-order-rules.d.ts
+declare const COMPARATORS: {
+  readonly asc: <T>(x: T, y: T) => boolean;
+  readonly desc: <T>(x: T, y: T) => 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 = ComparablePrimitive | {
+  [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+  toString: () => string;
+} | {
+  valueOf: () => ComparablePrimitive;
+};
+type ComparablePrimitive = bigint | boolean | number | string;
+/**
+ * Allows functions that want to handle a variadic number of order rules a
+ * a simplified API that hides most of the implementation details. The only
+ * thing users of this function need to do is provide a function that would take
+ * the data, and a compare function that can be used to determine the order
+ * between the items of the array.
+ * This functions takes care of the rest; it will parse rules, built the
+ * comparer, and manage the currying of the input arguments.
+ */
+//#endregion
+export { OrderRule as t };
+//# sourceMappingURL=curry-order-rules-CoO4bk5I.d.ts.map

package/dist/curry-order-rules-CoO4bk5I.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-CoO4bk5I.d.ts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAFI,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAM,CAAN,EAAA,GAAA,OAAA;EAAM,SAAA,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACL,CADK,EAAA,CAAA,EACC,CADD,EAAA,GAAA,OAAA;CACL;;;AAwBf;;;;;;;AAEgF;AAEvC;;;;;;AASC;;;;;KAb9B,eACN,WAAW,2BACW,WAAW,4BAA4B;KAE9D,oBAAoB,MAAM;KAK1B,UAAA,GACC;GACG,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/curry-order-rules-DwrF-_P1.js

@@ -0,0 +1,2 @@
+const e={asc:(e,t)=>e>t,desc:(e,t)=>e<t};function t(e,t){let[n,...a]=t;if(!i(n))return e(n,r(...a));let o=r(n,...a);return t=>e(t,o)}function n(e,[n,r,...a]){let o,s;return i(r)?(o=n,s=[r,...a]):(o=r,s=[n,...a]),t((...t)=>e(...t,o),s)}function r(t,n,...i){let a=typeof t==`function`?t:t[0],o=typeof t==`function`?`asc`:t[1],{[o]:s}=e,c=n===void 0?void 0:r(n,...i);return(e,t)=>{let n=a(e),r=a(t);return s(n,r)?1:s(r,n)?-1:c?.(e,t)??0}}function i(t){if(a(t))return!0;if(typeof t!=`object`||!Array.isArray(t))return!1;let[n,r,...i]=t;return a(n)&&typeof r==`string`&&r in e&&i.length===0}function a(e){return typeof e==`function`&&e.length===1}export{n,t};
+//# sourceMappingURL=curry-order-rules-DwrF-_P1.js.map

package/dist/curry-order-rules-DwrF-_P1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-DwrF-_P1.js","names":["arg: unknown","argRemoved: ReadonlyArray<unknown>"],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":["import type { CompareFunction } from './types/compare-function';\nimport type { NonEmptyArray } from './types/non-empty-array';\n\n// We define the comparators in a global const so that they are only\n// instantiated once, and so we can couple a label (string) for them that could\n// be used in runtime to refer to them (e.g. \"asc\", \"desc\").\nconst COMPARATORS = {\n  asc: <T>(x: T, y: T) => x > y,\n  desc: <T>(x: T, y: T) => x < y,\n} as const;\n\n/**\n * An order rule defines a projection/extractor that returns a comparable from\n * the data being compared. It would be run on each item being compared, and a\n * comparator would then be used on the results to determine the order.\n *\n * There are 2 forms of the order rule, a simple one which only provides the\n * projection function and assumes ordering is ascending, and a 2-tuple where\n * the first element is the projection function and the second is the direction;\n * this allows changing the direction without defining a more complex projection\n * to simply negate the value (e.g. `(x) => -x`).\n *\n * We rely on the javascript implementation of `<` and `>` for comparison, which\n * will attempt to transform both operands into a primitive comparable value via\n * the built in `valueOf` function (and then `toString`). It's up to the caller\n * to make sure that the projection is returning a value that makes sense for\n * this logic.\n *\n * It's important to note that there is no built-in caching/memoization of\n * projection function and therefore no guarantee that it would only be called\n * once.\n */\nexport type OrderRule<T>\n  = | Projection<T>\n    | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];\n\ntype Projection<T> = (x: T) => Comparable;\n\n// We define the Comparable based on how JS coerces values into primitives when\n// used with the `<` and `>` operators.\n// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#type_coercion\ntype Comparable\n  = | ComparablePrimitive\n    | { [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive }\n    | { toString: () => string }\n    | { valueOf: () => ComparablePrimitive };\n\n//  Notice that `boolean` is special in that it is coerced as a number (0 for\n// `false`, 1 for `true`) implicitly.\ntype ComparablePrimitive = bigint | boolean | number | string;\n\n/**\n * Allows functions that want to handle a variadic number of order rules a\n * a simplified API that hides most of the implementation details. The only\n * thing users of this function need to do is provide a function that would take\n * the data, and a compare function that can be used to determine the order\n * between the items of the array.\n * This functions takes care of the rest; it will parse rules, built the\n * comparer, and manage the currying of the input arguments.\n */\nexport function curryOrderRules<T>(\n  func: (data: ReadonlyArray<T>, compareFn: CompareFunction<T>) => unknown,\n  inputArgs: ReadonlyArray<unknown>,\n): unknown {\n  // We rely on casting blindly here, but we rely on casting blindly everywhere\n  // else when we call curry so it's fine...\n  const [dataOrRule, ...rules] = inputArgs as\n    | [\n        data: OrderRule<T> | ReadonlyArray<T>,\n        ...rules: Readonly<NonEmptyArray<OrderRule<T>>>,\n    ]\n    | Readonly<NonEmptyArray<OrderRule<T>>>;\n\n  if (!isOrderRule<T>(dataOrRule)) {\n    // dataFirst!\n\n    // @ts-expect-error [ts2556]: Typescript is failing to infer the type of rules\n    // correctly here after the type refinement above, rules should be non-empty\n    // when we get here.\n    const compareFn = orderRuleComparer(...rules);\n    return func(dataOrRule, compareFn);\n  }\n\n  // dataLast!\n\n  // Important: initialize the comparer outside of the returned function so it\n  // it's constructed and shared everywhere (it's stateless so should be safe\n  // if used multiple times).\n  const compareFn = orderRuleComparer(dataOrRule, ...rules);\n  return (data: ReadonlyArray<T>) => func(data, compareFn);\n}\n\n/**\n * Some functions need an extra number argument, this helps facilitate that.\n */\nexport function curryOrderRulesWithArgument(\n  func: <T>(\n    data: ReadonlyArray<T>,\n    compareFn: CompareFunction<T>,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    arg: any,\n  ) => unknown,\n  [first, second, ...rest]: ReadonlyArray<unknown>,\n): unknown {\n  // We need to pull the `n` argument out to make it work with curryOrderRules.\n  let arg: unknown;\n  let argRemoved: ReadonlyArray<unknown>;\n  if (isOrderRule(second)) {\n    // dataLast!\n    arg = first;\n    argRemoved = [second, ...rest];\n  } else {\n    // dataFirst!\n    arg = second;\n    argRemoved = [first, ...rest];\n  }\n\n  return curryOrderRules((...args) => func(...args, arg), argRemoved);\n}\n\nfunction orderRuleComparer<T>(\n  primaryRule: OrderRule<T>,\n  secondaryRule?: OrderRule<T>,\n  ...otherRules: ReadonlyArray<OrderRule<T>>\n): (a: T, b: T) => number {\n  const projector\n    = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];\n\n  const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];\n  const { [direction]: comparator } = COMPARATORS;\n\n  const nextComparer\n    = secondaryRule === undefined\n      ? undefined\n      : orderRuleComparer(secondaryRule, ...otherRules);\n\n  return (a, b) => {\n    const projectedA = projector(a);\n    const projectedB = projector(b);\n\n    if (comparator(projectedA, projectedB)) {\n      return 1;\n    }\n\n    if (comparator(projectedB, projectedA)) {\n      return -1;\n    }\n\n    // The elements are equal base on the current comparator and projection. So\n    // we need to check the elements using the next comparer, if one exists,\n    // otherwise we consider them as true equal (returning 0).\n    return nextComparer?.(a, b) ?? 0;\n  };\n}\n\nfunction isOrderRule<T>(x: unknown): x is OrderRule<T> {\n  if (isProjection(x)) {\n    return true;\n  }\n\n  if (typeof x !== 'object' || !Array.isArray(x)) {\n    return false;\n  }\n\n  const [maybeProjection, maybeDirection, ...rest]\n    = x as ReadonlyArray<unknown>;\n\n  return (\n    isProjection(maybeProjection)\n    && typeof maybeDirection === 'string'\n    && maybeDirection in COMPARATORS\n    // Has to be a 2-tuple\n    && rest.length === 0\n  );\n}\n\nfunction isProjection<T>(x: unknown): x is Projection<T> {\n  return typeof x === 'function' && x.length === 1;\n}\n"],"mappings":"AAMA,MAAM,EAAc,CAClB,KAAS,EAAM,IAAS,EAAI,EAC5B,MAAU,EAAM,IAAS,EAAI,EAC9B,CAmDD,SAAgB,EACd,EACA,EACS,CAGT,GAAM,CAAC,EAAY,GAAG,GAAS,EAO/B,GAAI,CAAC,EAAe,EAAW,CAO7B,OAAO,EAAK,EADM,EAAkB,GAAG,EAAM,CACX,CAQpC,IAAM,EAAY,EAAkB,EAAY,GAAG,EAAM,CACzD,MAAQ,IAA2B,EAAK,EAAM,EAAU,CAM1D,SAAgB,EACd,EAMA,CAAC,EAAO,EAAQ,GAAG,GACV,CAET,IAAIA,EACAC,EAWJ,OAVI,EAAY,EAAO,EAErB,EAAM,EACN,EAAa,CAAC,EAAQ,GAAG,EAAK,GAG9B,EAAM,EACN,EAAa,CAAC,EAAO,GAAG,EAAK,EAGxB,GAAiB,GAAG,IAAS,EAAK,GAAG,EAAM,EAAI,CAAE,EAAW,CAGrE,SAAS,EACP,EACA,EACA,GAAG,EACqB,CACxB,IAAM,EACF,OAAO,GAAgB,WAAa,EAAc,EAAY,GAE5D,EAAY,OAAO,GAAgB,WAAa,MAAQ,EAAY,GACpE,EAAG,GAAY,GAAe,EAE9B,EACF,IAAkB,IAAA,GAChB,IAAA,GACA,EAAkB,EAAe,GAAG,EAAW,CAErD,OAAQ,EAAG,IAAM,CACf,IAAM,EAAa,EAAU,EAAE,CACzB,EAAa,EAAU,EAAE,CAa/B,OAXI,EAAW,EAAY,EAAW,CAC7B,EAGL,EAAW,EAAY,EAAW,CAC7B,GAMF,IAAe,EAAG,EAAE,EAAI,GAInC,SAAS,EAAe,EAA+B,CACrD,GAAI,EAAa,EAAE,CACjB,MAAO,GAGT,GAAI,OAAO,GAAM,UAAY,CAAC,MAAM,QAAQ,EAAE,CAC5C,MAAO,GAGT,GAAM,CAAC,EAAiB,EAAgB,GAAG,GACvC,EAEJ,OACE,EAAa,EAAgB,EAC1B,OAAO,GAAmB,UAC1B,KAAkB,GAElB,EAAK,SAAW,EAIvB,SAAS,EAAgB,EAAgC,CACvD,OAAO,OAAO,GAAM,YAAc,EAAE,SAAW"}

package/dist/curry.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`);const e=require(`./curry-BPVIsvo3.cjs`);exports.curry=e.curry;
+const e=require(`./curry-BsY0Z8jH.cjs`);exports.curry=e.t;

package/dist/curry.d.cts

@@ -1,2 +1,2 @@
-import { curry } from "./curry-gLBYaLmk.cjs";
+import { t as curry } from "./curry-mh6BKSIA.cjs";
 export { curry };

package/dist/curry.d.ts

@@ -1,2 +1,2 @@
-import { curry } from "./curry-2mBj-wsI.js";
+import { t as curry } from "./curry-CKDQ1osk.js";
 export { curry };

package/dist/curry.js

@@ -1 +1 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import{curry as e}from"./curry-CzZjDrpv.js";export{e as curry};
+import{t as e}from"./curry-NmniqyJ0.js";export{e as curry};

package/dist/debounce.cjs

@@ -1 +1 @@
-const e=require(`./debounce-6x-eQzOn.cjs`);exports.debounce=e.debounce;
+function e(e,{waitMs:t,timing:n=`trailing`,maxWaitMs:r}){if(r!==void 0&&t!==void 0&&r<t)throw Error(`debounce: maxWaitMs (${r}) cannot be less than waitMs (${t})`);let i,a,o,s;function c(){if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}if(o===void 0)throw Error(`PERKAKAS[debounce]: latestCallArgs was unexpectedly undefined.`);let t=o;o=void 0,s=e(...t)}function l(){if(i===void 0)return;let e=i;i=void 0,clearTimeout(e),o!==void 0&&c()}function u(e){o=e,r!==void 0&&a===void 0&&(a=setTimeout(c,r))}return{call:(...a)=>{if(i===void 0)n===`trailing`?u(a):s=e(...a);else{n!==`leading`&&u(a);let e=i;i=void 0,clearTimeout(e)}return i=setTimeout(l,t??r??0),s},cancel:()=>{if(i!==void 0){let e=i;i=void 0,clearTimeout(e)}if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}o=void 0},flush:()=>(l(),s),get isPending(){return i!==void 0},get cachedValue(){return s}}}exports.debounce=e;

package/dist/debounce.d.cts

@@ -1,2 +1,98 @@
-import { debounce } from "./debounce-BNkJBFrQ.cjs";
-export { debounce };
+import { t as StrictFunction } from "./strict-function-CPTwDgnZ.cjs";
+
+//#region src/debounce.d.ts
+type Debouncer<F extends StrictFunction, IsNullable extends boolean = true> = {
+  /**
+   * Invoke the debounced function.
+   *
+   * @param args - Same as the args for the debounced function.
+   * @returns The last computed value of the debounced function with the
+   * latest args provided to it. If `timing` does not include `leading` then the
+   * the function would return `undefined` until the first cool-down period is
+   * over, otherwise the function would always return the return type of the
+   * debounced function.
+   */
+  readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
+  /**
+   * Cancels any debounced functions without calling them, effectively resetting
+   * the debouncer to the same state it is when initially created.
+   */
+  readonly cancel: () => void;
+  /**
+   * Similar to `cancel`, but would also trigger the `trailing` invocation if
+   * the debouncer would run one at the end of the cool-down period.
+   */
+  readonly flush: () => ReturnType<F> | undefined;
+  /**
+   * Is `true` when there is an active cool-down period currently debouncing
+   * invocations.
+   */
+  readonly isPending: boolean;
+  /**
+   * The last computed value of the debounced function.
+   */
+  readonly cachedValue: ReturnType<F> | undefined;
+};
+type DebounceOptions = {
+  readonly waitMs?: number;
+  readonly maxWaitMs?: number;
+};
+/**
+ * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
+ * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
+ * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
+ * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
+ * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
+ *
+ * @param func - The function to debounce, the returned `call` function will have
+ * the exact same signature.
+ * @param options - An object allowing further customization of the debouncer:
+ * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
+ *   `leading` would result in the function being invoked at the start of the
+ *   cool-down period; `trailing` would result in the function being invoked at
+ *   the end of the cool-down period (using the args from the last call to the
+ *   debouncer). When `both` is selected the `trailing` invocation would only
+ *   take place if there were more than one call to the debouncer during the
+ *   cool-down period. **DEFAULT: 'trailing'**
+ * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
+ *   debouncer would wait until this amount of time has passed without **any**
+ *   additional calls to the debouncer before triggering the end-of-cool-down-
+ *   period event. When this happens, the function would be invoked (if `timing`
+ *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
+ * - `maxWaitMs?: number`. The length of time since a debounced call (a call
+ *   that the debouncer prevented from being invoked) was made until it would be
+ *   invoked. Because the debouncer can be continually triggered and thus never
+ *   reach the end of the cool-down period, this allows the function to still
+ *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
+ *   `'leading'`.
+ * @returns A debouncer object. The main function is `call`. In addition to it
+ * the debouncer comes with the following additional functions and properties:
+ * - `cancel` method to cancel delayed `func` invocations
+ * - `flush` method to end the cool-down period immediately.
+ * - `cachedValue` the latest return value of an invocation (if one occurred).
+ * - `isPending` flag to check if there is an inflight cool-down window.
+ * @signature
+ *   P.debounce(func, options);
+ * @example
+ *   const debouncer = debounce(identity(), { timing: 'trailing', waitMs: 1000 });
+ *   const result1 = debouncer.call(1); // => undefined
+ *   const result2 = debouncer.call(2); // => undefined
+ *   // after 1 second
+ *   const result3 = debouncer.call(3); // => 2
+ *   // after 1 second
+ *   debouncer.cachedValue; // => 3
+ * @dataFirst
+ * @category Function
+ * @see https://css-tricks.com/debouncing-throttling-explained-examples/
+ */
+declare function debounce<F extends StrictFunction>(func: F, options: DebounceOptions & {
+  readonly timing?: 'trailing';
+}): Debouncer<F>;
+declare function debounce<F extends StrictFunction>(func: F, options: (DebounceOptions & {
+  readonly timing: 'both';
+}) | (Omit<DebounceOptions, 'maxWaitMs'> & {
+  readonly timing: 'leading';
+})): Debouncer<F, false>;
+//#endregion
+export { debounce };
+//# sourceMappingURL=debounce.d.cts.map

package/dist/debounce.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.cts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";;;KAOK,oBAAoB;;AAF8C;;;;;;;;;EAsCpC,SAAA,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBtB,UAwBsB,CAxBX,CAwBW,CAAA,EAAA,GAvB5B,UAuB4B,CAvBjB,CAuBiB,CAAA,GAAA,CAAA,IAAA,SAvBE,UAuBF,GAAA,SAAA,GAAA,KAAA,CAAA;EAAX;;AAAU;AAwDlC;EAAmC,SAAA,MAAA,EAAA,GAAA,GAAA,IAAA;EAC3B;;;;EAEI,SAAA,KAAA,EAAA,GAAA,GAtEY,UAsEZ,CAtEuB,CAsEvB,CAAA,GAAA,SAAA;EACI;;;;EAIJ,SAAA,SAAA,EAAA,OAAA;EAAL;;;EACK,SAAA,WAAA,EAjEY,UAiEZ,CAjEuB,CAiEvB,CAAA,GAAA,SAAA;;KA9DP,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,mBAAmB,sBAC3B,YACG;;IACR,UAAU;iBACG,mBAAmB,sBAC3B,aAED;;MACA,KAAK;;KACT,UAAU"}

package/dist/debounce.d.ts

@@ -1,2 +1,98 @@
-import { debounce } from "./debounce-BzjeDvY7.js";
-export { debounce };
+import { t as StrictFunction } from "./strict-function-BBgKFNUw.js";
+
+//#region src/debounce.d.ts
+type Debouncer<F extends StrictFunction, IsNullable extends boolean = true> = {
+  /**
+   * Invoke the debounced function.
+   *
+   * @param args - Same as the args for the debounced function.
+   * @returns The last computed value of the debounced function with the
+   * latest args provided to it. If `timing` does not include `leading` then the
+   * the function would return `undefined` until the first cool-down period is
+   * over, otherwise the function would always return the return type of the
+   * debounced function.
+   */
+  readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
+  /**
+   * Cancels any debounced functions without calling them, effectively resetting
+   * the debouncer to the same state it is when initially created.
+   */
+  readonly cancel: () => void;
+  /**
+   * Similar to `cancel`, but would also trigger the `trailing` invocation if
+   * the debouncer would run one at the end of the cool-down period.
+   */
+  readonly flush: () => ReturnType<F> | undefined;
+  /**
+   * Is `true` when there is an active cool-down period currently debouncing
+   * invocations.
+   */
+  readonly isPending: boolean;
+  /**
+   * The last computed value of the debounced function.
+   */
+  readonly cachedValue: ReturnType<F> | undefined;
+};
+type DebounceOptions = {
+  readonly waitMs?: number;
+  readonly maxWaitMs?: number;
+};
+/**
+ * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
+ * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
+ * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
+ * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
+ * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
+ *
+ * @param func - The function to debounce, the returned `call` function will have
+ * the exact same signature.
+ * @param options - An object allowing further customization of the debouncer:
+ * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
+ *   `leading` would result in the function being invoked at the start of the
+ *   cool-down period; `trailing` would result in the function being invoked at
+ *   the end of the cool-down period (using the args from the last call to the
+ *   debouncer). When `both` is selected the `trailing` invocation would only
+ *   take place if there were more than one call to the debouncer during the
+ *   cool-down period. **DEFAULT: 'trailing'**
+ * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
+ *   debouncer would wait until this amount of time has passed without **any**
+ *   additional calls to the debouncer before triggering the end-of-cool-down-
+ *   period event. When this happens, the function would be invoked (if `timing`
+ *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
+ * - `maxWaitMs?: number`. The length of time since a debounced call (a call
+ *   that the debouncer prevented from being invoked) was made until it would be
+ *   invoked. Because the debouncer can be continually triggered and thus never
+ *   reach the end of the cool-down period, this allows the function to still
+ *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
+ *   `'leading'`.
+ * @returns A debouncer object. The main function is `call`. In addition to it
+ * the debouncer comes with the following additional functions and properties:
+ * - `cancel` method to cancel delayed `func` invocations
+ * - `flush` method to end the cool-down period immediately.
+ * - `cachedValue` the latest return value of an invocation (if one occurred).
+ * - `isPending` flag to check if there is an inflight cool-down window.
+ * @signature
+ *   P.debounce(func, options);
+ * @example
+ *   const debouncer = debounce(identity(), { timing: 'trailing', waitMs: 1000 });
+ *   const result1 = debouncer.call(1); // => undefined
+ *   const result2 = debouncer.call(2); // => undefined
+ *   // after 1 second
+ *   const result3 = debouncer.call(3); // => 2
+ *   // after 1 second
+ *   debouncer.cachedValue; // => 3
+ * @dataFirst
+ * @category Function
+ * @see https://css-tricks.com/debouncing-throttling-explained-examples/
+ */
+declare function debounce<F extends StrictFunction>(func: F, options: DebounceOptions & {
+  readonly timing?: 'trailing';
+}): Debouncer<F>;
+declare function debounce<F extends StrictFunction>(func: F, options: (DebounceOptions & {
+  readonly timing: 'both';
+}) | (Omit<DebounceOptions, 'maxWaitMs'> & {
+  readonly timing: 'leading';
+})): Debouncer<F, false>;
+//#endregion
+export { debounce };
+//# sourceMappingURL=debounce.d.ts.map

package/dist/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","names":[],"sources":["../src/debounce.ts"],"sourcesContent":[],"mappings":";;;KAOK,oBAAoB;;AAF8C;;;;;;;;;EAsCpC,SAAA,IAAA,EAAA,CAAA,GAAA,IAAA,EAxBtB,UAwBsB,CAxBX,CAwBW,CAAA,EAAA,GAvB5B,UAuB4B,CAvBjB,CAuBiB,CAAA,GAAA,CAAA,IAAA,SAvBE,UAuBF,GAAA,SAAA,GAAA,KAAA,CAAA;EAAX;;AAAU;AAwDlC;EAAmC,SAAA,MAAA,EAAA,GAAA,GAAA,IAAA;EAC3B;;;;EAEI,SAAA,KAAA,EAAA,GAAA,GAtEY,UAsEZ,CAtEuB,CAsEvB,CAAA,GAAA,SAAA;EACI;;;;EAIJ,SAAA,SAAA,EAAA,OAAA;EAAL;;;EACK,SAAA,WAAA,EAjEY,UAiEZ,CAjEuB,CAiEvB,CAAA,GAAA,SAAA;;KA9DP,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDW,mBAAmB,sBAC3B,YACG;;IACR,UAAU;iBACG,mBAAmB,sBAC3B,aAED;;MACA,KAAK;;KACT,UAAU"}

package/dist/debounce.js

@@ -1 +1,2 @@
-import{debounce as e}from"./debounce-C9xIAomT.js";export{e as debounce};
+function e(e,{waitMs:t,timing:n=`trailing`,maxWaitMs:r}){if(r!==void 0&&t!==void 0&&r<t)throw Error(`debounce: maxWaitMs (${r}) cannot be less than waitMs (${t})`);let i,a,o,s;function c(){if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}if(o===void 0)throw Error(`PERKAKAS[debounce]: latestCallArgs was unexpectedly undefined.`);let t=o;o=void 0,s=e(...t)}function l(){if(i===void 0)return;let e=i;i=void 0,clearTimeout(e),o!==void 0&&c()}function u(e){o=e,r!==void 0&&a===void 0&&(a=setTimeout(c,r))}return{call:(...a)=>{if(i===void 0)n===`trailing`?u(a):s=e(...a);else{n!==`leading`&&u(a);let e=i;i=void 0,clearTimeout(e)}return i=setTimeout(l,t??r??0),s},cancel:()=>{if(i!==void 0){let e=i;i=void 0,clearTimeout(e)}if(a!==void 0){let e=a;a=void 0,clearTimeout(e)}o=void 0},flush:()=>(l(),s),get isPending(){return i!==void 0},get cachedValue(){return s}}}export{e as debounce};
+//# sourceMappingURL=debounce.js.map

package/dist/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.js","names":["coolDownTimeoutId: ReturnType<typeof setTimeout> | undefined","maxWaitTimeoutId: ReturnType<typeof setTimeout> | undefined","latestCallArgs: Parameters<F> | undefined","result: ReturnType<F> | undefined"],"sources":["../src/debounce.ts"],"sourcesContent":["/* eslint-disable ts/consistent-type-definitions --\n * Function inference doesn't work when `unknown` is used as the parameters\n * generic type, it **has** to be `any`.\n */\n\nimport type { StrictFunction } from './internal/types/strict-function';\n\ntype Debouncer<F extends StrictFunction, IsNullable extends boolean = true> = {\n  /**\n   * Invoke the debounced function.\n   *\n   * @param args - Same as the args for the debounced function.\n   * @returns The last computed value of the debounced function with the\n   * latest args provided to it. If `timing` does not include `leading` then the\n   * the function would return `undefined` until the first cool-down period is\n   * over, otherwise the function would always return the return type of the\n   * debounced function.\n   */\n  readonly call: (\n    ...args: Parameters<F>\n  ) => ReturnType<F> | (true extends IsNullable ? undefined : never);\n\n  /**\n   * Cancels any debounced functions without calling them, effectively resetting\n   * the debouncer to the same state it is when initially created.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Similar to `cancel`, but would also trigger the `trailing` invocation if\n   * the debouncer would run one at the end of the cool-down period.\n   */\n  readonly flush: () => ReturnType<F> | undefined;\n\n  /**\n   * Is `true` when there is an active cool-down period currently debouncing\n   * invocations.\n   */\n  readonly isPending: boolean;\n\n  /**\n   * The last computed value of the debounced function.\n   */\n  readonly cachedValue: ReturnType<F> | undefined;\n};\n\ntype DebounceOptions = {\n  readonly waitMs?: number;\n  readonly maxWaitMs?: number;\n};\n\n/**\n * Wraps `func` with a debouncer object that \"debounces\" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).\n * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).\n * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).\n * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.\n * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.\n *\n * @param func - The function to debounce, the returned `call` function will have\n * the exact same signature.\n * @param options - An object allowing further customization of the debouncer:\n * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.\n *   `leading` would result in the function being invoked at the start of the\n *   cool-down period; `trailing` would result in the function being invoked at\n *   the end of the cool-down period (using the args from the last call to the\n *   debouncer). When `both` is selected the `trailing` invocation would only\n *   take place if there were more than one call to the debouncer during the\n *   cool-down period. **DEFAULT: 'trailing'**\n * - `waitMs?: number`. The length of the cool-down period in milliseconds. The\n *   debouncer would wait until this amount of time has passed without **any**\n *   additional calls to the debouncer before triggering the end-of-cool-down-\n *   period event. When this happens, the function would be invoked (if `timing`\n *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**\n * - `maxWaitMs?: number`. The length of time since a debounced call (a call\n *   that the debouncer prevented from being invoked) was made until it would be\n *   invoked. Because the debouncer can be continually triggered and thus never\n *   reach the end of the cool-down period, this allows the function to still\n *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is\n *   `'leading'`.\n * @returns A debouncer object. The main function is `call`. In addition to it\n * the debouncer comes with the following additional functions and properties:\n * - `cancel` method to cancel delayed `func` invocations\n * - `flush` method to end the cool-down period immediately.\n * - `cachedValue` the latest return value of an invocation (if one occurred).\n * - `isPending` flag to check if there is an inflight cool-down window.\n * @signature\n *   P.debounce(func, options);\n * @example\n *   const debouncer = debounce(identity(), { timing: 'trailing', waitMs: 1000 });\n *   const result1 = debouncer.call(1); // => undefined\n *   const result2 = debouncer.call(2); // => undefined\n *   // after 1 second\n *   const result3 = debouncer.call(3); // => 2\n *   // after 1 second\n *   debouncer.cachedValue; // => 3\n * @dataFirst\n * @category Function\n * @see https://css-tricks.com/debouncing-throttling-explained-examples/\n */\nexport function debounce<F extends StrictFunction>(\n  func: F,\n  options: DebounceOptions & { readonly timing?: 'trailing' },\n): Debouncer<F>;\nexport function debounce<F extends StrictFunction>(\n  func: F,\n  options:\n    | (DebounceOptions & { readonly timing: 'both' })\n    | (Omit<DebounceOptions, 'maxWaitMs'> & { readonly timing: 'leading' }),\n): Debouncer<F, false>;\n\nexport function debounce<F extends StrictFunction>(\n  func: F,\n\n  {\n    waitMs,\n    timing = 'trailing',\n    maxWaitMs,\n  }: DebounceOptions & {\n    readonly timing?: 'both' | 'leading' | 'trailing';\n  },\n): Debouncer<F> {\n  if (maxWaitMs !== undefined && waitMs !== undefined && maxWaitMs < waitMs) {\n    throw new Error(\n      `debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`,\n    );\n  }\n\n  // All these are part of the debouncer runtime state:\n\n  // The timeout is the main object we use to tell if there's an active cool-\n  // down period or not.\n  let coolDownTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // We use an additional timeout to track how long the last debounced call is\n  // waiting.\n  let maxWaitTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // For 'trailing' invocations we need to keep the args around until we\n  // actually invoke the function.\n  let latestCallArgs: Parameters<F> | undefined;\n\n  // To make any value of the debounced function we need to be able to return a\n  // value. For any invocation except the first one when 'leading' is enabled we\n  // will return this cached value.\n  let result: ReturnType<F> | undefined;\n\n  function handleInvoke(): void {\n    if (maxWaitTimeoutId !== undefined) {\n      // We are invoking the function so the wait is over...\n      const timeoutId = maxWaitTimeoutId;\n      maxWaitTimeoutId = undefined;\n      clearTimeout(timeoutId);\n    }\n\n    /* v8 ignore next 7 -- This protects us against changes to the logic, there is no known flow we can simulate to reach this condition. It can only happen if a previous timeout isn't cleared (or faces a race condition clearing). */\n    if (latestCallArgs === undefined) {\n      throw new Error(\n        'PERKAKAS[debounce]: latestCallArgs was unexpectedly undefined.',\n      );\n    }\n\n    const args = latestCallArgs;\n    // Make sure the args aren't accidentally used again, this is mainly\n    // relevant for the check above where we'll fail a subsequent call to\n    // 'trailingEdge'.\n    latestCallArgs = undefined;\n\n    // Invoke the function and store the results locally.\n    // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n    // types too eagerly, making itself blind to the fact that the types match\n    // here.\n    result = func(...args);\n  };\n\n  function handleCoolDownEnd(): void {\n    if (coolDownTimeoutId === undefined) {\n      // It's rare to get here, it should only happen when `flush` is called\n      // when the cool-down window isn't active.\n      return;\n    }\n\n    // Make sure there are no more timers running.\n    const timeoutId = coolDownTimeoutId;\n    coolDownTimeoutId = undefined;\n    clearTimeout(timeoutId);\n    // Then reset state so a new cool-down window can begin on the next call.\n\n    if (latestCallArgs !== undefined) {\n      // If we have a debounced call waiting to be invoked at the end of the\n      // cool-down period we need to invoke it now.\n      handleInvoke();\n    }\n  };\n\n  function handleDebouncedCall(args: Parameters<F>): void {\n    // We save the latest call args so that (if and) when we invoke the function\n    // in the future, we have args to invoke it with.\n    latestCallArgs = args;\n\n    if (maxWaitMs !== undefined && maxWaitTimeoutId === undefined) {\n      // We only need to start the maxWait timeout once, on the first debounced\n      // call that is now being delayed.\n      maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);\n    }\n  };\n\n  return {\n    call: (...args) => {\n      if (coolDownTimeoutId === undefined) {\n        // This call is starting a new cool-down window!\n\n        if (timing === 'trailing') {\n          // Only when the timing is \"trailing\" is the first call \"debounced\".\n          handleDebouncedCall(args);\n        } else {\n          // Otherwise for \"leading\" and \"both\" the first call is actually\n          // called directly and not via a timeout.\n          // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n          // types too eagerly, making itself blind to the fact that the types match\n          // here.\n          result = func(...args);\n        }\n      } else {\n        // There's an inflight cool-down window.\n\n        if (timing !== 'leading') {\n          // When the timing is 'leading' all following calls are just ignored\n          // until the cool-down period ends. But for the other timings the call\n          // is \"debounced\".\n          handleDebouncedCall(args);\n        }\n\n        // The current timeout is no longer relevant because we need to wait the\n        // full `waitMs` time from this call.\n        const timeoutId = coolDownTimeoutId;\n        coolDownTimeoutId = undefined;\n        clearTimeout(timeoutId);\n      }\n\n      coolDownTimeoutId = setTimeout(\n        handleCoolDownEnd,\n        // If waitMs is not defined but maxWaitMs *is* it means the user is only\n        // interested in the leaky-bucket nature of the debouncer which is\n        // achieved by setting waitMs === maxWaitMs. If both are not defined we\n        // default to 0 which would wait until the end of the execution frame.\n        waitMs ?? maxWaitMs ?? 0,\n      );\n\n      // Return the last computed result while we \"debounce\" further calls.\n      return result;\n    },\n\n    cancel: () => {\n      // Reset all \"in-flight\" state of the debouncer. Notice that we keep the\n      // cached value!\n\n      if (coolDownTimeoutId !== undefined) {\n        const timeoutId = coolDownTimeoutId;\n        coolDownTimeoutId = undefined;\n        clearTimeout(timeoutId);\n      }\n\n      if (maxWaitTimeoutId !== undefined) {\n        const timeoutId = maxWaitTimeoutId;\n        maxWaitTimeoutId = undefined;\n        clearTimeout(timeoutId);\n      }\n\n      latestCallArgs = undefined;\n    },\n\n    flush: () => {\n      // Flush is just a manual way to trigger the end of the cool-down window.\n      handleCoolDownEnd();\n      return result;\n    },\n\n    get isPending() {\n      return coolDownTimeoutId !== undefined;\n    },\n\n    get cachedValue() {\n      return result;\n    },\n  };\n}\n"],"mappings":"AA8GA,SAAgB,EACd,EAEA,CACE,SACA,SAAS,WACT,aAIY,CACd,GAAI,IAAc,IAAA,IAAa,IAAW,IAAA,IAAa,EAAY,EACjE,MAAU,MACR,wBAAwB,EAAU,gCAAgC,EAAO,GAC1E,CAOH,IAAIA,EAIAC,EAIAC,EAKAC,EAEJ,SAAS,GAAqB,CAC5B,GAAI,IAAqB,IAAA,GAAW,CAElC,IAAM,EAAY,EAClB,EAAmB,IAAA,GACnB,aAAa,EAAU,CAIzB,GAAI,IAAmB,IAAA,GACrB,MAAU,MACR,iEACD,CAGH,IAAM,EAAO,EAIb,EAAiB,IAAA,GAMjB,EAAS,EAAK,GAAG,EAAK,CAGxB,SAAS,GAA0B,CACjC,GAAI,IAAsB,IAAA,GAGxB,OAIF,IAAM,EAAY,EAClB,EAAoB,IAAA,GACpB,aAAa,EAAU,CAGnB,IAAmB,IAAA,IAGrB,GAAc,CAIlB,SAAS,EAAoB,EAA2B,CAGtD,EAAiB,EAEb,IAAc,IAAA,IAAa,IAAqB,IAAA,KAGlD,EAAmB,WAAW,EAAc,EAAU,EAI1D,MAAO,CACL,MAAO,GAAG,IAAS,CACjB,GAAI,IAAsB,IAAA,GAGpB,IAAW,WAEb,EAAoB,EAAK,CAOzB,EAAS,EAAK,GAAG,EAAK,KAEnB,CAGD,IAAW,WAIb,EAAoB,EAAK,CAK3B,IAAM,EAAY,EAClB,EAAoB,IAAA,GACpB,aAAa,EAAU,CAazB,MAVA,GAAoB,WAClB,EAKA,GAAU,GAAa,EACxB,CAGM,GAGT,WAAc,CAIZ,GAAI,IAAsB,IAAA,GAAW,CACnC,IAAM,EAAY,EAClB,EAAoB,IAAA,GACpB,aAAa,EAAU,CAGzB,GAAI,IAAqB,IAAA,GAAW,CAClC,IAAM,EAAY,EAClB,EAAmB,IAAA,GACnB,aAAa,EAAU,CAGzB,EAAiB,IAAA,IAGnB,WAEE,GAAmB,CACZ,GAGT,IAAI,WAAY,CACd,OAAO,IAAsB,IAAA,IAG/B,IAAI,aAAc,CAChB,OAAO,GAEV"}

package/dist/deduped-DdwAYzXs.d.cts

@@ -0,0 +1,23 @@
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
+
+//#region src/internal/types/deduped.d.ts
+
+/**
+ * The result of running a function that would dedupe an array (`unique`,
+ * `uniqueBy`, and `uniqueWith`).
+ *
+ * There are certain traits of the output which are unique to a deduped array
+ * that allow us to create a better type; see comments inline.
+ *
+ * !Note: We can build better types for each of the unique functions
+ * _separately_ by taking advantage of _other_ characteristics that are unique
+ * to each one (e.g. in `unique` we know that each item that has a disjoint type
+ * to all previous items would be part of the output, even when it isn't the
+ * first), but to make this utility the most useful we kept it simple and
+ * generic for now.
+ */
+type Deduped<T extends IterableContainer> = T extends readonly [] ? [] : T extends readonly [infer Head, ...infer Rest] ? [Head, ...Array<Rest[number]>] : T extends readonly [...Array<unknown>, unknown] ? NonEmptyArray<T[number]> : Array<T[number]>;
+//#endregion
+export { Deduped as t };
+//# sourceMappingURL=deduped-DdwAYzXs.d.cts.map

package/dist/deduped-DdwAYzXs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduped-DdwAYzXs.d.cts","names":[],"sources":["../src/internal/types/deduped.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;;;;;;AAUQ,KAVI,OAUJ,CAAA,UAVsB,iBAUtB,CAAA,GAV2C,CAU3C,SAAA,SAAA,EAAA,GAAA,EAAA,GARJ,CAQI,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAAA,CALD,IAKM,KALG,MAAM,iBAChB,uBAAuB,2BAGvB,cAAc,aACZ,MAAM"}