@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/from-entries.d.ts

@@ -1,4 +1,68 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./perkakas-type-error-2yBU0Drj.js";
-import { fromEntries } from "./from-entries-DRBY1dKq.js";
-export { fromEntries };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as PerkakasTypeError } from "./perkakas-type-error-B9ULNhW0.js";
+import { Simplify } from "type-fest";
+
+//#region src/from-entries.d.ts
+type FromEntriesError<Message extends string> = PerkakasTypeError<'fromEntries', Message>;
+type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [key: Key, value: Value];
+type FromEntries<Entries> = Entries extends readonly [infer First, ...infer Tail] ? FromEntriesTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromEntriesTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromEntriesArray<Entries> : FromEntriesError<'Entries array-like could not be inferred'>;
+type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[0], E[1]> : FromEntriesError<'Array-like contains a non-entry element'>;
+type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
+type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = { [P in AllKeys<Entries>]?: ValueForKey<Entries, P> };
+type AllKeys<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
+type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.
+ * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.
+ * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.
+ * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param entries - An array of key-value pairs.
+ * @signature
+ *   P.fromEntries(tuples)
+ * @example
+ *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}
+ * @dataFirst
+ * @category Object
+ */
+declare function fromEntries<Entries extends IterableContainer<Entry>>(entries: Entries): Simplify<FromEntries<Entries>>;
+/**
+ * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
+ * If a tuple is not supplied for any element in the array, the element will be ignored
+ * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
+ *
+ * The strict option supports more sophisticated use-cases like those that would
+ * result when calling the strict `toPairs` function.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @signature
+ *   P.fromEntries()(tuples)
+ * @example
+ *   P.pipe(
+ *     [['a', 'b'], ['c', 'd']] as const,
+ *     P.fromEntries(),
+ *   ); // => {a: 'b', c: 'd'}
+ * @dataLast
+ * @category Object
+ */
+declare function fromEntries(): <Entries extends IterableContainer<Entry>>(entries: Entries) => Simplify<FromEntries<Entries>>;
+//#endregion
+export { fromEntries };
+//# sourceMappingURL=from-entries.d.ts.map

package/dist/from-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-entries.d.ts","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,2CAA2C,iCAE9C;KAGG,kBAAkB,cAAc,0CALhC,GAAA,EAME,GANF,EAKA,KAAA,EAEI,KAFC,CAAa;KAYlB,WAZgC,CAAA,OAAA,CAAA,GAYT,OAZS,SAAA,SAAA,CAC9B,KAAA,MAAA,EACE,GAAA,KAAA,KAAA,CAAK,GAcV,gBAdU,CAcO,KAdP,EAcc,IAdd,CAAA,GAeV,OAfU,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GAgBR,gBAhBQ,CAgBS,IAhBT,EAgBe,IAhBf,CAAA,GAiBR,OAjBQ,SAiBQ,iBAjBR,CAiB0B,KAjB1B,CAAA,GAkBN,gBAlBM,CAkBW,OAlBX,CAAA,GAmBN,gBAnBM,CAAA,0CAAA,CAAA;AAAA,KAwBT,gBAdW,CAAA,CAAA,EAAA,IAAA,CAAA,GAciB,CAdjB,SAc2B,KAd3B,GAeZ,WAfY,CAeA,IAfA,CAAA,GAeQ,MAfR,CAee,CAff,CAAA,CAAA,CAAA,EAeqB,CAfrB,CAAA,CAAA,CAAA,CAAA,GAgBZ,gBAhBY,CAAA,yCAAA,CAAA;KA4BX,gBA5BuB,CAAA,gBA4BU,iBA5BV,CA4B4B,KA5B5B,CAAA,CAAA,GAAA,MAAA,SA6BT,OA7BS,CA6BD,OA7BC,CAAA,GA8BtB,MA9BsB,CAAA,MAAA,EA8BP,OA9BO,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA+BP,OA/BO,CA+BC,OA/BD,CAAA,GAgCpB,MAhCoB,CAAA,MAAA,EAgCL,OAhCK,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SAiCL,OAjCK,CAiCG,OAjCH,CAAA,GAkClB,MAlCkB,CAAA,MAAA,EAkCH,OAlCG,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAmClB,+BAnCkB,CAmCc,OAnCd,CAAA;KA0CvB,+BAtCgB,CAAA,gBAsCgC,iBAtChC,CAsCkD,KAtClD,CAAA,CAAA,GAAA,QAwCX,OAxCkB,CAwCV,OAxCU,CAAA,IAwCE,WAxCF,CAwCc,OAxCd,EAwCuB,CAxCvB,CAAA,EAAxB;KA2CC,OA1CD,CAAA,gBA0CyB,iBA1CzB,CA0C2C,KA1C3C,CAAA,CAAA,GA0CqD,OA1CrD,CA2CF,OA3CE,CAAA,MAAA,CAAA,EA4CF,KA5CE,CAAA,CAAA,CAAA,CAAA;KAqDC,WApDkB,CAAA,gBAqDL,iBArDK,CAqDa,KArDb,CAAA,EAAA,UAsDX,WAtDW,CAAA,GAAA,CAuDlB,OAvDkB,CAuDV,OAvDU,CAAA,MAAA,CAAA,EAuDO,KAvDP,CAuDa,CAvDb,CAAA,CAAA,SAAA,KAAA,GAwDnB,OAxDmB,CAAA,MAAA,CAAA,GAyDnB,OAzDmB,CAyDX,OAzDW,CAAA,MAAA,CAAA,EAyDM,KAzDN,CAyDY,CAzDZ,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;AAGC;;;;;;;;;;AAOJ;;;;;AAcC,iBA2DL,WA3DK,CAAA,gBA2DuB,iBA3DvB,CA2DyC,KA3DzC,CAAA,CAAA,CAAA,OAAA,EA4DV,OA5DU,CAAA,EA6DlB,QA7DkB,CA6DT,WA7DS,CA6DG,OA7DH,CAAA,CAAA;;;;;;;;;;;;;AAKoB;;;;;;;;;AASA;;;;;AAGgB,iBAwEzC,WAAA,CAAA,CAxEyC,EAAA,CAAA,gBAwET,iBAxES,CAwES,KAxET,CAAA,CAAA,CAAA,OAAA,EAyE9C,OAzE8C,EAAA,GA0EpD,QA1EoD,CA0E3C,WA1E2C,CA0E/B,OA1E+B,CAAA,CAAA"}

package/dist/from-entries.js

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

package/dist/from-entries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-entries.js","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\n\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype FromEntriesError<Message extends string> = PerkakasTypeError<\n  'fromEntries',\n  Message\n>;\n\ntype Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [\n  key: Key,\n  value: Value,\n];\n\n// The 2 kinds of arrays we accept result in different kinds of outputs:\n// 1. If the input is a *tuple*, we know exactly what entries it would hold,\n// and thus can type the result so that the keys are required. We will then run\n// recursively on the rest of the tuple.\n// 2. If the input is an *array* then any keys defined in the array might not\n// actually show up in runtime, and thus need to be optional. (e.g. if the input\n// is an empty array).\ntype FromEntries<Entries> = Entries extends readonly [\n  infer First,\n  ...infer Tail,\n]\n  ? FromEntriesTuple<First, Tail>\n  : Entries extends readonly [...infer Head, infer Last]\n    ? FromEntriesTuple<Last, Head>\n    : Entries extends IterableContainer<Entry>\n      ? FromEntriesArray<Entries>\n      : FromEntriesError<'Entries array-like could not be inferred'>;\n\n// For strict tuples we build the result by intersecting each entry as a record\n// between it's key and value, recursively. The recursion goes through our main\n// type so that we support tuples which also contain rest parts.\ntype FromEntriesTuple<E, Rest> = E extends Entry\n  ? FromEntries<Rest> & Record<E[0], E[1]>\n  : FromEntriesError<'Array-like contains a non-entry element'>;\n\n// For the array case we also need to handle what kind of keys it defines:\n// 1. If it defines a *broad* key (one that has an infinite set of values, like\n// number or string) then the result is a simple record.\n// 2. If the keys are *literals* then we need to make the record partial\n// (because those props are explicit), and we need to match each key it's\n// specific possible value, as defined by the entries.\n//\n// Note that this destination between keys is the result of how typescript\n// considers Record<string, unknown> to be **implicitly** partial, whereas\n// Record<\"a\", unknown> is not.\ntype FromEntriesArray<Entries extends IterableContainer<Entry>>\n  = string extends AllKeys<Entries>\n    ? Record<string, Entries[number][1]>\n    : number extends AllKeys<Entries>\n      ? Record<number, Entries[number][1]>\n      : symbol extends AllKeys<Entries>\n        ? Record<symbol, Entries[number][1]>\n        : FromEntriesArrayWithLiteralKeys<Entries>;\n\n// This type is largely copied from `objectFromEntries` in the repo:\n// *sindresorhus/ts-extras* but makes all properties of the output optional,\n// which is more correct because we can't assure that an entry will exist for\n// every possible prop/key of the input.\n// @see https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-from-entries.ts)\ntype FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>>\n  = {\n    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;\n  };\n\ntype AllKeys<Entries extends IterableContainer<Entry>> = Extract<\n  Entries[number],\n  Entry\n>[0];\n\n// I tried and failed to simplify the type here! What the ternary does here is\n// to support the cases where the entries are defined by a single type that\n// defines all entries, but it defines the keys as a union of literals\n// (`['a' | 'b', number]`); which is different from the output of toPairs\n// which would define a separate tuple literal for each key (`['a', number] |\n// ['b', number]`). We need to support both cases!\ntype ValueForKey<\n  Entries extends IterableContainer<Entry>,\n  K extends PropertyKey,\n> = (Extract<Entries[number], Entry<K>> extends never\n  ? Entries[number]\n  : Extract<Entries[number], Entry<K>>)[1];\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.\n * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.\n * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.\n * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   P.fromEntries(tuples)\n * @example\n *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}\n * @dataFirst\n * @category Object\n */\nexport function fromEntries<Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n): Simplify<FromEntries<Entries>>;\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @signature\n *   P.fromEntries()(tuples)\n * @example\n *   P.pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     P.fromEntries(),\n *   ); // => {a: 'b', c: 'd'}\n * @dataLast\n * @category Object\n */\nexport function fromEntries(): <Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n) => Simplify<FromEntries<Entries>>;\n\nexport function fromEntries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.fromEntries, args);\n}\n"],"mappings":"wCAmJA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,OAAO,YAAa,EAAK"}

package/dist/from-keys.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./from-keys-CI2PJlIM.cjs`);exports.fromKeys=e.fromKeys;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}exports.fromKeys=t;

package/dist/from-keys.d.cts

@@ -1,5 +1,60 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./is-bounded-record-kpsb1wQA.cjs";
-import "./bounded-partial-A89bt7Kj.cjs";
-import { fromKeys } from "./from-keys-Ds1mndVk.cjs";
-export { fromKeys };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as BoundedPartial } from "./bounded-partial-CtOsGqxa.cjs";
+import { Simplify } from "type-fest";
+
+//#region src/from-keys.d.ts
+type ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? BoundedPartial<Record<T[number], V>> : never;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param data - An array of keys of the output object. All items in the array
+ * would be keys in the output array.
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(data, mapper);
+ * @example
+ *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataFirst
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number], index: number, data: T) => V): Simplify<FromKeys<T, V>>;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(mapper)(data);
+ * @example
+ *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataLast
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number], index: number, data: T) => V): (data: T) => Simplify<FromKeys<T, V>>;
+//#endregion
+export { fromKeys };
+//# sourceMappingURL=from-keys.d.cts.map

package/dist/from-keys.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-keys.d.cts","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":[],"mappings":";;;;;KAUK,sBAAsB,UAAU,sBAAsB,IAAI,GANc,GAMxE,KAAA;KAEA,QAFsB,CAAA,UAEH,iBAFG,EAAA,CAAA,CAAA,GAEqB,CAFrB,SAAA,SAAA,EAAA,GAAA,CAAA,CAAA,GAKvB,CALuB,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAMrB,aANqB,CAMP,IANO,EAMD,CANC,CAAA,GAMI,QANJ,CAMa,IANb,EAMmB,CANnB,CAAA,GAOrB,CAPqB,CAAA,MAAA,CAAA,SAOH,WAPG,GAQnB,cARmB,CAQJ,MARI,CAQG,CARH,CAAA,MAAA,CAAA,EAQc,CARd,CAAA,CAAA,GAAA,KAAA;;;;;AAAqC;;;;;;;;;;;;;;;;;AAoChE;;;;AAEiB,iBAFD,QAEC,CAAA,UAFkB,iBAElB,CAFoC,WAEpC,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EADT,CACS,EAAA,MAAA,EAAA,CAAA,IAAA,EAAA,CAAA,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAgC,CAAhC,EAAA,GAAsC,CAAtC,CAAA,EACd,QADc,CACL,QADK,CACI,CADJ,EACO,CADP,CAAA,CAAA;;;;;;;;AA0BjB;;;;;;;;;;;;;;;;iBAAgB,mBAAmB,kBAAkB,gCACpC,gCAAgC,MAAM,WAC7C,MAAM,SAAS,SAAS,GAAG"}

package/dist/from-keys.d.ts

@@ -1,5 +1,60 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./is-bounded-record-DEQ2a3_Y.js";
-import "./bounded-partial-DfemQln9.js";
-import { fromKeys } from "./from-keys-DsvEWPvE.js";
-export { fromKeys };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as BoundedPartial } from "./bounded-partial-CPc1XU57.js";
+import { Simplify } from "type-fest";
+
+//#region src/from-keys.d.ts
+type ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;
+type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? BoundedPartial<Record<T[number], V>> : never;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param data - An array of keys of the output object. All items in the array
+ * would be keys in the output array.
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(data, mapper);
+ * @example
+ *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataFirst
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number], index: number, data: T) => V): Simplify<FromKeys<T, V>>;
+/**
+ * Creates an object that maps each key in `data` to the result of `mapper` for
+ * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
+ * for each item in `data`.
+ *
+ * There are several other functions that could be used to build an object from
+ * an array:
+ * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
+ * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
+ * `fromEntries` - Builds an object from an array of key-value pairs.
+ * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
+ * Refer to the docs for more details.
+ *
+ * @param mapper - Takes a key and returns the value that would be associated
+ * with that key.
+ * @signature
+ *   P.fromKeys(mapper)(data);
+ * @example
+ *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
+ *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
+ * @dataLast
+ * @category Object
+ */
+declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number], index: number, data: T) => V): (data: T) => Simplify<FromKeys<T, V>>;
+//#endregion
+export { fromKeys };
+//# sourceMappingURL=from-keys.d.ts.map

package/dist/from-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-keys.d.ts","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":[],"mappings":";;;;;KAUK,sBAAsB,UAAU,sBAAsB,IAAI,GANc,GAMxE,KAAA;KAEA,QAFsB,CAAA,UAEH,iBAFG,EAAA,CAAA,CAAA,GAEqB,CAFrB,SAAA,SAAA,EAAA,GAAA,CAAA,CAAA,GAKvB,CALuB,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAMrB,aANqB,CAMP,IANO,EAMD,CANC,CAAA,GAMI,QANJ,CAMa,IANb,EAMmB,CANnB,CAAA,GAOrB,CAPqB,CAAA,MAAA,CAAA,SAOH,WAPG,GAQnB,cARmB,CAQJ,MARI,CAQG,CARH,CAAA,MAAA,CAAA,EAQc,CARd,CAAA,CAAA,GAAA,KAAA;;;;;AAAqC;;;;;;;;;;;;;;;;;AAoChE;;;;AAEiB,iBAFD,QAEC,CAAA,UAFkB,iBAElB,CAFoC,WAEpC,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EADT,CACS,EAAA,MAAA,EAAA,CAAA,IAAA,EAAA,CAAA,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAgC,CAAhC,EAAA,GAAsC,CAAtC,CAAA,EACd,QADc,CACL,QADK,CACI,CADJ,EACO,CADP,CAAA,CAAA;;;;;;;;AA0BjB;;;;;;;;;;;;;;;;iBAAgB,mBAAmB,kBAAkB,gCACpC,gCAAgC,MAAM,WAC7C,MAAM,SAAS,SAAS,GAAG"}

package/dist/from-keys.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{fromKeys as e}from"./from-keys-DJe8xU7b.js";export{e as fromKeys};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}export{t as fromKeys};
+//# sourceMappingURL=from-keys.js.map

package/dist/from-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-keys.js","names":["result: Partial<FromKeys<T, V>>"],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { BoundedPartial } from './internal/types/bounded-partial';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n// Takes a union of literals and creates a union of records with the value V for\n// each key **separately**\n// @example ExactlyOneKey<\"cat\" | \"dog\", boolean> // { cat: boolean } | { dog: boolean }\ntype ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;\n\ntype FromKeys<T extends IterableContainer, V> = T extends readonly []\n  // eslint-disable-next-line ts/no-empty-object-type -- We want to return an empty object type here, but it's not trivial to build that in Typescript, other fixer suggestions like Record<PropertyKey, never> or Record<PropertyKey, unknown> both break our type tests so they don't do what we need here. Because the result is mutable this might be the correct type after all...\n  ? {}\n  : T extends readonly [infer Head, ...infer Rest]\n    ? ExactlyOneKey<Head, V> & FromKeys<Rest, V>\n    : T[number] extends PropertyKey\n      ? BoundedPartial<Record<T[number], V>>\n      : never;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - An array of keys of the output object. All items in the array\n * would be keys in the output array.\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   P.fromKeys(data, mapper);\n * @example\n *   P.fromKeys([\"cat\", \"dog\"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataFirst\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): Simplify<FromKeys<T, V>>;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   P.fromKeys(mapper)(data);\n * @example\n *   P.pipe([\"cat\", \"dog\"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataLast\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  mapper: (item: T[number], index: number, data: T) => V,\n): (data: T) => Simplify<FromKeys<T, V>>;\n\nexport function fromKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(fromKeysImplementation, args);\n}\n\nfunction fromKeysImplementation<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): FromKeys<T, V> {\n  const result: Partial<FromKeys<T, V>> = {};\n\n  for (const [index, key] of data.entries()) {\n    // @ts-expect-error [ts7053] - There's no easy way to make Typescript aware that the items in T would be keys in the output object because it's type is built recursively and the \"being an item of an array\" property of a type is not \"carried over\" in the recursive type definition.\n    result[key] = mapper(key, index, data);\n  }\n\n  return result as FromKeys<T, V>;\n}\n"],"mappings":"wCA8EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAMA,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}

package/dist/funnel.cjs

@@ -1 +1 @@
-const e=require(`./funnel-CL-QFpGk.cjs`);exports.funnel=e.funnel;
+const e=Symbol(`funnel/voidReducer`),t=()=>e;function n(n,{triggerAt:r=`end`,minQuietPeriodMs:i,maxBurstDurationMs:a,minGapMs:o,reducer:s=t}){let c,l,u,d;function f(){let t=u;t!==void 0&&(u=void 0,t===e?n():n(t),o!==void 0&&(l=setTimeout(p,o)))}function p(){clearTimeout(l),l=void 0,c===void 0&&f()}function m(){clearTimeout(c),c=void 0,d=void 0,l===void 0&&f()}return{call:(...e)=>{let t=c===void 0&&l===void 0;if((r!==`start`||t)&&(u=s(u,...e)),!(c===void 0&&!t)){if(i!==void 0||a!==void 0||o===void 0){clearTimeout(c);let e=Date.now();d??=e;let t=a===void 0?i??0:Math.min(i??a,a-(e-d));c=setTimeout(m,t)}r!==`end`&&t&&f()}},cancel:()=>{clearTimeout(c),c=void 0,d=void 0,clearTimeout(l),l=void 0,u=void 0},flush:()=>{m(),p()},get isIdle(){return c===void 0&&l===void 0}}}exports.funnel=n;

package/dist/funnel.d.cts

@@ -1,2 +1,155 @@
-import { funnel } from "./funnel-DRrT4WPx.cjs";
-export { funnel };
+import { RequireAtLeastOne } from "type-fest";
+
+//#region src/funnel.d.ts
+type FunnelOptions<Args extends RestArguments, R> = {
+  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;
+} & FunnelTimingOptions;
+/**
+ * Not all combinations of timing options are valid, there are dependencies
+ * between them to ensure users can't configure the funnel in a way which would
+ * cause it to never trigger.
+ */
+type FunnelTimingOptions = ({
+  readonly triggerAt?: 'end';
+} & (({
+  readonly minGapMs: number;
+} & RequireAtLeastOne<{
+  readonly minQuietPeriodMs: number;
+  readonly maxBurstDurationMs: number;
+}>) | {
+  readonly minQuietPeriodMs?: number;
+  readonly maxBurstDurationMs?: number;
+  readonly minGapMs?: never;
+})) | {
+  readonly triggerAt: 'start' | 'both';
+  readonly minQuietPeriodMs?: number;
+  readonly maxBurstDurationMs?: number;
+  readonly minGapMs?: number;
+};
+type RestArguments = Array<any>;
+interface Funnel<Args extends RestArguments = []> {
+  /**
+   * Call the function. This might result in the `execute` function being called
+   * now or later, depending on it's configuration and it's current state.
+   *
+   * @param args - The args are defined by the `reducer` function.
+   */
+  readonly call: (...args: Args) => void;
+  /**
+   * Resets the funnel to it's initial state. Any calls made since the last
+   * invocation will be discarded.
+   */
+  readonly cancel: () => void;
+  /**
+   * Triggers an invocation regardless of the current state of the funnel.
+   * Like any other invocation, The funnel will also be reset to it's initial
+   * state afterwards.
+   */
+  readonly flush: () => void;
+  /**
+   * The funnel is in it's initial state (there are no active timeouts).
+   */
+  readonly isIdle: boolean;
+}
+/**
+ * Creates a funnel that controls the timing and execution of `callback`. Its
+ * main purpose is to manage multiple consecutive (usually fast-paced) calls,
+ * reshaping them according to a defined batching strategy and timing policy.
+ * This is useful when handling uncontrolled call rates, such as DOM events or
+ * network traffic. It can implement strategies like debouncing, throttling,
+ * batching, and more.
+ *
+ * An optional `reducer` function can be provided to allow passing data to the
+ * callback via calls to `call` (otherwise the signature of `call` takes no
+ * arguments).
+ *
+ * Typing is inferred from `callback`s param, and from the rest params that
+ * the optional `reducer` function accepts. Use **explicit** types for these
+ * to ensure that everything _else_ is well-typed.
+ *
+ * Notice that this function constructs a funnel **object**, and does **not**
+ * execute anything when called. The returned object should be used to execute
+ * the funnel via the its `call` method.
+ *
+ * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.
+ * - Throttling: use `minGapMs` and `triggerAt: "start"` or `"both"`.
+ * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).
+ *
+ * @param callback - The main function that would be invoked periodically based
+ * on `options`. The function would take the latest result of the `reducer`; if
+ * no calls where made since the last time it was invoked it will not be
+ * invoked. (If a return value is needed, it should be passed via a reference or
+ * via closure to the outer scope of the funnel).
+ * @param options - An object that defines when `execute` should be invoked,
+ * relative to the calls of `call`. An empty/missing options object is
+ * equivalent to setting `minQuietPeriodMs` to `0`.
+ * @param options.reducer - Combines the arguments passed to `call` with the
+ * value computed on the previous call (or `undefined` on the first time). The
+ * goal of the function is to extract and summarize the data needed for
+ * `callback`. It should be fast and simple as it is called often and should
+ * defer heavy operations to the `execute` function. If the final value
+ * is `undefined`, `callback` will not be called.
+ * @param options.triggerAt - At what "edges" of the funnel's burst window
+ * would `execute` invoke:
+ * - `start` - the function will be invoked immediately (within the  **same**
+ * execution frame!), and any subsequent calls would be ignored until the funnel
+ * is idle again. During this period `reducer` will also not be called.
+ * - `end` - the function will **not** be invoked initially but the timer will
+ * be started. Any calls during this time would be passed to the reducer, and
+ * when the timers are done, the reduced result would trigger an invocation.
+ * - `both` - the function will be invoked immediately, and then the funnel
+ * would behave as if it was in the 'end' state. @default 'end'.
+ * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls
+ * in short succession to cause excessive invocations (aka "debounce"). This
+ * duration represents the **minimum** amount of time that needs to pass
+ * between calls (the "quiet" part) in order for the subsequent call to **not**
+ * be considered part of the burst. In other words, as long as calls are faster
+ * than this, they are considered part of the burst and the burst is extended.
+ * @param options.maxBurstDurationMs - Bursts are extended every time a call is
+ * made within the burst period. This means that the burst period could be
+ * extended indefinitely. To prevent such cases, a maximum burst duration could
+ * be defined. When `minQuietPeriodMs` is not defined and this option is, they
+ * will both share the same value.
+ * @param options.minGapMs - A minimum duration between calls of `execute`.
+ * This is maintained regardless of the shape of the burst and is ensured even
+ * if the `maxBurstDurationMs` is reached before it. (aka "throttle").
+ * @returns A funnel with a `call` function that is used to trigger invocations.
+ * In addition to it the funnel also comes with the following functions and
+ * properties:
+ * - `cancel` - Resets the funnel to it's initial state, discarding the current
+ * `reducer` result without calling `execute` on it.
+ * - `flush` - Triggers an invocation even if there are active timeouts, and
+ * then resets the funnel to it's initial state.
+ * - `isIdle` - Checks if there are any active timeouts.
+ * @signature
+ *   P.funnel(callback, options);
+ * @example
+ *   const debouncer = P.funnel(
+ *     () => {
+ *       console.log("Callback executed!");
+ *     },
+ *     { minQuietPeriodMs: 100 },
+ *   );
+ *   debouncer.call();
+ *   debouncer.call();
+ *
+ *   const throttle = P.funnel(
+ *     () => {
+ *       console.log("Callback executed!");
+ *     },
+ *     { minGapMs: 100, triggerAt: "start" },
+ *   );
+ *   throttle.call();
+ *   throttle.call();
+ * @category Function
+ */
+declare function funnel<Args extends RestArguments = [], R = never>(callback: (data: R) => void, {
+  triggerAt,
+  minQuietPeriodMs,
+  maxBurstDurationMs,
+  minGapMs,
+  reducer
+}: FunnelOptions<Args, R>): Funnel<Args>;
+//#endregion
+export { funnel };
+//# sourceMappingURL=funnel.d.cts.map

package/dist/funnel.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funnel.d.cts","names":[],"sources":["../src/funnel.ts"],"sourcesContent":[],"mappings":";;;KAaK,2BAA2B;mCACG,0BAA0B,SAAS;AAdnB,CAAA,GAe/C,mBAFc;;;;;;KASb,mBAAA,GAPkB,CAAA;EAOlB,SAAA,SAAA,CAAA,EAAA,KAAmB;AAEkC,CAAA,GAkBrD,CAAA,CAAA;EAEK,SAAM,QAAA,EAAA,MAAc;AAyH9B,CAAA,GA7IyC,iBA6InB,CAAA;EAAc,SAAA,gBAAA,EAAA,MAAA;EACjB,SAAA,kBAAA,EAAA,MAAA;CAEf,CAAA,CAAA,GAAA;EACA,SAAA,gBAAA,CAAA,EAAA,MAAA;EACA,SAAA,kBAAA,CAAA,EAAA,MAAA;EACA,SAAA,QAAA,CAAA,EAAA,KAAA;CACA,CAAA,CAAA,GAAA;EACe,SAAA,SAAA,EAAA,OAAA,GAAA,MAAA;EAAM,SAAA,gBAAA,CAAA,EAAA,MAAA;EAApB,SAAA,kBAAA,CAAA,EAAA,MAAA;EACK,SAAA,QAAA,CAAA,EAAA,MAAA;CAAP;KApIE,aAAA,GAAgB,KAoIZ,CAAA,GAAA,CAAA;UAlIC,oBAAoB;;;;;;;2BAQH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiHX,oBAAoB,gDACjB;;;;;;GAOd,cAAc,MAAM,KACtB,OAAO"}

package/dist/funnel.d.ts

@@ -1,2 +1,155 @@
-import { funnel } from "./funnel-CMyhp3Kv.js";
-export { funnel };
+import { RequireAtLeastOne } from "type-fest";
+
+//#region src/funnel.d.ts
+type FunnelOptions<Args extends RestArguments, R> = {
+  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;
+} & FunnelTimingOptions;
+/**
+ * Not all combinations of timing options are valid, there are dependencies
+ * between them to ensure users can't configure the funnel in a way which would
+ * cause it to never trigger.
+ */
+type FunnelTimingOptions = ({
+  readonly triggerAt?: 'end';
+} & (({
+  readonly minGapMs: number;
+} & RequireAtLeastOne<{
+  readonly minQuietPeriodMs: number;
+  readonly maxBurstDurationMs: number;
+}>) | {
+  readonly minQuietPeriodMs?: number;
+  readonly maxBurstDurationMs?: number;
+  readonly minGapMs?: never;
+})) | {
+  readonly triggerAt: 'start' | 'both';
+  readonly minQuietPeriodMs?: number;
+  readonly maxBurstDurationMs?: number;
+  readonly minGapMs?: number;
+};
+type RestArguments = Array<any>;
+interface Funnel<Args extends RestArguments = []> {
+  /**
+   * Call the function. This might result in the `execute` function being called
+   * now or later, depending on it's configuration and it's current state.
+   *
+   * @param args - The args are defined by the `reducer` function.
+   */
+  readonly call: (...args: Args) => void;
+  /**
+   * Resets the funnel to it's initial state. Any calls made since the last
+   * invocation will be discarded.
+   */
+  readonly cancel: () => void;
+  /**
+   * Triggers an invocation regardless of the current state of the funnel.
+   * Like any other invocation, The funnel will also be reset to it's initial
+   * state afterwards.
+   */
+  readonly flush: () => void;
+  /**
+   * The funnel is in it's initial state (there are no active timeouts).
+   */
+  readonly isIdle: boolean;
+}
+/**
+ * Creates a funnel that controls the timing and execution of `callback`. Its
+ * main purpose is to manage multiple consecutive (usually fast-paced) calls,
+ * reshaping them according to a defined batching strategy and timing policy.
+ * This is useful when handling uncontrolled call rates, such as DOM events or
+ * network traffic. It can implement strategies like debouncing, throttling,
+ * batching, and more.
+ *
+ * An optional `reducer` function can be provided to allow passing data to the
+ * callback via calls to `call` (otherwise the signature of `call` takes no
+ * arguments).
+ *
+ * Typing is inferred from `callback`s param, and from the rest params that
+ * the optional `reducer` function accepts. Use **explicit** types for these
+ * to ensure that everything _else_ is well-typed.
+ *
+ * Notice that this function constructs a funnel **object**, and does **not**
+ * execute anything when called. The returned object should be used to execute
+ * the funnel via the its `call` method.
+ *
+ * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.
+ * - Throttling: use `minGapMs` and `triggerAt: "start"` or `"both"`.
+ * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).
+ *
+ * @param callback - The main function that would be invoked periodically based
+ * on `options`. The function would take the latest result of the `reducer`; if
+ * no calls where made since the last time it was invoked it will not be
+ * invoked. (If a return value is needed, it should be passed via a reference or
+ * via closure to the outer scope of the funnel).
+ * @param options - An object that defines when `execute` should be invoked,
+ * relative to the calls of `call`. An empty/missing options object is
+ * equivalent to setting `minQuietPeriodMs` to `0`.
+ * @param options.reducer - Combines the arguments passed to `call` with the
+ * value computed on the previous call (or `undefined` on the first time). The
+ * goal of the function is to extract and summarize the data needed for
+ * `callback`. It should be fast and simple as it is called often and should
+ * defer heavy operations to the `execute` function. If the final value
+ * is `undefined`, `callback` will not be called.
+ * @param options.triggerAt - At what "edges" of the funnel's burst window
+ * would `execute` invoke:
+ * - `start` - the function will be invoked immediately (within the  **same**
+ * execution frame!), and any subsequent calls would be ignored until the funnel
+ * is idle again. During this period `reducer` will also not be called.
+ * - `end` - the function will **not** be invoked initially but the timer will
+ * be started. Any calls during this time would be passed to the reducer, and
+ * when the timers are done, the reduced result would trigger an invocation.
+ * - `both` - the function will be invoked immediately, and then the funnel
+ * would behave as if it was in the 'end' state. @default 'end'.
+ * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls
+ * in short succession to cause excessive invocations (aka "debounce"). This
+ * duration represents the **minimum** amount of time that needs to pass
+ * between calls (the "quiet" part) in order for the subsequent call to **not**
+ * be considered part of the burst. In other words, as long as calls are faster
+ * than this, they are considered part of the burst and the burst is extended.
+ * @param options.maxBurstDurationMs - Bursts are extended every time a call is
+ * made within the burst period. This means that the burst period could be
+ * extended indefinitely. To prevent such cases, a maximum burst duration could
+ * be defined. When `minQuietPeriodMs` is not defined and this option is, they
+ * will both share the same value.
+ * @param options.minGapMs - A minimum duration between calls of `execute`.
+ * This is maintained regardless of the shape of the burst and is ensured even
+ * if the `maxBurstDurationMs` is reached before it. (aka "throttle").
+ * @returns A funnel with a `call` function that is used to trigger invocations.
+ * In addition to it the funnel also comes with the following functions and
+ * properties:
+ * - `cancel` - Resets the funnel to it's initial state, discarding the current
+ * `reducer` result without calling `execute` on it.
+ * - `flush` - Triggers an invocation even if there are active timeouts, and
+ * then resets the funnel to it's initial state.
+ * - `isIdle` - Checks if there are any active timeouts.
+ * @signature
+ *   P.funnel(callback, options);
+ * @example
+ *   const debouncer = P.funnel(
+ *     () => {
+ *       console.log("Callback executed!");
+ *     },
+ *     { minQuietPeriodMs: 100 },
+ *   );
+ *   debouncer.call();
+ *   debouncer.call();
+ *
+ *   const throttle = P.funnel(
+ *     () => {
+ *       console.log("Callback executed!");
+ *     },
+ *     { minGapMs: 100, triggerAt: "start" },
+ *   );
+ *   throttle.call();
+ *   throttle.call();
+ * @category Function
+ */
+declare function funnel<Args extends RestArguments = [], R = never>(callback: (data: R) => void, {
+  triggerAt,
+  minQuietPeriodMs,
+  maxBurstDurationMs,
+  minGapMs,
+  reducer
+}: FunnelOptions<Args, R>): Funnel<Args>;
+//#endregion
+export { funnel };
+//# sourceMappingURL=funnel.d.ts.map

package/dist/funnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funnel.d.ts","names":[],"sources":["../src/funnel.ts"],"sourcesContent":[],"mappings":";;;KAaK,2BAA2B;mCACG,0BAA0B,SAAS;AAdnB,CAAA,GAe/C,mBAFc;;;;;;KASb,mBAAA,GAPkB,CAAA;EAOlB,SAAA,SAAA,CAAA,EAAA,KAAmB;AAEkC,CAAA,GAkBrD,CAAA,CAAA;EAEK,SAAM,QAAA,EAAA,MAAc;AAyH9B,CAAA,GA7IyC,iBA6InB,CAAA;EAAc,SAAA,gBAAA,EAAA,MAAA;EACjB,SAAA,kBAAA,EAAA,MAAA;CAEf,CAAA,CAAA,GAAA;EACA,SAAA,gBAAA,CAAA,EAAA,MAAA;EACA,SAAA,kBAAA,CAAA,EAAA,MAAA;EACA,SAAA,QAAA,CAAA,EAAA,KAAA;CACA,CAAA,CAAA,GAAA;EACe,SAAA,SAAA,EAAA,OAAA,GAAA,MAAA;EAAM,SAAA,gBAAA,CAAA,EAAA,MAAA;EAApB,SAAA,kBAAA,CAAA,EAAA,MAAA;EACK,SAAA,QAAA,CAAA,EAAA,MAAA;CAAP;KApIE,aAAA,GAAgB,KAoIZ,CAAA,GAAA,CAAA;UAlIC,oBAAoB;;;;;;;2BAQH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiHX,oBAAoB,gDACjB;;;;;;GAOd,cAAc,MAAM,KACtB,OAAO"}

package/dist/funnel.js

@@ -1 +1,2 @@
-import{funnel as e}from"./funnel-CEbURcmp.js";export{e as funnel};
+const e=Symbol(`funnel/voidReducer`),t=()=>e;function n(n,{triggerAt:r=`end`,minQuietPeriodMs:i,maxBurstDurationMs:a,minGapMs:o,reducer:s=t}){let c,l,u,d;function f(){let t=u;t!==void 0&&(u=void 0,t===e?n():n(t),o!==void 0&&(l=setTimeout(p,o)))}function p(){clearTimeout(l),l=void 0,c===void 0&&f()}function m(){clearTimeout(c),c=void 0,d=void 0,l===void 0&&f()}return{call:(...e)=>{let t=c===void 0&&l===void 0;if((r!==`start`||t)&&(u=s(u,...e)),!(c===void 0&&!t)){if(i!==void 0||a!==void 0||o===void 0){clearTimeout(c);let e=Date.now();d??=e;let t=a===void 0?i??0:Math.min(i??a,a-(e-d));c=setTimeout(m,t)}r!==`end`&&t&&f()}},cancel:()=>{clearTimeout(c),c=void 0,d=void 0,clearTimeout(l),l=void 0,u=void 0},flush:()=>{m(),p()},get isIdle(){return c===void 0&&l===void 0}}}export{n as funnel};
+//# sourceMappingURL=funnel.js.map