@vinicunca/perkakas 1.9.0 → 1.12.0

package/dist/funnel-CEbURcmp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"funnel-CEbURcmp.js","names":["burstTimeoutId: ReturnType<typeof setTimeout> | undefined","intervalTimeoutId: ReturnType<typeof setTimeout> | undefined","preparedData: R | undefined","burstStartTimestamp: number | undefined"],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\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.\n */\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/**\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.\n */\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 *   P.funnel(callback, options);\n * @example\n *   const debouncer = P.funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = P.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  /**\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   */\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  /**\n   * Until invoked, all calls are reduced into a single value that would be sent\n   * to the executor on invocation.\n   */\n  let preparedData: R | undefined;\n\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   */\n  let burstStartTimestamp: number | undefined;\n\n  function 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    // eslint-disable-next-line sonar/different-types-comparison\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    /**\n     * When called via a timeout the timeout is already cleared, but when called\n     * via `flush` we need to manually clear it.\n     */\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      /**\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       */\n      return;\n    }\n\n    invoke();\n  };\n\n  function handleBurstEnd(): void {\n    /**\n     * When called via a timeout the timeout is already cleared, but when called\n     * via `flush` we need to manually clear it.\n     */\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      /**\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       */\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      /**\n       * We act based on the initial state of the timeouts before the call is\n       * handled and causes the timeouts to change.\n       */\n      const wasIdle = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        /**\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         */\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\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         */\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                /**\n                 * We need to account for the time already spent so that we\n                 * don't wait longer than the maxDelay.\n                 */\n                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":"AAUA,MAAM,EAAsB,OAAO,qBAAqB,CAClD,MAA0B,EA0JhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAMd,IAAIA,EACAC,EAMAC,EAMAC,EAEJ,SAAS,GAAe,CACtB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAGX,IAAU,EAIZ,GAAU,CAEV,EAAS,EAAM,CAGb,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,EAAS,GAI/D,SAAS,GAA0B,CAKjC,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IASvB,GAAQ,CAGV,SAAS,GAAuB,CAK9B,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAS1B,GAAQ,CAGV,MAAO,CACL,MAAO,GAAG,IAAS,CAKjB,IAAM,EAAU,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAEtE,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,EAAK,EAG3C,MAAmB,IAAA,IAAa,CAAC,GAQrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAMA,aAAa,EAAe,CAE5B,IAAM,EAAM,KAAK,KAAK,CAEtB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAKpB,GAAsB,EAAM,GAC7B,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"}

package/dist/funnel-CL-QFpGk.cjs

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

package/dist/funnel-CMyhp3Kv.d.ts

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

package/dist/funnel-CMyhp3Kv.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"funnel-CMyhp3Kv.d.ts","names":[],"sources":["../src/funnel.ts"],"sourcesContent":[],"mappings":";;;KAaK,2BAA2B;mCACG,0BAA0B,SAAS;AAdnB,CAAA,GAe/C,mBAFc;;;;;;KASb,mBAAA,GAPD,CAAA;EAAmB,SAAA,SAAA,CAAA,EAAA,KAAA;AAAA,CAAA,GAOlB,CAAA,CAAA;EAoBA,SAAA,QAAa,EAAA,MAAA;AAAQ,CAAA,GAlBe,iBAoBzB,CAAA;EAAA,SAAA,gBAAA,EAAA,MAAA;WAAc,kBAAA,EAAA,MAAA;;EAQC,SAAA,gBAAA,CAAA,EAAA,MAAA;EAiHf,SAAM,kBAAA,CAAA,EAAA,MAAA;EAAA,SAAA,QAAA,CAAA,EAAA,KAAA;;WACH,SAAA,EAAA,OAAA,GAAA,MAAA;WAEf,gBAAA,CAAA,EAAA,MAAA;WACA,kBAAA,CAAA,EAAA,MAAA;WACA,QAAA,CAAA,EAAA,MAAA;;KAhIC,aAAA,GAAgB,KAkIjB,CAAA,GAAA,CAAA;UAhIM,MAiIS,CAAA,aAjIW,aAiIX,GAAA,EAAA,CAAA,CAAA;;;;;;;2BAzHQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiHX,oBAAoB,gDACjB;;;;;;GAOd,cAAc,MAAM,KACtB,OAAO"}

package/dist/funnel-DRrT4WPx.d.cts

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

package/dist/funnel-DRrT4WPx.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"funnel-DRrT4WPx.d.cts","names":[],"sources":["../src/funnel.ts"],"sourcesContent":[],"mappings":";;;KAaK,2BAA2B;mCACG,0BAA0B,SAAS;AAdnB,CAAA,GAe/C,mBAFc;;;;;;KASb,mBAAA,GAPD,CAAA;EAAmB,SAAA,SAAA,CAAA,EAAA,KAAA;AAAA,CAAA,GAOlB,CAAA,CAAA;EAoBA,SAAA,QAAa,EAAA,MAAA;AAAQ,CAAA,GAlBe,iBAoBzB,CAAA;EAAA,SAAA,gBAAA,EAAA,MAAA;WAAc,kBAAA,EAAA,MAAA;;EAQC,SAAA,gBAAA,CAAA,EAAA,MAAA;EAiHf,SAAM,kBAAA,CAAA,EAAA,MAAA;EAAA,SAAA,QAAA,CAAA,EAAA,KAAA;;WACH,SAAA,EAAA,OAAA,GAAA,MAAA;WAEf,gBAAA,CAAA,EAAA,MAAA;WACA,kBAAA,CAAA,EAAA,MAAA;WACA,QAAA,CAAA,EAAA,MAAA;;KAhIC,aAAA,GAAgB,KAkIjB,CAAA,GAAA,CAAA;UAhIM,MAiIS,CAAA,aAjIW,aAiIX,GAAA,EAAA,CAAA,CAAA;;;;;;;2BAzHQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiHX,oBAAoB,gDACjB;;;;;;GAOd,cAAc,MAAM,KACtB,OAAO"}

package/dist/group-by-057Glgkg.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.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}Object.defineProperty(exports,`groupBy`,{enumerable:!0,get:function(){return t}});

package/dist/group-by-8exEDbij.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(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}export{t as groupBy};
-//# sourceMappingURL=group-by-8exEDbij.js.map

package/dist/group-by-8exEDbij.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"group-by-8exEDbij.js","names":["output: BoundedPartial<Record<Key, NonEmptyArray<T>>>"],"sources":["../src/group-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\n\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 *    P.groupBy(data, callbackfn)\n * @example\n *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    P.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: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => 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 *    P.groupBy(callbackfn)(data);\n * @example\n *    P.pipe(\n *      [{a: 'cat'}, {a: 'dog'}] as const,\n *      P.groupBy(P.prop('a')),\n *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}\n *    P.pipe(\n *      [0, 1],\n *      P.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: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => 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>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => Key | undefined,\n): BoundedPartial<Record<Key, NonEmptyArray<T>>> {\n  const output: BoundedPartial<Record<Key, NonEmptyArray<T>>> = 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":"4CAiFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAK+C,CAC/C,IAAMA,EAAwD,OAAO,OAAO,KAAK,CAEjF,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"}

package/dist/group-by-DDS1NPHf.d.cts

@@ -1,69 +0,0 @@
-import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
-import { BoundedPartial } from "./bounded-partial-A89bt7Kj.cjs";
-
-//#region src/group-by.d.ts
-
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- * If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param data - The items to group.
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(data, callbackfn)
- * @example
- *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
- * @dataFirst
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- *  If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(callbackfn)(data);
- * @example
- *    P.pipe(
- *      [{a: 'cat'}, {a: 'dog'}] as const,
- *      P.groupBy(P.prop('a')),
- *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.pipe(
- *      [0, 1],
- *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
- *    ); // => {even: [0]}
- * @dataLast
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-//#endregion
-export { groupBy };
-//# sourceMappingURL=group-by-DDS1NPHf.d.cts.map

package/dist/group-by-DDS1NPHf.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"group-by-DDS1NPHf.d.cts","names":[],"sources":["../src/group-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgCA;;;;;;;;;;;;;;;;AAyCA;;;;;;;;;AAMW,iBA/CK,OA+CL,CAAA,CAAA,EAAA,YA/C4B,WA+C5B,GA/C0C,WA+C1C,CAAA,CAAA,IAAA,EA9CH,aA8CG,CA9CW,CA8CX,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA5CA,CA4CA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA1CD,aA0CC,CA1Ca,CA0Cb,CAAA,EAAA,GAzCJ,GAyCI,GAAA,SAAA,CAAA,EAxCR,cAwCQ,CAxCO,MAwCP,CAxCc,GAwCd,EAxCmB,aAwCnB,CAxCiC,CAwCjC,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBANK,uBAAuB,cAAc,iCAE1C,wBAED,cAAc,OACjB,0BACI,cAAc,OAAO,eAAe,OAAO,KAAK,cAAc"}

package/dist/group-by-DXW8niUS.d.ts

@@ -1,69 +0,0 @@
-import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.js";
-import { BoundedPartial } from "./bounded-partial-DfemQln9.js";
-
-//#region src/group-by.d.ts
-
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- * If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param data - The items to group.
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(data, callbackfn)
- * @example
- *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
- * @dataFirst
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- *  If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(callbackfn)(data);
- * @example
- *    P.pipe(
- *      [{a: 'cat'}, {a: 'dog'}] as const,
- *      P.groupBy(P.prop('a')),
- *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.pipe(
- *      [0, 1],
- *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
- *    ); // => {even: [0]}
- * @dataLast
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-//#endregion
-export { groupBy };
-//# sourceMappingURL=group-by-DXW8niUS.d.ts.map

package/dist/group-by-DXW8niUS.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"group-by-DXW8niUS.d.ts","names":[],"sources":["../src/group-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgCA;;;;;;;;;;;;;;;;AAyCA;;;;;;;;;AAMW,iBA/CK,OA+CL,CAAA,CAAA,EAAA,YA/C4B,WA+C5B,GA/C0C,WA+C1C,CAAA,CAAA,IAAA,EA9CH,aA8CG,CA9CW,CA8CX,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA5CA,CA4CA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA1CD,aA0CC,CA1Ca,CA0Cb,CAAA,EAAA,GAzCJ,GAyCI,GAAA,SAAA,CAAA,EAxCR,cAwCQ,CAxCO,MAwCP,CAxCc,GAwCd,EAxCmB,aAwCnB,CAxCiC,CAwCjC,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBANK,uBAAuB,cAAc,iCAE1C,wBAED,cAAc,OACjB,0BACI,cAAc,OAAO,eAAe,OAAO,KAAK,cAAc"}

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

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.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}Object.defineProperty(exports,`groupByProp`,{enumerable:!0,get:function(){return t}});

package/dist/group-by-prop-CcSzCSuu.d.cts

@@ -1,89 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
-import { BoundedPartial } from "./bounded-partial-A89bt7Kj.cjs";
-import { FilteredArray } from "./filtered-array-DQcAXQDD.cjs";
-import { ArrayRequiredPrefix } from "./array-required-prefix-FSH3Acx8.cjs";
-import { AllUnionFields, ConditionalKeys, EmptyObject, IsNever, Or, Simplify } from "type-fest";
-
-//#region src/group-by-prop.d.ts
-type GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>> = T extends unknown ? FixEmptyObject<EnsureValuesAreNonEmpty<GroupByPropRaw<T, Prop>>> : never;
-type GroupByPropRaw<T extends IterableContainer, Prop extends GroupableProps<T>> = { [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>> };
-type GroupableProps<T extends IterableContainer> = ConditionalKeys<ItemsSuperObject<T>, PropertyKey | undefined>;
-type AllPropValues<T extends IterableContainer, Prop extends GroupableProps<T>> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;
-type ItemsSuperObject<T extends IterableContainer> = AllUnionFields<Exclude<T[number], undefined>>;
-type FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;
-type EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>> = Simplify<Omit<T, PossiblyEmptyArrayKeys<T>> & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>>;
-type PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>> = keyof T extends infer Key extends unknown ? Key extends keyof T ? IsNonEmptyArray<T[Key]> extends true ? never : Key : never : never;
-type IsNonEmptyArray<T extends IterableContainer> = Or<IsNonEmptyFixedTuple<TupleParts<T>['required']>, IsNonEmptyFixedTuple<TupleParts<T>['suffix']>>;
-type IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;
-type CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = { [P in keyof T]: ArrayRequiredPrefix<T[P], 1> };
-/**
- * Groups the elements of an array of objects based on the values of a
- * specified property of those objects. The result would contain a property for
- * each unique value of the specific property, with it's value being the input
- * array filtered to only items that have that property set to that value.
- * For any object where the property is missing, or if it's value is
- * `undefined` the item would be filtered out.
- *
- * The grouping property is enforced at the type level to exist in at least one
- * item and to never have a value that cannot be used as an object key (e.g. it
- * must be `PropertyKey | undefined`).
- *
- * The resulting arrays are filtered with the prop and it's value as a
- * type-guard, effectively narrowing the items in each output arrays. This
- * means that when the grouping property is the discriminator of a
- * discriminated union type each output array would contain just the subtype for
- * that value.
- *
- * If you need more control over the grouping you should use `groupBy` instead.
- *
- * @param data - The items to group.
- * @param prop - The property name to group by.
- * @signature
- *    P.groupByProp(data, prop)
- * @example
- *    const result = P.groupByProp(
- *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
- *      [{ a: 'cat' }, { a: 'dog' }] as const,
- *      'a',
- *    );
- * @dataFirst
- * @category Array
- */
-declare function groupByProp<T extends IterableContainer, const Prop extends GroupableProps<T>>(data: T, prop: Prop): GroupByProp<T, Prop>;
-/**
- * Groups the elements of an array of objects based on the values of a
- * specified property of those objects. The result would contain a property for
- * each unique value of the specific property, with it's value being the input
- * array filtered to only items that have that property set to that value.
- * For any object where the property is missing, or if it's value is
- * `undefined` the item would be filtered out.
- *
- * The grouping property is enforced at the type level to exist in at least one
- * item and to never have a value that cannot be used as an object key (e.g. it
- * must be `PropertyKey | undefined`).
- *
- * The resulting arrays are filtered with the prop and it's value as a
- * type-guard, effectively narrowing the items in each output arrays. This
- * means that when the grouping property is the discriminator of a
- * discriminated union type each output array would contain just the subtype for
- * that value.
- *
- * If you need more control over the grouping you should use `groupBy` instead.
- *
- * @param prop - The property name to group by.
- * @signature
- *    P.groupByProp(prop)(data);
- * @example
- *    const result = P.pipe(
- *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
- *      [{ a: 'cat' }, { a: 'dog' }] as const,
- *      P.groupByProp('a'),
- *    );
- * @dataLast
- * @category Array
- */
-declare function groupByProp<T extends IterableContainer, const Prop extends GroupableProps<T>>(prop: Prop): (data: T) => GroupByProp<T, Prop>;
-//#endregion
-export { groupByProp };
-//# sourceMappingURL=group-by-prop-CcSzCSuu.d.cts.map

package/dist/group-by-prop-CcSzCSuu.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"group-by-prop-CcSzCSuu.d.cts","names":[],"sources":["../src/group-by-prop.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAeK,sBAAsB,gCAAgC,eAAe,MAEtE,oBACE,eAAe,wBAAwB,eAAe,GAAG;KAK1D,yBACO,gCACG,eAAe,kBAElB,aAZI,CAYU,CAZV,EAYa,IAZb,CAAA,GAYqB,aAZrB,CAYmC,CAZnC,EAYsC,MAZtC,CAY6C,IAZ7C,EAYmD,KAZnD,CAAA,CAAA,EAAA;KAkBX,cAlBsB,CAAA,UAkBG,iBAlBH,CAAA,GAkBwB,eAlBxB,CAmBzB,gBAnByB,CAmBR,CAnBQ,CAAA,EAoBzB,WApByB,GAAA,SAAA,CAAA;KAwBtB,aAxBqE,CAAA,UAyB9D,iBAzB8D,EAAA,aA0B3D,cA1B2D,CA0B5C,CA1B4C,CAAA,CAAA,GA2BtE,OA3BsE,CA2B9D,gBA3B8D,CA2B7C,CA3B6C,CAAA,CA2B1C,IA3B0C,CAAA,EA2BnC,WA3BmC,CAAA;KAqCrE,gBArCsD,CAAA,UAqC3B,iBArC2B,CAAA,GAqCN,cArCM,CA0CzD,OA1CyD,CA0CjD,CA1CiD,CAAA,MAAA,CAAA,EAAA,SAAA,CAAA,CAAA;KAqDtD,cAnDD,CAAA,CAAA,CAAA,GAmDqB,OAnDrB,CAAA,MAmDmC,CAnDnC,CAAA,SAAA,IAAA,GAmDqD,WAnDrD,GAmDmE,CAnDnE;KAwDC,uBAvDuD,CAAA,UAuDrB,MAvDqB,CAuDd,WAvDc,EAuDD,iBAvDC,CAAA,CAAA,GAwDxD,QAxDwD,CAyDxD,IAzDwD,CAyDnD,CAzDmD,EAyDhD,sBAzDgD,CAyDzB,CAzDyB,CAAA,CAAA,GA0DtD,cA1DsD,CA0DvC,qBA1DuC,CA0DjB,IA1DiB,CA0DZ,CA1DY,EA0DT,sBA1DS,CA0Dc,CA1Dd,CAAA,CAAA,CAAA,CAAA,CAAA;KA+DvD,sBA/D0D,CAAA,UA+DzB,MA/DyB,CA+DlB,WA/DkB,EA+DL,iBA/DK,CAAA,CAAA,GAAA,MAgErD,CAhEqD,SAAA,KAAA,aAAA,OAAA,GAiEzD,GAjEyD,SAAA,MAiEvC,CAjEuC,GAkEvD,eAlEuD,CAkEvC,CAlEuC,CAkErC,GAlEqC,CAAA,CAAA,SAAA,IAAA,GAAA,KAAA,GAoErD,GApEqD,GAAA,KAAA,GAAA,KAAA;KAyE1D,eAzEwC,CAAA,UAyEd,iBAzEc,CAAA,GAyEO,EAzEP,CA0E3C,oBA1E2C,CA0EtB,UA1EsB,CA0EX,CA1EW,CAAA,CAAA,UAAA,CAAA,CAAA,EA2E3C,oBA3E2C,CA2EtB,UA3EsB,CA2EX,CA3EW,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA;KAgFxC,oBAhFgB,CAAA,CAAA,CAAA,GAgFU,OAhFV,CAgFkB,OAhFlB,CAgF0B,CAhF1B,EAAA,SAAA,EAAA,CAAA,CAAA;KAmFhB,qBAnFC,CAAA,UAmF+B,MAnF/B,CAmFsC,WAnFtC,EAmFmD,iBAnFnD,CAAA,CAAA,GAAA,QAAc,MAoFN,CApFM,GAoFF,mBApFE,CAoFkB,CApFlB,CAoFoB,CApFpB,CAAA,EAAA,CAAA,CAAA,EAAA;;;;;;;;;;;;;;AAS8B;;;;;;;;AAMgB;;;;;;;;;;;AASvD;AAUU,iBAsFL,WAtFK,CAAA,UAuFT,iBAvFS,EAAA,mBAwFA,cAxFA,CAwFe,CAxFf,CAAA,CAAA,CAAA,IAAA,EAyFb,CAzFa,EAAA,IAAA,EAyFJ,IAzFI,CAAA,EAyFG,WAzFH,CAyFe,CAzFf,EAyFkB,IAzFlB,CAAA;;;;;;AAA8C;;;;;;;AAgBK;;;;;;;;;;;;;;;;;AAM5D;;;AAO8C,iBA8F1C,WA9F0C,CAAA,UA+F9C,iBA/F8C,EAAA,mBAgGrC,cAhGqC,CAgGtB,CAhGsB,CAAA,CAAA,CAAA,IAAA,EAiGlD,IAjGkD,CAAA,EAAA,CAAA,IAAA,EAiGpC,CAjGoC,EAAA,GAiG9B,WAjG8B,CAiGlB,CAjGkB,EAiGf,IAjGe,CAAA"}