@vinicunca/perkakas 1.8.0 → 1.9.0

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"from-keys-BYHfvCLR.d.ts","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":[],"mappings":";;;;;KAUK,sBAAsB,UAAU,sBAAsB,IAAI,GANc,GAMxE,KAAA;KAEA,QAFa,CAAA,UAEM,iBAFN,EAAA,CAAA,CAAA,GAE8B,CAF9B,SAAA,SAAA,EAAA,GAAA,CAAA,CAAA,GAKd,CALc,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAMZ,aANY,CAME,IANF,EAMQ,CANR,CAAA,GAMa,QANb,CAMsB,IANtB,EAM4B,CAN5B,CAAA,GAOZ,CAPY,CAAA,MAAA,CAAA,SAOM,WAPN,GAQV,cARU,CAQK,MARL,CAQY,CARZ,CAAA,MAAA,CAAA,EAQuB,CARvB,CAAA,CAAA,GAAA,KAAA;;;;;;AAA8C;;;;;;;;;;;;;;;;;;AAoChE;;AAAqD,iBAArC,QAAqC,CAAA,UAAlB,iBAAkB,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAC7C,CAD6C,EAAA,MAAA,EAAA,CAAA,IAAA,EAEpC,CAFoC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEJ,CAFI,EAAA,GAEE,CAFF,CAAA,EAGlD,QAHkD,CAGzC,QAHyC,CAGhC,CAHgC,EAG7B,CAH6B,CAAA,CAAA;;;;;;;;;;;AA4BrD;;;;;;;;;;;;;iBAAgB,mBAAmB,kBAAkB,gCACpC,gCAAgC,MAAM,WAC7C,MAAM,SAAS,SAAS,GAAG"}

package/dist/funnel-1FhwR-u9.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-1FhwR-u9.d.ts.map

package/dist/funnel-1FhwR-u9.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"funnel-1FhwR-u9.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/group-by-prop--MehVKql.d.ts

@@ -1,89 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { TupleParts } from "./tuple-parts-BxpZLJ7r.js";
-import { BoundedPartial } from "./bounded-partial-TshEjJC1.js";
-import { FilteredArray } from "./filtered-array-BGEkFwrv.js";
-import { ArrayRequiredPrefix } from "./array-required-prefix-BeSNHH4G.js";
-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--MehVKql.d.ts.map

package/dist/group-by-prop--MehVKql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"group-by-prop--MehVKql.d.ts","names":[],"sources":["../src/group-by-prop.ts"],"sourcesContent":[],"mappings":"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"}

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

@@ -1,69 +0,0 @@
-import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
-import { BoundedPartial } from "./bounded-partial-TshEjJC1.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-schxH1QR.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"group-by-schxH1QR.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/has-at-least-D1A8i5J3.d.ts

@@ -1,59 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { ArrayRequiredPrefix } from "./array-required-prefix-BeSNHH4G.js";
-import { IsNumericLiteral } from "type-fest";
-
-//#region src/has-at-least.d.ts
-
-/**
- * Checks if the given array has at least the defined number of elements. When
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param data - The input array.
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   P.hasAtLeast(data, minimum)
- * @example
- *   P.hasAtLeast([], 4); // => false
- *
- *   const data: number[] = [1,2,3,4];
- *   P.hasAtLeast(data, 1); // => true
- *   data[0]; // 1, with type `number`
- * @dataFirst
- * @category Array
- */
-declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
-declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
-/**
- * Checks if the given array has at least the defined number of elements. When
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   P.hasAtLeast(minimum)(data)
- * @example
- *   P.pipe([], P.hasAtLeast(4)); // => false
- *
- *   const data = [[1,2], [3], [4,5]];
- *   P.pipe(
- *     data,
- *     P.filter(P.hasAtLeast(2)),
- *     P.map(([, second]) => second),
- *   ); // => [2,5], with type `number[]`
- * @dataLast
- * @category Array
- */
-declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
-declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
-//#endregion
-export { hasAtLeast };
-//# sourceMappingURL=has-at-least-D1A8i5J3.d.ts.map

package/dist/has-at-least-D1A8i5J3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"has-at-least-D1A8i5J3.d.ts","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2BA;;;;;;;;;;;;AAIA;AA0BA;;;;;;;AAG4B,iBAjCZ,UAiCY,CAAA,UAjCS,iBAiCT,EAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAhCpB,iBAgCoB,GAhCA,CAgCA,EAAA,OAAA,EA/BjB,gBA+BiB,CA/BA,CA+BA,CAAA,SAAA,IAAA,GA/BkB,CA+BlB,GAAA,KAAA,CAAA,EAAA,IAAA,IA9BjB,mBA8BiB,CA9BG,CA8BH,EA9BM,CA8BN,CAAA;AACK,iBA9BjB,UAAA,CA8BiB,IAAA,EA9BA,iBA8BA,EAAA,OAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;AACjC;;;;;;;;;;;;;;;;;;;;;iBALgB,sCACL,iBAAiB,kBAAkB,uBAChC,yBACN,oBAAoB,cACf,oBAAoB,GAAG;iBACpB,UAAA,0BAEN"}

package/dist/has-sub-object-DPcKaDk7.d.ts

@@ -1,44 +0,0 @@
-import { Simplify, Tagged } from "type-fest";
-
-//#region src/has-sub-object.d.ts
-declare const HAS_SUB_OBJECT_BRAND: unique symbol;
-type HasSubObjectGuard<T, S> = Simplify<Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>>;
-type HasSubObjectObjectValue<A, B> = Partial<{ [Key in keyof A & keyof B]: A[Key] & B[Key] extends never ? B[Key] : A[Key] | B[Key] extends object ? HasSubObjectObjectValue<A[Key], B[Key]> : A[Key] & B[Key] extends object ? B[Key] : A[Key] }> & { [Key in Exclude<keyof A, keyof B> | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never };
-type HasSubObjectData<Data, SubObject, RData = Required<Data>, RSubObject = Required<SubObject>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RSubObject[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]> : RData[Key] & RSubObject[Key] extends object ? RSubObject[Key] : RData[Key] }> & { [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key] };
-type HasSubObjectSubObject<SubObject, Data, RSubObject = Required<SubObject>, RData = Required<Data>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RData[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]> : RData[Key] & RSubObject[Key] extends object ? RData[Key] : RSubObject[Key] }> & Record<Exclude<keyof SubObject, keyof Data>, never>;
-/**
- * Checks if `subObject` is a sub-object of `object`, which means for every
- * property and value in `subObject`, there's the same property in `object`
- * with an equal value. Equality is checked with `isDeepEqual`.
- *
- * @param data - The object to test.
- * @param subObject - The sub-object to test against.
- * @signature
- *    P.hasSubObject(data, subObject)
- * @example
- *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { a: 1, c: 3 }) //=> true
- *    P.hasSubObject({ a: 1, b: 2, c: 3 }, { b: 4 }) //=> false
- *    P.hasSubObject({ a: 1, b: 2, c: 3 }, {}) //=> true
- * @dataFirst
- * @category Guard
- */
-declare function hasSubObject<T extends object, S extends HasSubObjectSubObject<S, T>>(data: T, subObject: S): data is HasSubObjectGuard<T, S>;
-/**
- * Checks if `subObject` is a sub-object of `object`, which means for every
- * property and value in `subObject`, there's the same property in `object`
- * with an equal value. Equality is checked with `isDeepEqual`.
- *
- * @param subObject - The sub-object to test against.
- * @signature
- *    P.hasSubObject(subObject)(data)
- * @example
- *    P.hasSubObject({ a: 1, c: 3 })({ a: 1, b: 2, c: 3 }) //=> true
- *    P.hasSubObject({ b: 4 })({ a: 1, b: 2, c: 3 }) //=> false
- *    P.hasSubObject({})({ a: 1, b: 2, c: 3 }) //=> true
- * @dataLast
- * @category Guard
- */
-declare function hasSubObject<S extends object>(subObject: S): <T extends HasSubObjectData<T, S>>(data: T) => data is HasSubObjectGuard<T, S>;
-//#endregion
-export { hasSubObject };
-//# sourceMappingURL=has-sub-object-DPcKaDk7.d.ts.map

package/dist/has-sub-object-DPcKaDk7.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"has-sub-object-DPcKaDk7.d.ts","names":[],"sources":["../src/has-sub-object.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/human-readable-file-size-C2gHuBVX.d.ts

@@ -1,17 +0,0 @@
-//#region src/human-readable-file-size.d.ts
-/**
- * Returns human readable file size.
- *
- * @param bytes the file size in bytes
- * @param base the base (1000 or 1024)
- * @signature
- *  P.humanReadableFileSize(bytes, base)
- * @example
- *  P.humanReadableFileSize(1000); // => '1.0 kB'
- *  P.humanReadableFileSize(2097152, 1024); // => '2.0 Mib'
- * @category String
- */
-declare function humanReadableFileSize(bytes: number, base?: 1000 | 1024): string;
-//#endregion
-export { humanReadableFileSize };
-//# sourceMappingURL=human-readable-file-size-C2gHuBVX.d.ts.map

package/dist/human-readable-file-size-C2gHuBVX.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"human-readable-file-size-C2gHuBVX.d.ts","names":[],"sources":["../src/human-readable-file-size.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,qBAAA"}

package/dist/identity-BwbmOFJX.d.ts

@@ -1,22 +0,0 @@
-//#region src/identity.d.ts
-/**
- * A function that returns the first argument passed to it.
- *
- * Notice that this is a dataLast impl where the function needs to be invoked
- * to get the "do nothing" function.
- *
- * See also:
- * `doNothing` - A function that doesn't return anything.
- * `constant` - A function that ignores the input arguments and returns the same value on every invocation.
- *
- * @signature
- *    P.identity();
- * @example
- *    P.map([1,2,3], P.identity()); // => [1,2,3]
- * @category Function
- */
-declare function identity(): typeof identityImplementation;
-declare function identityImplementation<T, Args extends ReadonlyArray<unknown>>(value: T, ..._args: Args): T;
-//#endregion
-export { identity };
-//# sourceMappingURL=identity-BwbmOFJX.d.ts.map

package/dist/identity-BwbmOFJX.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"identity-BwbmOFJX.d.ts","names":[],"sources":["../src/identity.ts"],"sourcesContent":[],"mappings":";;AAgBA;AAQC;;;;;;;;;;;;;;iBARe,QAAA,CAAA,UAAmB;iBAU1B,uCAAuC,+BACvC,aAEG,OACT"}

package/dist/index-by-CJj3L6wv.d.ts

@@ -1,53 +0,0 @@
-import { BoundedPartial } from "./bounded-partial-TshEjJC1.js";
-
-//#region src/index-by.d.ts
-
-/**
- * Converts a list of objects into an object indexing the objects by the given
- * key.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param data - The array.
- * @param mapper - The indexing function.
- * @signature
- *    P.indexBy(array, fn)
- * @example
- *    P.indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}
- * @dataFirst
- * @category Array
- */
-declare function indexBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, mapper: (item: T, index: number, data: ReadonlyArray<T>) => K): BoundedPartial<Record<K, T>>;
-/**
- * Converts a list of objects into an object indexing the objects by the given
- * key.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param mapper - The indexing function.
- * @signature
- *    P.indexBy(fn)(array)
- * @example
- *    P.pipe(
- *      ['one', 'two', 'three'],
- *      P.indexBy(x => x.length)
- *    ) // => {3: 'two', 5: 'three'}
- * @dataLast
- * @category Array
- */
-declare function indexBy<T, K extends PropertyKey>(mapper: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, T>>;
-//#endregion
-export { indexBy };
-//# sourceMappingURL=index-by-CJj3L6wv.d.ts.map

package/dist/index-by-CJj3L6wv.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-by-CJj3L6wv.d.ts","names":[],"sources":["../src/index-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;;;;;;;;;;AA4BA;;;;;AACyC,iBA7BzB,OA6ByB,CAAA,CAAA,EAAA,UA7BJ,WA6BI,CAAA,CAAA,IAAA,EA5BjC,aA4BiC,CA5BnB,CA4BmB,CAAA,EAAA,MAAA,EAAA,CAAA,IAAA,EA3BxB,CA2BwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA3BA,aA2BA,CA3Bc,CA2Bd,CAAA,EAAA,GA3BqB,CA2BrB,CAAA,EA1BtC,cA0BsC,CA1BvB,MA0BuB,CA1BhB,CA0BgB,EA1Bb,CA0Ba,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;iBADzB,qBAAqB,4BACpB,wBAAwB,cAAc,OAAO,WACpD,cAAc,OAAO,eAAe,OAAO,GAAG"}

package/dist/int-range-inclusive-BSXuRjMO.d.ts

@@ -1,15 +0,0 @@
-import { IntRange } from "type-fest";
-
-//#region src/internal/types/int-range-inclusive.d.ts
-
-/**
- * Type fest offers IntClosedRange which is a similar offering, but is
- * implemented in a way which makes it inefficient when the Step size is '1'
- * (as in our case). Their implementation can cause ts(2589) errors ('Type
- * instantiation is excessively deep and possibly infinite') errors when the
- * integers are large (even when the range itself is not).
- */
-type IntRangeInclusive<From extends number, To extends number> = IntRange<From, To> | To;
-//#endregion
-export { IntRangeInclusive };
-//# sourceMappingURL=int-range-inclusive-BSXuRjMO.d.ts.map

package/dist/int-range-inclusive-BSXuRjMO.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"int-range-inclusive-BSXuRjMO.d.ts","names":[],"sources":["../src/internal/types/int-range-inclusive.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEM,KAFM,iBAEN,CAAA,aAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GADA,QACA,CADS,IACT,EADe,EACf,CAAA,GAAA,EAAA"}