@vinicunca/perkakas 1.14.0 → 1.16.0

package/dist/for-each.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"for-each.cjs","names":["curry"],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEach(data, callbackfn)\n * @example\n *    forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    forEach(callbackfn)(data)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGA0DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,EAAW,CAEjB,EAGT,SAAS,EAAsB,EAAyF,CACtH,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,EAAK,CACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"for-each.cjs","names":["curry"],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEach(data, callbackfn)\n * @example\n *    forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    forEach(callbackfn)(data)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGA0DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAM,CAAkB,CAC9D,CAEA,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,CAAU,EAEhB,CACT,CAEA,SAAS,EAAsB,EAAyF,CACtH,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,CAAI,EACtB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAErD"}

package/dist/for-each.js.map

@@ -1 +1 @@
-{"version":3,"file":"for-each.js","names":[],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEach(data, callbackfn)\n * @example\n *    forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    forEach(callbackfn)(data)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"mCA0DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,EAAW,CAEjB,EAGT,SAAS,EAAsB,EAAyF,CACtH,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,EAAK,CACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"for-each.js","names":[],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEach(data, callbackfn)\n * @example\n *    forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    forEach(callbackfn)(data)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"mCA0DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,CAAkB,CAC9D,CAEA,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,CAAU,EAEhB,CACT,CAEA,SAAS,EAAsB,EAAyF,CACtH,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,CAAI,EACtB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAErD"}

package/dist/from-entries.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(Object.fromEntries,t)}exports.fromEntries=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(Object.fromEntries,t)}exports.fromEntries=t;
 //# sourceMappingURL=from-entries.cjs.map

package/dist/from-entries.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-entries.cjs","names":["curry"],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\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 * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   fromEntries(tuples)\n * @example\n *   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 * Refer to the docs for more details.\n *\n * @signature\n *   fromEntries()(tuples)\n * @example\n *   pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     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":"kGA+IA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,OAAO,YAAa,EAAK"}
+{"version":3,"file":"from-entries.cjs","names":["curry"],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { IsNever, Simplify } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\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> = (IsNever<Extract<Entries[number], Entry<K>>> extends true\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 * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   fromEntries(tuples)\n * @example\n *   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 * Refer to the docs for more details.\n *\n * @signature\n *   fromEntries()(tuples)\n * @example\n *   pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     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":"kGA+IA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,OAAO,YAAa,CAAI,CACvC"}

package/dist/from-entries.js.map

@@ -1 +1 @@
-{"version":3,"file":"from-entries.js","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\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 * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   fromEntries(tuples)\n * @example\n *   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 * Refer to the docs for more details.\n *\n * @signature\n *   fromEntries()(tuples)\n * @example\n *   pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     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":"mCA+IA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,OAAO,YAAa,EAAK"}
+{"version":3,"file":"from-entries.js","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { IsNever, Simplify } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\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> = (IsNever<Extract<Entries[number], Entry<K>>> extends true\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 * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   fromEntries(tuples)\n * @example\n *   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 * Refer to the docs for more details.\n *\n * @signature\n *   fromEntries()(tuples)\n * @example\n *   pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     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":"mCA+IA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,OAAO,YAAa,CAAI,CACvC"}

package/dist/from-keys.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(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;
 //# sourceMappingURL=from-keys.cjs.map

package/dist/from-keys.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"from-keys.cjs","names":["curry"],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\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 ? Record<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 * 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 *   fromKeys(data, mapper);\n * @example\n *   fromKeys([\"cat\", \"dog\"], length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   fromKeys([1, 2], 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 * 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 *   fromKeys(mapper)(data);\n * @example\n *   pipe([\"cat\", \"dog\"], fromKeys(length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   pipe([1, 2], fromKeys(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":"kGA0EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAM,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}
+{"version":3,"file":"from-keys.cjs","names":["curry"],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\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 ? Record<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 * 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 *   fromKeys(data, mapper);\n * @example\n *   fromKeys([\"cat\", \"dog\"], length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   fromKeys([1, 2], 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 * 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 *   fromKeys(mapper)(data);\n * @example\n *   pipe([\"cat\", \"dog\"], fromKeys(length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   pipe([1, 2], fromKeys(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":"kGA0EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EACP,EACA,EACgB,CAChB,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,QAAQ,EAEtC,EAAO,GAAO,EAAO,EAAK,EAAO,CAAI,EAGvC,OAAO,CACT"}

package/dist/from-keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"from-keys.js","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\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 ? Record<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 * 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 *   fromKeys(data, mapper);\n * @example\n *   fromKeys([\"cat\", \"dog\"], length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   fromKeys([1, 2], 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 * 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 *   fromKeys(mapper)(data);\n * @example\n *   pipe([\"cat\", \"dog\"], fromKeys(length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   pipe([1, 2], fromKeys(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":"mCA0EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAM,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}
+{"version":3,"file":"from-keys.js","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\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 ? Record<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 * 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 *   fromKeys(data, mapper);\n * @example\n *   fromKeys([\"cat\", \"dog\"], length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   fromKeys([1, 2], 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 * 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 *   fromKeys(mapper)(data);\n * @example\n *   pipe([\"cat\", \"dog\"], fromKeys(length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   pipe([1, 2], fromKeys(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":"mCA0EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EACP,EACA,EACgB,CAChB,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,QAAQ,EAEtC,EAAO,GAAO,EAAO,EAAK,EAAO,CAAI,EAGvC,OAAO,CACT"}

package/dist/funnel.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"funnel.cjs","names":[],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n// We use the value provided by the reducer to also determine if a call\n// was done during a timeout period. This means that even when no reducer\n// is provided, we still need a dummy reducer that would return something\n// other than `undefined`. It is safe to cast this to R (which might be\n// anything) because the callback would never use it as it would be typed\n// as a zero-args function.\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n// Not all combinations of timing options are valid, there are dependencies\n// between them to ensure users can't configure the funnel in a way which would\n// cause it to never trigger.\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. Default: 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   funnel(callback, options);\n * @example\n *   const debouncer = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  // We manage execution via 2 timeouts, one to track bursts of calls, and one\n  // to track the interval between invocations. Together we refer to the period\n  // where any of these are active as a \"cool-down period\".\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // Until invoked, all calls are reduced into a single value that would be sent\n  // to the executor on invocation.\n  let preparedData: R | undefined;\n\n  // In order to be able to limit the total size of the burst (when\n  // `maxBurstDurationMs` is used) we need to track when the burst started.\n  let burstStartTimestamp: number | undefined;\n\n  const invoke = (): void => {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  };\n\n  function handleIntervalEnd(): void {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  }\n\n  const handleBurstEnd = (): void => {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      // We act based on the initial state of the timeouts before the call is\n      // handled and causes the timeouts to change.\n      const wasIdle\n        = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        // We are not in an active burst period but in an interval period. We\n        // don't start a new burst window until the next invoke.\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        // The timeout tracking the burst period needs to be reset every time\n        // another call is made so that it waits the full cool-down duration\n        // before it is released.\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                // We need to account for the time already spent so that we\n                // don't wait longer than the maxDelay.\n                Math.max(0, maxBurstDurationMs - (now - burstStartTimestamp)),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"mEAQA,MAAM,EAAsB,OAAO,qBAAqB,CAClD,MAA0B,EAwJhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAId,IAAI,EACA,EAIA,EAIA,EAEE,MAAqB,CACzB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAEX,IAAU,EAIZ,GAAU,CAEV,EAAS,EAAM,CAGb,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,EAAS,IAI/D,SAAS,GAA0B,CAGjC,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IAOvB,GAAQ,CAGV,IAAM,MAA6B,CAGjC,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAO1B,GAAQ,EAGV,MAAO,CACL,MAAO,GAAG,IAAS,CAGjB,IAAM,EACF,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAE1D,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,EAAK,EAG3C,MAAmB,IAAA,IAAa,CAAC,GAMrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAIA,aAAa,EAAe,CAE5B,IAAM,EAAM,KAAK,KAAK,CAEtB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAGpB,KAAK,IAAI,EAAG,GAAsB,EAAM,GAAqB,CAC9D,CAEP,EAAiB,WAAW,EAAgB,EAAiB,CAG3D,IAAc,OAAS,GACzB,GAAQ,GAIZ,WAAc,CACZ,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEpB,EAAe,IAAA,IAGjB,UAAa,CACX,GAAgB,CAChB,GAAmB,EAGrB,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,IAEhE"}
+{"version":3,"file":"funnel.cjs","names":[],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n// We use the value provided by the reducer to also determine if a call\n// was done during a timeout period. This means that even when no reducer\n// is provided, we still need a dummy reducer that would return something\n// other than `undefined`. It is safe to cast this to R (which might be\n// anything) because the callback would never use it as it would be typed\n// as a zero-args function.\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n// Not all combinations of timing options are valid, there are dependencies\n// between them to ensure users can't configure the funnel in a way which would\n// cause it to never trigger.\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. Default: 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   funnel(callback, options);\n * @example\n *   const debouncer = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  // We manage execution via 2 timeouts, one to track bursts of calls, and one\n  // to track the interval between invocations. Together we refer to the period\n  // where any of these are active as a \"cool-down period\".\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // Until invoked, all calls are reduced into a single value that would be sent\n  // to the executor on invocation.\n  let preparedData: R | undefined;\n\n  // In order to be able to limit the total size of the burst (when\n  // `maxBurstDurationMs` is used) we need to track when the burst started.\n  let burstStartTimestamp: number | undefined;\n\n  const invoke = (): void => {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  };\n\n  function handleIntervalEnd(): void {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  }\n\n  const handleBurstEnd = (): void => {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      // We act based on the initial state of the timeouts before the call is\n      // handled and causes the timeouts to change.\n      const wasIdle\n        = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        // We are not in an active burst period but in an interval period. We\n        // don't start a new burst window until the next invoke.\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        // The timeout tracking the burst period needs to be reset every time\n        // another call is made so that it waits the full cool-down duration\n        // before it is released.\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                // We need to account for the time already spent so that we\n                // don't wait longer than the maxDelay.\n                Math.max(0, maxBurstDurationMs - (now - burstStartTimestamp)),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"mEAQA,MAAM,EAAsB,OAAO,oBAAoB,EACjD,MAA0B,EAwJhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAId,IAAI,EACA,EAIA,EAIA,EAEE,MAAqB,CACzB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAEX,IAAU,EAIZ,EAAS,EAET,EAAS,CAAK,EAGZ,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,CAAQ,GAE9D,EAEA,SAAS,GAA0B,CAGjC,aAAa,CAAiB,EAC9B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IAOvB,EAAO,CACT,CAEA,IAAM,MAA6B,CAGjC,aAAa,CAAc,EAC3B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAO1B,EAAO,CACT,EAEA,MAAO,CACL,MAAO,GAAG,IAAS,CAGjB,IAAM,EACF,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAE1D,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,CAAI,GAG1C,MAAmB,IAAA,IAAa,CAAC,GAMrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAIA,aAAa,CAAc,EAE3B,IAAM,EAAM,KAAK,IAAI,EAErB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAGpB,KAAK,IAAI,EAAG,GAAsB,EAAM,EAAoB,CAC9D,EAEN,EAAiB,WAAW,EAAgB,CAAgB,CAC9D,CAEI,IAAc,OAAS,GACzB,EAAO,CAHT,CAKF,EAEA,WAAc,CACZ,aAAa,CAAc,EAC3B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,CAAiB,EAC9B,EAAoB,IAAA,GAEpB,EAAe,IAAA,EACjB,EAEA,UAAa,CACX,EAAe,EACf,EAAkB,CACpB,EAEA,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,EAC/D,CACF,CACF"}

package/dist/funnel.js.map

@@ -1 +1 @@
-{"version":3,"file":"funnel.js","names":[],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n// We use the value provided by the reducer to also determine if a call\n// was done during a timeout period. This means that even when no reducer\n// is provided, we still need a dummy reducer that would return something\n// other than `undefined`. It is safe to cast this to R (which might be\n// anything) because the callback would never use it as it would be typed\n// as a zero-args function.\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n// Not all combinations of timing options are valid, there are dependencies\n// between them to ensure users can't configure the funnel in a way which would\n// cause it to never trigger.\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. Default: 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   funnel(callback, options);\n * @example\n *   const debouncer = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  // We manage execution via 2 timeouts, one to track bursts of calls, and one\n  // to track the interval between invocations. Together we refer to the period\n  // where any of these are active as a \"cool-down period\".\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // Until invoked, all calls are reduced into a single value that would be sent\n  // to the executor on invocation.\n  let preparedData: R | undefined;\n\n  // In order to be able to limit the total size of the burst (when\n  // `maxBurstDurationMs` is used) we need to track when the burst started.\n  let burstStartTimestamp: number | undefined;\n\n  const invoke = (): void => {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  };\n\n  function handleIntervalEnd(): void {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  }\n\n  const handleBurstEnd = (): void => {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      // We act based on the initial state of the timeouts before the call is\n      // handled and causes the timeouts to change.\n      const wasIdle\n        = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        // We are not in an active burst period but in an interval period. We\n        // don't start a new burst window until the next invoke.\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        // The timeout tracking the burst period needs to be reset every time\n        // another call is made so that it waits the full cool-down duration\n        // before it is released.\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                // We need to account for the time already spent so that we\n                // don't wait longer than the maxDelay.\n                Math.max(0, maxBurstDurationMs - (now - burstStartTimestamp)),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"AAQA,MAAM,EAAsB,OAAO,qBAAqB,CAClD,MAA0B,EAwJhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAId,IAAI,EACA,EAIA,EAIA,EAEE,MAAqB,CACzB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAEX,IAAU,EAIZ,GAAU,CAEV,EAAS,EAAM,CAGb,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,EAAS,IAI/D,SAAS,GAA0B,CAGjC,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IAOvB,GAAQ,CAGV,IAAM,MAA6B,CAGjC,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAO1B,GAAQ,EAGV,MAAO,CACL,MAAO,GAAG,IAAS,CAGjB,IAAM,EACF,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAE1D,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,EAAK,EAG3C,MAAmB,IAAA,IAAa,CAAC,GAMrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAIA,aAAa,EAAe,CAE5B,IAAM,EAAM,KAAK,KAAK,CAEtB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAGpB,KAAK,IAAI,EAAG,GAAsB,EAAM,GAAqB,CAC9D,CAEP,EAAiB,WAAW,EAAgB,EAAiB,CAG3D,IAAc,OAAS,GACzB,GAAQ,GAIZ,WAAc,CACZ,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEpB,EAAe,IAAA,IAGjB,UAAa,CACX,GAAgB,CAChB,GAAmB,EAGrB,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,IAEhE"}
+{"version":3,"file":"funnel.js","names":[],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n// We use the value provided by the reducer to also determine if a call\n// was done during a timeout period. This means that even when no reducer\n// is provided, we still need a dummy reducer that would return something\n// other than `undefined`. It is safe to cast this to R (which might be\n// anything) because the callback would never use it as it would be typed\n// as a zero-args function.\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n// Not all combinations of timing options are valid, there are dependencies\n// between them to ensure users can't configure the funnel in a way which would\n// cause it to never trigger.\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. Default: 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   funnel(callback, options);\n * @example\n *   const debouncer = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  // We manage execution via 2 timeouts, one to track bursts of calls, and one\n  // to track the interval between invocations. Together we refer to the period\n  // where any of these are active as a \"cool-down period\".\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // Until invoked, all calls are reduced into a single value that would be sent\n  // to the executor on invocation.\n  let preparedData: R | undefined;\n\n  // In order to be able to limit the total size of the burst (when\n  // `maxBurstDurationMs` is used) we need to track when the burst started.\n  let burstStartTimestamp: number | undefined;\n\n  const invoke = (): void => {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  };\n\n  function handleIntervalEnd(): void {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  }\n\n  const handleBurstEnd = (): void => {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      // We act based on the initial state of the timeouts before the call is\n      // handled and causes the timeouts to change.\n      const wasIdle\n        = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        // We are not in an active burst period but in an interval period. We\n        // don't start a new burst window until the next invoke.\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        // The timeout tracking the burst period needs to be reset every time\n        // another call is made so that it waits the full cool-down duration\n        // before it is released.\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                // We need to account for the time already spent so that we\n                // don't wait longer than the maxDelay.\n                Math.max(0, maxBurstDurationMs - (now - burstStartTimestamp)),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"AAQA,MAAM,EAAsB,OAAO,oBAAoB,EACjD,MAA0B,EAwJhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAId,IAAI,EACA,EAIA,EAIA,EAEE,MAAqB,CACzB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAEX,IAAU,EAIZ,EAAS,EAET,EAAS,CAAK,EAGZ,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,CAAQ,GAE9D,EAEA,SAAS,GAA0B,CAGjC,aAAa,CAAiB,EAC9B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IAOvB,EAAO,CACT,CAEA,IAAM,MAA6B,CAGjC,aAAa,CAAc,EAC3B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAO1B,EAAO,CACT,EAEA,MAAO,CACL,MAAO,GAAG,IAAS,CAGjB,IAAM,EACF,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAE1D,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,CAAI,GAG1C,MAAmB,IAAA,IAAa,CAAC,GAMrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAIA,aAAa,CAAc,EAE3B,IAAM,EAAM,KAAK,IAAI,EAErB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAGpB,KAAK,IAAI,EAAG,GAAsB,EAAM,EAAoB,CAC9D,EAEN,EAAiB,WAAW,EAAgB,CAAgB,CAC9D,CAEI,IAAc,OAAS,GACzB,EAAO,CAHT,CAKF,EAEA,WAAc,CACZ,aAAa,CAAc,EAC3B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,CAAiB,EAC9B,EAAoB,IAAA,GAEpB,EAAe,IAAA,EACjB,EAEA,UAAa,CACX,EAAe,EACf,EAAkB,CACpB,EAEA,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,EAC/D,CACF,CACF"}

package/dist/group-by-prop.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=Object.create(null);for(let r of e){let e=r?.[t];if(e!==void 0){let t=n[e];t===void 0?n[e]=[r]:t.push(r)}}return Object.setPrototypeOf(n,Object.prototype),n}exports.groupByProp=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){let n=Object.create(null);for(let r of e){let e=r?.[t];if(e!==void 0){let t=n[e];t===void 0?n[e]=[r]:t.push(r)}}return Object.setPrototypeOf(n,Object.prototype),n}exports.groupByProp=t;
 //# sourceMappingURL=group-by-prop.cjs.map

package/dist/group-by-prop.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"group-by-prop.cjs","names":["curry"],"sources":["../src/group-by-prop.ts"],"sourcesContent":["import type {\n  AllUnionFields,\n  ConditionalKeys,\n  EmptyObject,\n  IsNever,\n  Or,\n  Simplify,\n} from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>\n  // Distribute unions.\n  = T extends unknown\n    ? FixEmptyObject<EnsureValuesAreNonEmpty<GroupByPropRaw<T, Prop>>>\n    : never;\n\n// For each possible value of the prop we filter the input tuple with the prop\n// assigned to the value, e.g. `{ type: \"cat\" }`\ntype GroupByPropRaw<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = {\n  [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;\n};\n\n// We can only group by props that only have values that could be used to key\n// an object (i.e. PropertyKey), or if they are undefined (which would filter\n// them out of the grouping).\ntype GroupableProps<T extends IterableContainer> = ConditionalKeys<\n  ItemsSuperObject<T>,\n  PropertyKey | undefined\n>;\n\n// The union of all possible values that the prop could have within the tuple.\ntype AllPropValues<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;\n\n// Creates a singular object type that all items in the tuple would extend. This\n// provides us a way to check, for each prop, what are all values it would\n// have within the tuple. We use this to map which props are candidates for\n// grouping, and when a prop is selected, the full list of values that would\n// exist in the output. For example:\n// `{ a: number, b: \"cat\", c: string } | { b: \"dog\", c: Date }` is groupable\n// by 'a' and 'b', but not 'c', and when selecting by 'b', the output would\n// have a prop for \"cat\" and a prop for \"dog\".\ntype ItemsSuperObject<T extends IterableContainer> = AllUnionFields<\n  // If the input tuple contains optional elements they would add `undefined` to\n  // T[number] (and could technically show up in the array itself). Because\n  // undefined breaks AllUnionFields we need to remove it from the union. This\n  // is OK because we handle this in the implementation too.\n  Exclude<T[number], undefined>\n>;\n\n// When the input array is empty the constructed result type would be `{}`\n// because our mapped type would never run; but this doesn't represent the\n// semantics of the return value for that case, because it effectively means\n// \"any object\" and not \"empty object\". This can happen in 2 situations:\n// A union of tuples where one of the tuples doesn't have any item with the\n// groupable prop, or when the groupable prop has a value of `undefined` for\n// all items. The former is extra problematic because it would add `| {}` to the\n// result type which effectively cancels out all other parts of the union.\ntype FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n// Group by can never return an empty tuple but our filtered arrays might not\n// represent that. We need to reshape the tuples so that they always have at\n// least one item in them.\ntype EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>>\n  = Simplify<\n    Omit<T, PossiblyEmptyArrayKeys<T>>\n    & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>\n  >;\n\n// Go over the keys the object and return those that their value can accept an\n// empty array.\ntype PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>>\n  = keyof T extends infer Key extends unknown\n    ? Key extends keyof T\n      ? IsNonEmptyArray<T[Key]> extends true\n        ? never\n        : Key\n      : never\n    : never;\n\n// An array is non-empty if any of the fixed parts are non-empty.\ntype IsNonEmptyArray<T extends IterableContainer> = Or<\n  IsNonEmptyFixedTuple<TupleParts<T>['required']>,\n  IsNonEmptyFixedTuple<TupleParts<T>['suffix']>\n>;\n\n// A fixed tuple (one without optional or a rest element in it) is non-empty if\n// we can't extract the empty tuple from it.\ntype IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;\n\n// We coerce the arbitrary array values to have a prefix of at least one item.\ntype CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = {\n  [P in keyof T]: ArrayRequiredPrefix<T[P], 1>;\n};\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param data - The items to group.\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(data, prop)\n * @example\n *    const result = groupByProp(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      'a',\n *    );\n * @dataFirst\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop>;\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(prop)(data);\n * @example\n *    const result = pipe(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      groupByProp('a'),\n *    );\n * @dataLast\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(prop: Prop): (data: T) => GroupByProp<T, Prop>;\n\nexport function groupByProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByPropImplementation, args);\n}\n\nfunction groupByPropImplementation<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop> {\n  const output: BoundedPartial<Record<AllPropValues<T, Prop>, Array<T[number]>>>\n    = Object.create(null);\n\n  for (const item of data) {\n    const key = item?.[prop];\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop\n      // directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an\n        // empty array and falling through to a unified the push. It is also\n        // more performant to mutate the existing object over using spread to\n        // continually create new objects on every unique key.\n        // @ts-expect-error [ts7053] -- For the same reasons as mentioned above, TypeScript isn't inferring `key` correctly, and therefore is erroring when trying to access the output object using it.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array instead\n        // of creating a new array via spreading every time we add an item to\n        // it (e.g., `[...current, item]`).\n        // @ts-expect-error [ts2339] -- And again here `items` is still `never`.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g.\n  // `{}`). Without this none of the built-in object methods like `toString`\n  // would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  // @ts-expect-error [ts2322] -- This is fine! We use a broader type for output while we build it because it more accurately represents the shape of the object *while it is being built*. TypeScript can't tell that we finished building the object so can't ensure that output matches the expected output at this point.\n  return output;\n}\n"],"mappings":"kGAoLA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAGP,EAAS,EAAkC,CAC3C,IAAM,EACF,OAAO,OAAO,KAAK,CAEvB,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAM,IAAO,GACnB,GAAI,IAAQ,IAAA,GAAW,CAGrB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAMZ,EAAO,GAAO,CAAC,EAAK,CAMpB,EAAM,KAAK,EAAK,EAWtB,OAHA,OAAO,eAAe,EAAQ,OAAO,UAAU,CAGxC"}
+{"version":3,"file":"group-by-prop.cjs","names":["curry"],"sources":["../src/group-by-prop.ts"],"sourcesContent":["import type {\n  AllUnionFields,\n  ConditionalKeys,\n  EmptyObject,\n  IsNever,\n  Simplify,\n} from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>\n  // Distribute unions.\n  = T extends unknown\n    ? FixEmptyObject<EnsureValuesAreNonEmpty<GroupByPropRaw<T, Prop>>>\n    : never;\n\n// For each possible value of the prop we filter the input tuple with the prop\n// assigned to the value, e.g. `{ type: \"cat\" }`\ntype GroupByPropRaw<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = {\n  [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;\n};\n\n// We can only group by props that only have values that could be used to key\n// an object (i.e. PropertyKey), or if they are undefined (which would filter\n// them out of the grouping).\ntype GroupableProps<T extends IterableContainer> = ConditionalKeys<\n  ItemsSuperObject<T>,\n  PropertyKey | undefined\n>;\n\n// The union of all possible values that the prop could have within the tuple.\ntype AllPropValues<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;\n\n// Creates a singular object type that all items in the tuple would extend. This\n// provides us a way to check, for each prop, what are all values it would\n// have within the tuple. We use this to map which props are candidates for\n// grouping, and when a prop is selected, the full list of values that would\n// exist in the output. For example:\n// `{ a: number, b: \"cat\", c: string } | { b: \"dog\", c: Date }` is groupable\n// by 'a' and 'b', but not 'c', and when selecting by 'b', the output would\n// have a prop for \"cat\" and a prop for \"dog\".\ntype ItemsSuperObject<T extends IterableContainer> = AllUnionFields<\n  // If the input tuple contains optional elements they would add `undefined` to\n  // T[number] (and could technically show up in the array itself). Because\n  // undefined breaks AllUnionFields we need to remove it from the union. This\n  // is OK because we handle this in the implementation too.\n  Exclude<T[number], undefined>\n>;\n\n// When the input array is empty the constructed result type would be `{}`\n// because our mapped type would never run; but this doesn't represent the\n// semantics of the return value for that case, because it effectively means\n// \"any object\" and not \"empty object\". This can happen in 2 situations:\n// A union of tuples where one of the tuples doesn't have any item with the\n// groupable prop, or when the groupable prop has a value of `undefined` for\n// all items. The former is extra problematic because it would add `| {}` to the\n// result type which effectively cancels out all other parts of the union.\ntype FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n// Group by can never return an empty tuple but our filtered arrays might not\n// represent that. We need to reshape the tuples so that they always have at\n// least one item in them.\ntype EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>>\n  = Simplify<\n    Omit<T, PossiblyEmptyArrayKeys<T>>\n    & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>\n  >;\n\n// Go over the keys the object and return those that their value can accept an\n// empty array.\ntype PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>>\n  = keyof T extends infer Key extends unknown\n    ? Key extends keyof T\n      ? IsNonEmptyArray<T[Key]> extends true\n        ? never\n        : Key\n      : never\n    : never;\n\n// An array is non-empty if any of the fixed parts are non-empty.\ntype IsNonEmptyArray<T extends IterableContainer>\n  = IsNonEmptyFixedTuple<TupleParts<T>['required']> extends true\n    ? true\n    : IsNonEmptyFixedTuple<TupleParts<T>['suffix']> extends true\n      ? true\n      : false;\n\n// A fixed tuple (one without optional or a rest element in it) is non-empty if\n// we can't extract the empty tuple from it.\ntype IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;\n\n// We coerce the arbitrary array values to have a prefix of at least one item.\ntype CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = {\n  [P in keyof T]: ArrayRequiredPrefix<T[P], 1>;\n};\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param data - The items to group.\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(data, prop)\n * @example\n *    const result = groupByProp(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      'a',\n *    );\n * @dataFirst\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop>;\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(prop)(data);\n * @example\n *    const result = pipe(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      groupByProp('a'),\n *    );\n * @dataLast\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(prop: Prop): (data: T) => GroupByProp<T, Prop>;\n\nexport function groupByProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByPropImplementation, args);\n}\n\nfunction groupByPropImplementation<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop> {\n  const output: BoundedPartial<Record<AllPropValues<T, Prop>, Array<T[number]>>>\n    = Object.create(null);\n\n  for (const item of data) {\n    const key = item?.[prop];\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop\n      // directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an\n        // empty array and falling through to a unified the push. It is also\n        // more performant to mutate the existing object over using spread to\n        // continually create new objects on every unique key.\n        // @ts-expect-error [ts7053] -- For the same reasons as mentioned above, TypeScript isn't inferring `key` correctly, and therefore is erroring when trying to access the output object using it.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array instead\n        // of creating a new array via spreading every time we add an item to\n        // it (e.g., `[...current, item]`).\n        // @ts-expect-error [ts2339] -- And again here `items` is still `never`.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g.\n  // `{}`). Without this none of the built-in object methods like `toString`\n  // would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  // @ts-expect-error [ts2322] -- This is fine! We use a broader type for output while we build it because it more accurately represents the shape of the object *while it is being built*. TypeScript can't tell that we finished building the object so can't ensure that output matches the expected output at this point.\n  return output;\n}\n"],"mappings":"kGAqLA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAGP,EAAS,EAAkC,CAC3C,IAAM,EACF,OAAO,OAAO,IAAI,EAEtB,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAM,IAAO,GACnB,GAAI,IAAQ,IAAA,GAAW,CAGrB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAMZ,EAAO,GAAO,CAAC,CAAI,EAMnB,EAAM,KAAK,CAAI,CAEnB,CACF,CAQA,OAHA,OAAO,eAAe,EAAQ,OAAO,SAAS,EAGvC,CACT"}

package/dist/group-by-prop.js.map

@@ -1 +1 @@
-{"version":3,"file":"group-by-prop.js","names":[],"sources":["../src/group-by-prop.ts"],"sourcesContent":["import type {\n  AllUnionFields,\n  ConditionalKeys,\n  EmptyObject,\n  IsNever,\n  Or,\n  Simplify,\n} from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>\n  // Distribute unions.\n  = T extends unknown\n    ? FixEmptyObject<EnsureValuesAreNonEmpty<GroupByPropRaw<T, Prop>>>\n    : never;\n\n// For each possible value of the prop we filter the input tuple with the prop\n// assigned to the value, e.g. `{ type: \"cat\" }`\ntype GroupByPropRaw<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = {\n  [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;\n};\n\n// We can only group by props that only have values that could be used to key\n// an object (i.e. PropertyKey), or if they are undefined (which would filter\n// them out of the grouping).\ntype GroupableProps<T extends IterableContainer> = ConditionalKeys<\n  ItemsSuperObject<T>,\n  PropertyKey | undefined\n>;\n\n// The union of all possible values that the prop could have within the tuple.\ntype AllPropValues<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;\n\n// Creates a singular object type that all items in the tuple would extend. This\n// provides us a way to check, for each prop, what are all values it would\n// have within the tuple. We use this to map which props are candidates for\n// grouping, and when a prop is selected, the full list of values that would\n// exist in the output. For example:\n// `{ a: number, b: \"cat\", c: string } | { b: \"dog\", c: Date }` is groupable\n// by 'a' and 'b', but not 'c', and when selecting by 'b', the output would\n// have a prop for \"cat\" and a prop for \"dog\".\ntype ItemsSuperObject<T extends IterableContainer> = AllUnionFields<\n  // If the input tuple contains optional elements they would add `undefined` to\n  // T[number] (and could technically show up in the array itself). Because\n  // undefined breaks AllUnionFields we need to remove it from the union. This\n  // is OK because we handle this in the implementation too.\n  Exclude<T[number], undefined>\n>;\n\n// When the input array is empty the constructed result type would be `{}`\n// because our mapped type would never run; but this doesn't represent the\n// semantics of the return value for that case, because it effectively means\n// \"any object\" and not \"empty object\". This can happen in 2 situations:\n// A union of tuples where one of the tuples doesn't have any item with the\n// groupable prop, or when the groupable prop has a value of `undefined` for\n// all items. The former is extra problematic because it would add `| {}` to the\n// result type which effectively cancels out all other parts of the union.\ntype FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n// Group by can never return an empty tuple but our filtered arrays might not\n// represent that. We need to reshape the tuples so that they always have at\n// least one item in them.\ntype EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>>\n  = Simplify<\n    Omit<T, PossiblyEmptyArrayKeys<T>>\n    & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>\n  >;\n\n// Go over the keys the object and return those that their value can accept an\n// empty array.\ntype PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>>\n  = keyof T extends infer Key extends unknown\n    ? Key extends keyof T\n      ? IsNonEmptyArray<T[Key]> extends true\n        ? never\n        : Key\n      : never\n    : never;\n\n// An array is non-empty if any of the fixed parts are non-empty.\ntype IsNonEmptyArray<T extends IterableContainer> = Or<\n  IsNonEmptyFixedTuple<TupleParts<T>['required']>,\n  IsNonEmptyFixedTuple<TupleParts<T>['suffix']>\n>;\n\n// A fixed tuple (one without optional or a rest element in it) is non-empty if\n// we can't extract the empty tuple from it.\ntype IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;\n\n// We coerce the arbitrary array values to have a prefix of at least one item.\ntype CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = {\n  [P in keyof T]: ArrayRequiredPrefix<T[P], 1>;\n};\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param data - The items to group.\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(data, prop)\n * @example\n *    const result = groupByProp(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      'a',\n *    );\n * @dataFirst\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop>;\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(prop)(data);\n * @example\n *    const result = pipe(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      groupByProp('a'),\n *    );\n * @dataLast\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(prop: Prop): (data: T) => GroupByProp<T, Prop>;\n\nexport function groupByProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByPropImplementation, args);\n}\n\nfunction groupByPropImplementation<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop> {\n  const output: BoundedPartial<Record<AllPropValues<T, Prop>, Array<T[number]>>>\n    = Object.create(null);\n\n  for (const item of data) {\n    const key = item?.[prop];\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop\n      // directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an\n        // empty array and falling through to a unified the push. It is also\n        // more performant to mutate the existing object over using spread to\n        // continually create new objects on every unique key.\n        // @ts-expect-error [ts7053] -- For the same reasons as mentioned above, TypeScript isn't inferring `key` correctly, and therefore is erroring when trying to access the output object using it.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array instead\n        // of creating a new array via spreading every time we add an item to\n        // it (e.g., `[...current, item]`).\n        // @ts-expect-error [ts2339] -- And again here `items` is still `never`.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g.\n  // `{}`). Without this none of the built-in object methods like `toString`\n  // would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  // @ts-expect-error [ts2322] -- This is fine! We use a broader type for output while we build it because it more accurately represents the shape of the object *while it is being built*. TypeScript can't tell that we finished building the object so can't ensure that output matches the expected output at this point.\n  return output;\n}\n"],"mappings":"mCAoLA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAGP,EAAS,EAAkC,CAC3C,IAAM,EACF,OAAO,OAAO,KAAK,CAEvB,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAM,IAAO,GACnB,GAAI,IAAQ,IAAA,GAAW,CAGrB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAMZ,EAAO,GAAO,CAAC,EAAK,CAMpB,EAAM,KAAK,EAAK,EAWtB,OAHA,OAAO,eAAe,EAAQ,OAAO,UAAU,CAGxC"}
+{"version":3,"file":"group-by-prop.js","names":[],"sources":["../src/group-by-prop.ts"],"sourcesContent":["import type {\n  AllUnionFields,\n  ConditionalKeys,\n  EmptyObject,\n  IsNever,\n  Simplify,\n} from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>\n  // Distribute unions.\n  = T extends unknown\n    ? FixEmptyObject<EnsureValuesAreNonEmpty<GroupByPropRaw<T, Prop>>>\n    : never;\n\n// For each possible value of the prop we filter the input tuple with the prop\n// assigned to the value, e.g. `{ type: \"cat\" }`\ntype GroupByPropRaw<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = {\n  [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;\n};\n\n// We can only group by props that only have values that could be used to key\n// an object (i.e. PropertyKey), or if they are undefined (which would filter\n// them out of the grouping).\ntype GroupableProps<T extends IterableContainer> = ConditionalKeys<\n  ItemsSuperObject<T>,\n  PropertyKey | undefined\n>;\n\n// The union of all possible values that the prop could have within the tuple.\ntype AllPropValues<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;\n\n// Creates a singular object type that all items in the tuple would extend. This\n// provides us a way to check, for each prop, what are all values it would\n// have within the tuple. We use this to map which props are candidates for\n// grouping, and when a prop is selected, the full list of values that would\n// exist in the output. For example:\n// `{ a: number, b: \"cat\", c: string } | { b: \"dog\", c: Date }` is groupable\n// by 'a' and 'b', but not 'c', and when selecting by 'b', the output would\n// have a prop for \"cat\" and a prop for \"dog\".\ntype ItemsSuperObject<T extends IterableContainer> = AllUnionFields<\n  // If the input tuple contains optional elements they would add `undefined` to\n  // T[number] (and could technically show up in the array itself). Because\n  // undefined breaks AllUnionFields we need to remove it from the union. This\n  // is OK because we handle this in the implementation too.\n  Exclude<T[number], undefined>\n>;\n\n// When the input array is empty the constructed result type would be `{}`\n// because our mapped type would never run; but this doesn't represent the\n// semantics of the return value for that case, because it effectively means\n// \"any object\" and not \"empty object\". This can happen in 2 situations:\n// A union of tuples where one of the tuples doesn't have any item with the\n// groupable prop, or when the groupable prop has a value of `undefined` for\n// all items. The former is extra problematic because it would add `| {}` to the\n// result type which effectively cancels out all other parts of the union.\ntype FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n// Group by can never return an empty tuple but our filtered arrays might not\n// represent that. We need to reshape the tuples so that they always have at\n// least one item in them.\ntype EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>>\n  = Simplify<\n    Omit<T, PossiblyEmptyArrayKeys<T>>\n    & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>\n  >;\n\n// Go over the keys the object and return those that their value can accept an\n// empty array.\ntype PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>>\n  = keyof T extends infer Key extends unknown\n    ? Key extends keyof T\n      ? IsNonEmptyArray<T[Key]> extends true\n        ? never\n        : Key\n      : never\n    : never;\n\n// An array is non-empty if any of the fixed parts are non-empty.\ntype IsNonEmptyArray<T extends IterableContainer>\n  = IsNonEmptyFixedTuple<TupleParts<T>['required']> extends true\n    ? true\n    : IsNonEmptyFixedTuple<TupleParts<T>['suffix']> extends true\n      ? true\n      : false;\n\n// A fixed tuple (one without optional or a rest element in it) is non-empty if\n// we can't extract the empty tuple from it.\ntype IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;\n\n// We coerce the arbitrary array values to have a prefix of at least one item.\ntype CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = {\n  [P in keyof T]: ArrayRequiredPrefix<T[P], 1>;\n};\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param data - The items to group.\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(data, prop)\n * @example\n *    const result = groupByProp(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      'a',\n *    );\n * @dataFirst\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop>;\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param prop - The property name to group by.\n * @signature\n *    groupByProp(prop)(data);\n * @example\n *    const result = pipe(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      groupByProp('a'),\n *    );\n * @dataLast\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(prop: Prop): (data: T) => GroupByProp<T, Prop>;\n\nexport function groupByProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByPropImplementation, args);\n}\n\nfunction groupByPropImplementation<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop> {\n  const output: BoundedPartial<Record<AllPropValues<T, Prop>, Array<T[number]>>>\n    = Object.create(null);\n\n  for (const item of data) {\n    const key = item?.[prop];\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop\n      // directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an\n        // empty array and falling through to a unified the push. It is also\n        // more performant to mutate the existing object over using spread to\n        // continually create new objects on every unique key.\n        // @ts-expect-error [ts7053] -- For the same reasons as mentioned above, TypeScript isn't inferring `key` correctly, and therefore is erroring when trying to access the output object using it.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array instead\n        // of creating a new array via spreading every time we add an item to\n        // it (e.g., `[...current, item]`).\n        // @ts-expect-error [ts2339] -- And again here `items` is still `never`.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g.\n  // `{}`). Without this none of the built-in object methods like `toString`\n  // would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  // @ts-expect-error [ts2322] -- This is fine! We use a broader type for output while we build it because it more accurately represents the shape of the object *while it is being built*. TypeScript can't tell that we finished building the object so can't ensure that output matches the expected output at this point.\n  return output;\n}\n"],"mappings":"mCAqLA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAGP,EAAS,EAAkC,CAC3C,IAAM,EACF,OAAO,OAAO,IAAI,EAEtB,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAM,IAAO,GACnB,GAAI,IAAQ,IAAA,GAAW,CAGrB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAMZ,EAAO,GAAO,CAAC,CAAI,EAMnB,EAAM,KAAK,CAAI,CAEnB,CACF,CAQA,OAHA,OAAO,eAAe,EAAQ,OAAO,SAAS,EAGvC,CACT"}

package/dist/group-by.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=Object.create(null);for(let r=0;r<e.length;r++){let i=e[r],a=t(i,r,e);if(a!==void 0){let e=n[a];e===void 0?n[a]=[i]:e.push(i)}}return Object.setPrototypeOf(n,Object.prototype),n}exports.groupBy=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){let n=Object.create(null);for(let r=0;r<e.length;r++){let i=e[r],a=t(i,r,e);if(a!==void 0){let e=n[a];e===void 0?n[a]=[i]:e.push(i)}}return Object.setPrototypeOf(n,Object.prototype),n}exports.groupBy=t;
 //# sourceMappingURL=group-by.cjs.map

package/dist/group-by.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"group-by.cjs","names":["curry"],"sources":["../src/group-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { curry } from './curry';\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param data - The items to group.\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(data, callbackfn)\n * @example\n *    groupBy([{a: 'cat'}, {a: 'dog'}] as const, prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}\n * @dataFirst\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(callbackfn)(data);\n * @example\n *    pipe(\n *      [{a: 'cat'}, {a: 'dog'}] as const,\n *      groupBy(prop('a')),\n *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    pipe(\n *      [0, 1],\n *      groupBy(x => x % 2 === 0 ? 'even' : undefined),\n *    ); // => {even: [0]}\n * @dataLast\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\nexport function groupBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByImplementation, args);\n}\n\nfunction groupByImplementation<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>> {\n  const output: BoundedPartial<Record<Key, NonEmptyArray<T>>>\n    = Object.create(null);\n\n  for (let index = 0; index < data.length; index++) {\n    // Accessing the object directly instead of via an iterator on the `entries` showed significant performance benefits while benchmarking.\n    const item = data[index];\n\n    // @ts-expect-error [ts2345] -- TypeScript is not able to infer that the index wouldn't overflow the array and that it shouldn't add `undefined` to the type. We don't want to use the `!` operator here because it's semantics are different because it changes the type of `item` to `NonNullable<T>` which is inaccurate because T itself could have `undefined` as a valid value.\n    const key = callbackfn(item, index, data);\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an empty array and falling through to a unified the push. It is also more performant to mutate the existing object over using spread to continually create new objects on every unique key.\n        // @ts-expect-error [ts2322] -- In addition to the typing issue we have for `item`, this line also creates a typing issue for the whole object, as TypeScript is having a hard time inferring what values could be adding to the object.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array over continually creating a new array every time we add an item to it.\n        // @ts-expect-error [ts2345] -- See comment above about the effective typing for `item` here.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g. `{}`). Without this none of the built-in object methods like `toString` would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  return output;\n}\n"],"mappings":"kGAwEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAAgE,EAAwB,EAAiI,CAChO,IAAM,EACF,OAAO,OAAO,KAAK,CAEvB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,OAAQ,IAAS,CAEhD,IAAM,EAAO,EAAK,GAGZ,EAAM,EAAW,EAAM,EAAO,EAAK,CACzC,GAAI,IAAQ,IAAA,GAAW,CAErB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAGZ,EAAO,GAAO,CAAC,EAAK,CAIpB,EAAM,KAAK,EAAK,EAQtB,OAFA,OAAO,eAAe,EAAQ,OAAO,UAAU,CAExC"}
+{"version":3,"file":"group-by.cjs","names":["curry"],"sources":["../src/group-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { curry } from './curry';\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param data - The items to group.\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(data, callbackfn)\n * @example\n *    groupBy([{a: 'cat'}, {a: 'dog'}] as const, prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}\n * @dataFirst\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(callbackfn)(data);\n * @example\n *    pipe(\n *      [{a: 'cat'}, {a: 'dog'}] as const,\n *      groupBy(prop('a')),\n *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    pipe(\n *      [0, 1],\n *      groupBy(x => x % 2 === 0 ? 'even' : undefined),\n *    ); // => {even: [0]}\n * @dataLast\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\nexport function groupBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByImplementation, args);\n}\n\nfunction groupByImplementation<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>> {\n  const output: BoundedPartial<Record<Key, NonEmptyArray<T>>>\n    = Object.create(null);\n\n  for (let index = 0; index < data.length; index++) {\n    // Accessing the object directly instead of via an iterator on the `entries` showed significant performance benefits while benchmarking.\n    const item = data[index];\n\n    // @ts-expect-error [ts2345] -- TypeScript is not able to infer that the index wouldn't overflow the array and that it shouldn't add `undefined` to the type. We don't want to use the `!` operator here because it's semantics are different because it changes the type of `item` to `NonNullable<T>` which is inaccurate because T itself could have `undefined` as a valid value.\n    const key = callbackfn(item, index, data);\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an empty array and falling through to a unified the push. It is also more performant to mutate the existing object over using spread to continually create new objects on every unique key.\n        // @ts-expect-error [ts2322] -- In addition to the typing issue we have for `item`, this line also creates a typing issue for the whole object, as TypeScript is having a hard time inferring what values could be adding to the object.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array over continually creating a new array every time we add an item to it.\n        // @ts-expect-error [ts2345] -- See comment above about the effective typing for `item` here.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g. `{}`). Without this none of the built-in object methods like `toString` would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  return output;\n}\n"],"mappings":"kGAwEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EAAgE,EAAwB,EAAiI,CAChO,IAAM,EACF,OAAO,OAAO,IAAI,EAEtB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,OAAQ,IAAS,CAEhD,IAAM,EAAO,EAAK,GAGZ,EAAM,EAAW,EAAM,EAAO,CAAI,EACxC,GAAI,IAAQ,IAAA,GAAW,CAErB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAGZ,EAAO,GAAO,CAAC,CAAI,EAInB,EAAM,KAAK,CAAI,CAEnB,CACF,CAKA,OAFA,OAAO,eAAe,EAAQ,OAAO,SAAS,EAEvC,CACT"}

package/dist/group-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"group-by.js","names":[],"sources":["../src/group-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { curry } from './curry';\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param data - The items to group.\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(data, callbackfn)\n * @example\n *    groupBy([{a: 'cat'}, {a: 'dog'}] as const, prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}\n * @dataFirst\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(callbackfn)(data);\n * @example\n *    pipe(\n *      [{a: 'cat'}, {a: 'dog'}] as const,\n *      groupBy(prop('a')),\n *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    pipe(\n *      [0, 1],\n *      groupBy(x => x % 2 === 0 ? 'even' : undefined),\n *    ); // => {even: [0]}\n * @dataLast\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\nexport function groupBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByImplementation, args);\n}\n\nfunction groupByImplementation<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>> {\n  const output: BoundedPartial<Record<Key, NonEmptyArray<T>>>\n    = Object.create(null);\n\n  for (let index = 0; index < data.length; index++) {\n    // Accessing the object directly instead of via an iterator on the `entries` showed significant performance benefits while benchmarking.\n    const item = data[index];\n\n    // @ts-expect-error [ts2345] -- TypeScript is not able to infer that the index wouldn't overflow the array and that it shouldn't add `undefined` to the type. We don't want to use the `!` operator here because it's semantics are different because it changes the type of `item` to `NonNullable<T>` which is inaccurate because T itself could have `undefined` as a valid value.\n    const key = callbackfn(item, index, data);\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an empty array and falling through to a unified the push. It is also more performant to mutate the existing object over using spread to continually create new objects on every unique key.\n        // @ts-expect-error [ts2322] -- In addition to the typing issue we have for `item`, this line also creates a typing issue for the whole object, as TypeScript is having a hard time inferring what values could be adding to the object.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array over continually creating a new array every time we add an item to it.\n        // @ts-expect-error [ts2345] -- See comment above about the effective typing for `item` here.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g. `{}`). Without this none of the built-in object methods like `toString` would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  return output;\n}\n"],"mappings":"mCAwEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAgE,EAAwB,EAAiI,CAChO,IAAM,EACF,OAAO,OAAO,KAAK,CAEvB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,OAAQ,IAAS,CAEhD,IAAM,EAAO,EAAK,GAGZ,EAAM,EAAW,EAAM,EAAO,EAAK,CACzC,GAAI,IAAQ,IAAA,GAAW,CAErB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAGZ,EAAO,GAAO,CAAC,EAAK,CAIpB,EAAM,KAAK,EAAK,EAQtB,OAFA,OAAO,eAAe,EAAQ,OAAO,UAAU,CAExC"}
+{"version":3,"file":"group-by.js","names":[],"sources":["../src/group-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { curry } from './curry';\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param data - The items to group.\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(data, callbackfn)\n * @example\n *    groupBy([{a: 'cat'}, {a: 'dog'}] as const, prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}\n * @dataFirst\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\n/**\n * Groups the elements of a given iterable according to the string values\n * returned by a provided callback function. The returned object has separate\n * properties for each group, containing arrays with the elements in the group.\n * Unlike the built in `Object.groupBy` this function also allows the callback to\n * return `undefined` in order to exclude the item from being added to any\n * group.\n *\n * If you are grouping objects by a property of theirs (e.g.\n * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)\n * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,\n * as it would provide better typing.\n *\n * @param callbackfn - A function to execute for each element in the iterable.\n * It should return a value indicating the group of the current element, or\n * `undefined` when the item should be excluded from any group.\n * @returns An object with properties for all groups, each assigned to an array\n * containing the elements of the associated group.\n * @signature\n *    groupBy(callbackfn)(data);\n * @example\n *    pipe(\n *      [{a: 'cat'}, {a: 'dog'}] as const,\n *      groupBy(prop('a')),\n *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    pipe(\n *      [0, 1],\n *      groupBy(x => x % 2 === 0 ? 'even' : undefined),\n *    ); // => {even: [0]}\n * @dataLast\n * @category Array\n */\nexport function groupBy<T, Key extends PropertyKey = PropertyKey>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined,\n): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;\n\nexport function groupBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByImplementation, args);\n}\n\nfunction groupByImplementation<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>> {\n  const output: BoundedPartial<Record<Key, NonEmptyArray<T>>>\n    = Object.create(null);\n\n  for (let index = 0; index < data.length; index++) {\n    // Accessing the object directly instead of via an iterator on the `entries` showed significant performance benefits while benchmarking.\n    const item = data[index];\n\n    // @ts-expect-error [ts2345] -- TypeScript is not able to infer that the index wouldn't overflow the array and that it shouldn't add `undefined` to the type. We don't want to use the `!` operator here because it's semantics are different because it changes the type of `item` to `NonNullable<T>` which is inaccurate because T itself could have `undefined` as a valid value.\n    const key = callbackfn(item, index, data);\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop directly without needing to check existence or types.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an empty array and falling through to a unified the push. It is also more performant to mutate the existing object over using spread to continually create new objects on every unique key.\n        // @ts-expect-error [ts2322] -- In addition to the typing issue we have for `item`, this line also creates a typing issue for the whole object, as TypeScript is having a hard time inferring what values could be adding to the object.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array over continually creating a new array every time we add an item to it.\n        // @ts-expect-error [ts2345] -- See comment above about the effective typing for `item` here.\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g. `{}`). Without this none of the built-in object methods like `toString` would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  return output;\n}\n"],"mappings":"mCAwEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,CAAI,CAC1C,CAEA,SAAS,EAAgE,EAAwB,EAAiI,CAChO,IAAM,EACF,OAAO,OAAO,IAAI,EAEtB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,OAAQ,IAAS,CAEhD,IAAM,EAAO,EAAK,GAGZ,EAAM,EAAW,EAAM,EAAO,CAAI,EACxC,GAAI,IAAQ,IAAA,GAAW,CAErB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAGZ,EAAO,GAAO,CAAC,CAAI,EAInB,EAAM,KAAK,CAAI,CAEnB,CACF,CAKA,OAFA,OAAO,eAAe,EAAQ,OAAO,SAAS,EAEvC,CACT"}

package/dist/has-at-least.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e.length>=t}exports.hasAtLeast=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return e.length>=t}exports.hasAtLeast=t;
 //# sourceMappingURL=has-at-least.cjs.map

package/dist/has-at-least.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-at-least.cjs","names":["curry"],"sources":["../src/has-at-least.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param data - The input array.\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(data, minimum)\n * @example\n *   hasAtLeast([], 4); // => false\n *\n *   const data: number[] = [1,2,3,4];\n *   hasAtLeast(data, 1); // => true\n *   data[0]; // 1, with type `number`\n * @dataFirst\n * @category Array\n */\nexport function hasAtLeast<T extends IterableContainer, N extends number>(\n  data: IterableContainer | T,\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(data: IterableContainer, minimum: number): boolean;\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(minimum)(data)\n * @example\n *   pipe([], hasAtLeast(4)); // => false\n *\n *   const data = [[1,2], [3], [4,5]];\n *   pipe(\n *     data,\n *     filter(hasAtLeast(2)),\n *     map(([, second]) => second),\n *   ); // => [2,5], with type `number[]`\n * @dataLast\n * @category Array\n */\nexport function hasAtLeast<N extends number>(\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): <T extends IterableContainer>(\n  data: IterableContainer | T,\n) => data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(\n  minimum: number,\n): (data: IterableContainer) => boolean;\n\nexport function hasAtLeast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasAtLeastImplementation, args);\n}\n\nfunction hasAtLeastImplementation(data: IterableContainer, minimum: number): boolean {\n  return data.length >= minimum;\n}\n"],"mappings":"kGAkEA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,SAAS,EAAyB,EAAyB,EAA0B,CACnF,OAAO,EAAK,QAAU"}
+{"version":3,"file":"has-at-least.cjs","names":["curry"],"sources":["../src/has-at-least.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param data - The input array.\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(data, minimum)\n * @example\n *   hasAtLeast([], 4); // => false\n *\n *   const data: number[] = [1,2,3,4];\n *   hasAtLeast(data, 1); // => true\n *   data[0]; // 1, with type `number`\n * @dataFirst\n * @category Array\n */\nexport function hasAtLeast<T extends IterableContainer, N extends number>(\n  data: IterableContainer | T,\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(data: IterableContainer, minimum: number): boolean;\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(minimum)(data)\n * @example\n *   pipe([], hasAtLeast(4)); // => false\n *\n *   const data = [[1,2], [3], [4,5]];\n *   pipe(\n *     data,\n *     filter(hasAtLeast(2)),\n *     map(([, second]) => second),\n *   ); // => [2,5], with type `number[]`\n * @dataLast\n * @category Array\n */\nexport function hasAtLeast<N extends number>(\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): <T extends IterableContainer>(\n  data: IterableContainer | T,\n) => data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(\n  minimum: number,\n): (data: IterableContainer) => boolean;\n\nexport function hasAtLeast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasAtLeastImplementation, args);\n}\n\nfunction hasAtLeastImplementation(data: IterableContainer, minimum: number): boolean {\n  return data.length >= minimum;\n}\n"],"mappings":"kGAkEA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,CAAI,CAC7C,CAEA,SAAS,EAAyB,EAAyB,EAA0B,CACnF,OAAO,EAAK,QAAU,CACxB"}

package/dist/has-at-least.js.map

@@ -1 +1 @@
-{"version":3,"file":"has-at-least.js","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param data - The input array.\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(data, minimum)\n * @example\n *   hasAtLeast([], 4); // => false\n *\n *   const data: number[] = [1,2,3,4];\n *   hasAtLeast(data, 1); // => true\n *   data[0]; // 1, with type `number`\n * @dataFirst\n * @category Array\n */\nexport function hasAtLeast<T extends IterableContainer, N extends number>(\n  data: IterableContainer | T,\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(data: IterableContainer, minimum: number): boolean;\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(minimum)(data)\n * @example\n *   pipe([], hasAtLeast(4)); // => false\n *\n *   const data = [[1,2], [3], [4,5]];\n *   pipe(\n *     data,\n *     filter(hasAtLeast(2)),\n *     map(([, second]) => second),\n *   ); // => [2,5], with type `number[]`\n * @dataLast\n * @category Array\n */\nexport function hasAtLeast<N extends number>(\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): <T extends IterableContainer>(\n  data: IterableContainer | T,\n) => data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(\n  minimum: number,\n): (data: IterableContainer) => boolean;\n\nexport function hasAtLeast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasAtLeastImplementation, args);\n}\n\nfunction hasAtLeastImplementation(data: IterableContainer, minimum: number): boolean {\n  return data.length >= minimum;\n}\n"],"mappings":"mCAkEA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EAAyB,EAAyB,EAA0B,CACnF,OAAO,EAAK,QAAU"}
+{"version":3,"file":"has-at-least.js","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param data - The input array.\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(data, minimum)\n * @example\n *   hasAtLeast([], 4); // => false\n *\n *   const data: number[] = [1,2,3,4];\n *   hasAtLeast(data, 1); // => true\n *   data[0]; // 1, with type `number`\n * @dataFirst\n * @category Array\n */\nexport function hasAtLeast<T extends IterableContainer, N extends number>(\n  data: IterableContainer | T,\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(data: IterableContainer, minimum: number): boolean;\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   hasAtLeast(minimum)(data)\n * @example\n *   pipe([], hasAtLeast(4)); // => false\n *\n *   const data = [[1,2], [3], [4,5]];\n *   pipe(\n *     data,\n *     filter(hasAtLeast(2)),\n *     map(([, second]) => second),\n *   ); // => [2,5], with type `number[]`\n * @dataLast\n * @category Array\n */\nexport function hasAtLeast<N extends number>(\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): <T extends IterableContainer>(\n  data: IterableContainer | T,\n) => data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(\n  minimum: number,\n): (data: IterableContainer) => boolean;\n\nexport function hasAtLeast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasAtLeastImplementation, args);\n}\n\nfunction hasAtLeastImplementation(data: IterableContainer, minimum: number): boolean {\n  return data.length >= minimum;\n}\n"],"mappings":"mCAkEA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,CAAI,CAC7C,CAEA,SAAS,EAAyB,EAAyB,EAA0B,CACnF,OAAO,EAAK,QAAU,CACxB"}

package/dist/has-prop.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return Object.hasOwn(e,t)}exports.hasProp=t;
+//# sourceMappingURL=has-prop.cjs.map