@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/types/array/find-last-index.d.ts

@@ -0,0 +1,43 @@
+import type { Pred, PredIndexed } from '../utils/types';
+/**
+ * Returns the index of the last element in the array where predicate is true, and -1 otherwise.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.findLastIndex(items, fn)
+ *    P.findLastIndex.indexed(items, fn)
+ * @example
+ *    P.findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1
+ *    P.findLastIndex.indexed([1, 3, 4, 6], (n, i) => n % 2 === 1) // => 1
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function findLastIndex<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): number;
+/**
+ * Returns the index of the last element in the array where predicate is true, and -1 otherwise.
+ * @param fn the predicate
+ * @signature
+ *    P.findLastIndex(fn)(items)
+ *    P.findLastIndex.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLastIndex(n => n % 2 === 1)
+ *    ) // => 1
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLastIndex.indexed((n, i) => n % 2 === 1)
+ *    ) // => 1
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function findLastIndex<T>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => number;
+export declare namespace findLastIndex {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): number;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => number;
+}
+//# sourceMappingURL=find-last-index.d.ts.map

package/dist/types/array/find-last-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-last-index.d.ts","sourceRoot":"","sources":["../../../src/array/find-last-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAI7E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,MAAM,CAAC;AAEV;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;AAkBvC,yBAAiB,aAAa,CAAC;IAC7B,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,MAAM,CAAC;IACV,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC;CAKxC"}

package/dist/types/array/find-last.d.ts

@@ -0,0 +1,45 @@
+import type { Pred, PredIndexed } from '../utils/types';
+/**
+ * Returns the value of the last element in the array where predicate is true, and undefined
+ * otherwise.
+ * @param array the array
+ * @param fn the predicate
+ * @signature
+ *    P.findLast(items, fn)
+ *    P.findLast.indexed(items, fn)
+ * @example
+ *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
+ *    P.findLast.indexed([1, 3, 4, 6], (n, i) => n % 2 === 1) // => 3
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function findLast<T>(array: ReadonlyArray<T>, fn: Pred<T, boolean>): T | undefined;
+/**
+ * Returns the value of the last element in the array where predicate is true, and undefined
+ * otherwise.
+ * @param fn the predicate
+ * @signature
+ *    P.findLast(fn)(items)
+ *    P.findLast.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLast(n => n % 2 === 1)
+ *    ) // => 3
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLast.indexed((n, i) => n % 2 === 1)
+ *    ) // => 3
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function findLast<T = never>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+export declare namespace findLast {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+}
+//# sourceMappingURL=find-last.d.ts.map

package/dist/types/array/find-last.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-last.d.ts","sourceRoot":"","sources":["../../../src/array/find-last.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAI7E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,GAAG,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,KAAK,EAChC,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;AAkB9C,yBAAiB,QAAQ,CAAC;IACxB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,GAAG,SAAS,CAAC;IACjB,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;CAK/C"}

package/dist/types/array/find.d.ts

@@ -0,0 +1,59 @@
+import type { Pred, PredIndexed, PredIndexedOptional } from '../utils/types';
+/**
+ * Returns the value of the first element in the array where predicate is true, and undefined otherwise.
+ * @param items the array
+ * @param fn the predicate
+ * @signature
+ *    P.find(items, fn)
+ *    P.find.indexed(items, fn)
+ * @example
+ *    P.find([1, 3, 4, 6], n => n % 2 === 0) // => 4
+ *    P.find.indexed([1, 3, 4, 6], (n, i) => n % 2 === 0) // => 4
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function find<T>(items: ReadonlyArray<T>, fn: Pred<T, boolean>): T | undefined;
+/**
+ * Returns the value of the first element in the array where predicate is true, and undefined otherwise.
+ * @param fn the predicate
+ * @signature
+ *    P.find(fn)(items)
+ *    P.find.indexed(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.find(n => n % 2 === 0)
+ *    ) // => 4
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.find.indexed((n, i) => n % 2 === 0)
+ *    ) // => 4
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function find<T = never>(fn: Pred<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+export declare namespace find {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, boolean>): T | undefined;
+    function indexed<T>(fn: PredIndexed<T, boolean>): (array: ReadonlyArray<T>) => T | undefined;
+    const lazy: (<T>(fn: PredIndexedOptional<T, boolean>) => (value: T, index?: number | undefined, array?: T[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: T;
+    }) & {
+        single: true;
+    };
+    const lazyIndexed: ((fn: PredIndexedOptional<unknown, boolean>) => (value: unknown, index?: number | undefined, array?: unknown[] | undefined) => {
+        done: boolean;
+        hasNext: boolean;
+        next: unknown;
+    }) & {
+        readonly indexed: true;
+    } & {
+        single: true;
+    };
+}
+//# sourceMappingURL=find.d.ts.map

package/dist/types/array/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../src/array/find.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAM7E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,GAAG,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,IAAI,CAAC,CAAC,GAAG,KAAK,EAC5B,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;AA6B9C,yBAAiB,IAAI,CAAC;IACpB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,GAAG,SAAS,CAAC;IACjB,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAKvC,MAAM,IAAI;;;;;;KAAyB,CAAC;IAEpC,MAAM,WAAW;;;;;;;;KAAuC,CAAC;CACjE"}

package/dist/types/array/first-by.d.ts

@@ -0,0 +1,57 @@
+import type { IterableContainer, NonEmptyArray } from '../utils/types';
+import { type OrderRule } from '../utils/purry-order-rules';
+type FirstBy<T extends IterableContainer> = (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined) | T[number];
+/**
+ * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data an array of items
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending ordeP.
+ * @returns the first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(...rules)(data);
+ * @example
+ *   const max = P.pipe([1,2,3], P.firstBy([P.identity, "desc"])); // => 3;
+ *   const min = P.pipe([1,2,3], P.firstBy([1,2,3])); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
+ *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
+ * @dataLast
+ * @category Array
+ */
+export declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
+/**
+ * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining "tie-breaker" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data an array of items
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending ordeP.
+ * @returns the first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(data, ...rules);
+ * @example
+ *   const max = P.firstBy([1,2,3], [P.identity, "desc"]); // => 3;
+ *   const min = P.firstBy([1,2,3], P.identity); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
+ *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
+ * @dataFirst
+ * @category Array
+ */
+export declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
+export {};
+//# sourceMappingURL=first-by.d.ts.map

package/dist/types/array/first-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-by.d.ts","sourceRoot":"","sources":["../../../src/array/first-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,iBAAiB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExF,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,4BAA4B,CAAC;AAG7E,KAAK,OAAO,CAAC,CAAC,SAAS,iBAAiB,IACpC,CAAC,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,GACtD,KAAK,GACL,CAAC,SAAS,SAAS,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GACrD,KAAK,GACL,SAAS,CAAC,GACV,CAAC,CAAC,MAAM,CAAC,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,iBAAiB,EACjD,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,iBAAiB,EACjD,IAAI,EAAE,CAAC,EACP,GAAG,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/first.d.ts

@@ -0,0 +1,35 @@
+import type { IterableContainer } from '../utils/types';
+type FirstOut<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Last | Pre[0] : T[0] | undefined;
+/**
+ * Gets the first element of `array`.
+ * Note: In `pipe`, use `first()` form instead of `first`. Otherwise, the inferred type is lost.
+ * @param array the array
+ * @signature
+ *    P.first(array)
+ * @example
+ *    P.first([1, 2, 3]) // => 1
+ *    P.first([]) // => undefined
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.first(),
+ *      x => x + 1
+ *    ); // => 5
+ *
+ * @category Array
+ * @pipeable
+ */
+export declare function first<T extends IterableContainer>(array: Readonly<T>): FirstOut<T>;
+export declare function first<T extends IterableContainer>(): (array: Readonly<T>) => FirstOut<T>;
+export declare namespace first {
+    function lazy<T>(): (value: T) => {
+        done: boolean;
+        hasNext: boolean;
+        next: T;
+    };
+    namespace lazy {
+        const single = true;
+    }
+}
+export {};
+//# sourceMappingURL=first.d.ts.map

package/dist/types/array/first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.ts","sourceRoot":"","sources":["../../../src/array/first.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,KAAK,QAAQ,CAAC,CAAC,SAAS,iBAAiB,IAAI,CAAC,SAAS,EAAE,GACrD,SAAS,GACT,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,GAC7C,CAAC,CAAC,CAAC,CAAC,GACJ,CAAC,SAAS,SAAS,CAAC,GAAG,MAAM,GAAG,EAAE,MAAM,IAAI,CAAC,GAC3C,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,GACb,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AAEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/C,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GACjB,QAAQ,CAAC,CAAC,CAAC,CAAC;AACf,wBAAgB,KAAK,CAAC,CAAC,SAAS,iBAAiB,KAAK,CACpD,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KACf,QAAQ,CAAC,CAAC,CAAC,CAAC;AAUjB,yBAAiB,KAAK,CAAC;IACrB,SAAgB,IAAI,CAAC,CAAC,aACL,CAAC;;;;MAOjB;IACD,UAAiB,IAAI,CAAC;QACb,MAAM,MAAM,OAAO,CAAC;KAC5B;CACF"}

package/dist/types/array/flat-map-to-obj.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Map each element of an array into an object using a defined callback function and flatten the result.
+ * @param array The array to map.
+ * @param fn The mapping function, which should return an Array of key-value pairs, similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.flatMapToObj(array, fn)
+ *    P.flatMapToObj.indexed(array, fn)
+ * @example
+ *  P.flatMapToObj([1, 2, 3], (x) =>
+ *    x % 2 === 1 ? [[String(x), x]] : []
+ *  ) // => {1: 1, 3: 3}
+ *  P.flatMapToObj.indexed(['a', 'b'], (x, i) => [
+ *    [x, i],
+ *    [x + x, i + i],
+ *  ]) // => {a: 0, aa: 0, b: 1, bb: 2}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function flatMapToObj<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T) => Array<[K, V]>): Record<K, V>;
+/**
+ * Map each element of an array into an object using a defined callback function and flatten the result.
+ * @param fn The mapping function, which should return an Array of key-value pairs, similar to Object.fromEntries
+ * @returns The new mapped object.
+ * @signature
+ *    P.flatMapToObj(fn)(array)
+ *    P.flatMapToObj(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.flatMapToObj(x => (x % 2 === 1 ? [[String(x), x]] : []))
+ *    ) // => {1: 1, 3: 3}
+ *    P.pipe(
+ *      ['a', 'b'],
+ *      P.flatMapToObj.indexed((x, i) => [
+ *        [x, i],
+ *        [x + x, i + i],
+ *      ])
+ *    ) // => {a: 0, aa: 0, b: 1, bb: 2}
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function flatMapToObj<T, K extends keyof any, V>(fn: (element: T) => Array<[K, V]>): (array: ReadonlyArray<T>) => Record<K, V>;
+export declare namespace flatMapToObj {
+    function indexed<T, K extends keyof any, V>(array: ReadonlyArray<T>, fn: (element: T, index: number, array: ReadonlyArray<T>) => Array<[K, V]>): Record<K, V>;
+    function indexed<T, K extends keyof any, V>(fn: (element: T, index: number, array: ReadonlyArray<T>) => Array<[K, V]>): (array: ReadonlyArray<T>) => Record<K, V>;
+}
+//# sourceMappingURL=flat-map-to-obj.d.ts.map

package/dist/types/array/flat-map-to-obj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-map-to-obj.d.ts","sourceRoot":"","sources":["../../../src/array/flat-map-to-obj.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,EAAE,CAAC,EACpD,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAChC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,EAAE,CAAC,EACpD,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAChC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAkB7C,yBAAiB,YAAY,CAAC;IAC5B,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,EAAE,CAAC,EAC/C,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACxE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChB,SAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,EAAE,CAAC,EAC/C,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACxE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAI9C"}

package/dist/types/array/flat-map.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Map each element of an array using a defined callback function and flatten the mapped result.
+ * @param array The array to map.
+ * @param fn The function mapper.
+ * @signature
+ *    P.flatMap(array, fn)
+ * @example
+ *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
+ * @dataFirst
+ * @pipeable
+ * @category Array
+ */
+export declare function flatMap<T, K>(array: ReadonlyArray<T>, fn: (input: T) => K | ReadonlyArray<K>): Array<K>;
+/**
+ * Map each element of an array using a defined callback function and flatten the mapped result.
+ * @param fn The function mapper.
+ * @signature
+ *    P.flatMap(fn)(array)
+ * @example
+ *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
+ * @dataLast
+ * @pipeable
+ * @category Array
+ */
+export declare function flatMap<T, K>(fn: (input: T) => K | ReadonlyArray<K>): (array: ReadonlyArray<T>) => Array<K>;
+export declare namespace flatMap {
+    function lazy<T, K>(fn: (input: T) => K | ReadonlyArray<K>): (value: T) => {
+        done: boolean;
+        hasMany: boolean;
+        hasNext: boolean;
+        next: K & any[];
+    } | {
+        done: boolean;
+        hasNext: boolean;
+        next: K | readonly K[];
+        hasMany?: never;
+    };
+}
+//# sourceMappingURL=flat-map.d.ts.map

package/dist/types/array/flat-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-map.d.ts","sourceRoot":"","sources":["../../../src/array/flat-map.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GACrC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GACrC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAazC,yBAAiB,OAAO,CAAC;IACvB,SAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,WAChD,CAAC;;;;;;;;;;MAgBjB;CACF"}

package/dist/types/array/flatten-deep.d.ts

@@ -0,0 +1,26 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+type FlattenDeep<T> = T extends ReadonlyArray<infer K> ? FlattenDeep2<K> : T;
+type FlattenDeep2<T> = T extends ReadonlyArray<infer K> ? FlattenDeep3<K> : T;
+type FlattenDeep3<T> = T extends ReadonlyArray<infer K> ? FlattenDeep4<K> : T;
+type FlattenDeep4<T> = T extends ReadonlyArray<infer K> ? K : T;
+/**
+ * Recursively flattens `array`.
+ * Note: In `pipe`, use `flattenDeep()` form instead of `flattenDeep`. Otherwise, the inferred type is lost.
+ * @param items the target array
+ * @signature P.flattenDeep(array)
+ * @example
+ *    P.flattenDeep([[1, 2], [[3], [4, 5]]]) // => [1, 2, 3, 4, 5]
+ *    P.pipe(
+ *      [[1, 2], [[3], [4, 5]]],
+ *      P.flattenDeep(),
+ *    ); // => [1, 2, 3, 4, 5]
+ * @category Array
+ * @pipeable
+ */
+export declare function flattenDeep<T>(items: ReadonlyArray<T>): Array<FlattenDeep<T>>;
+export declare function flattenDeep<T>(): (items: ReadonlyArray<T>) => Array<FlattenDeep<T>>;
+export declare namespace flattenDeep {
+    function lazy(): (value: any) => LazyResult<any>;
+}
+export {};
+//# sourceMappingURL=flatten-deep.d.ts.map

package/dist/types/array/flatten-deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-deep.d.ts","sourceRoot":"","sources":["../../../src/array/flatten-deep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC7E,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC9E,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC9E,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/E,wBAAgB,WAAW,CAAC,CAAC,KAAK,CAChC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KACpB,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAyB3B,yBAAiB,WAAW,CAAC;IAC3B,SAAgB,IAAI,YACH,GAAG,KAAG,WAAW,GAAG,CAAC,CAgBrC;CACF"}

package/dist/types/array/flatten.d.ts

@@ -0,0 +1,23 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+type Flatten<T> = T extends ReadonlyArray<infer K> ? K : T;
+/**
+ * Flattens `array` a single level deep.
+ * Note: In `pipe`, use `flatten()` form instead of `flatten`. Otherwise, the inferred type is lost.
+ * @param items the target array
+ * @signature P.flatten(array)
+ * @example
+ *    P.flatten([[1, 2], [3], [4, 5]]) // => [1, 2, 3, 4, 5]
+ *    P.pipe(
+ *      [[1, 2], [3], [4, 5]],
+ *      P.flatten(),
+ *    ); // => [1, 2, 3, 4, 5]
+ * @category Array
+ * @pipeable
+ */
+export declare function flatten<T>(items: ReadonlyArray<T>): Array<Flatten<T>>;
+export declare function flatten<T>(): (items: ReadonlyArray<T>) => Array<Flatten<T>>;
+export declare namespace flatten {
+    function lazy<T>(): (next: T) => LazyResult<any>;
+}
+export {};
+//# sourceMappingURL=flatten.d.ts.map

package/dist/types/array/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../src/array/flatten.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKvD,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvE,wBAAgB,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAU7E,yBAAiB,OAAO,CAAC;IACvB,SAAgB,IAAI,CAAC,CAAC,YACN,CAAC,KAAG,WAAW,GAAG,CAAC,CAelC;CACF"}

package/dist/types/array/for-each.d.ts

@@ -0,0 +1,57 @@
+import type { LazyResult } from '../utils/reduce-lazy';
+import type { Pred, PredIndexed, PredIndexedOptional } from '../utils/types';
+/**
+ * Iterate an array using a defined callback function. The original array is returned instead of `void`.
+ * @param array The array.
+ * @param fn The callback function.
+ * @returns The original array
+ * @signature
+ *    P.forEach(array, fn)
+ *    P.forEach.indexed(array, fn)
+ * @example
+ *    P.forEach([1, 2, 3], x => {
+ *      console.log(x)
+ *    }) // => [1, 2, 3]
+ *    P.forEach.indexed([1, 2, 3], (x, i) => {
+ *      console.log(x, i)
+ *    }) // => [1, 2, 3]
+ * @dataFirst
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function forEach<T>(array: ReadonlyArray<T>, fn: Pred<T, void>): Array<T>;
+/**
+ * Iterate an array using a defined callback function. The original array is returned instead of `void`.
+ * @param fn the function mapper
+ * @signature
+ *    P.forEach(fn)(array)
+ *    P.forEach.indexed(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.forEach(x => {
+ *        console.log(x)
+ *      })
+ *    ) // => [1, 2, 3]
+ *    P.pipe(
+ *      [1, 2, 3],
+ *      P.forEach.indexed((x, i) => {
+ *        console.log(x, i)
+ *      })
+ *    ) // => [1, 2, 3]
+ * @dataLast
+ * @indexed
+ * @pipeable
+ * @category Array
+ */
+export declare function forEach<T>(fn: Pred<T, void>): (array: ReadonlyArray<T>) => Array<T>;
+export declare namespace forEach {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, void>): Array<T>;
+    function indexed<T>(fn: PredIndexed<T, void>): (array: ReadonlyArray<T>) => Array<T>;
+    const lazy: <T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>;
+    const lazyIndexed: (<T>(fn: PredIndexedOptional<T, void>) => (value: T, index?: number | undefined, array?: readonly T[] | undefined) => LazyResult<T>) & {
+        readonly indexed: true;
+    };
+}
+//# sourceMappingURL=for-each.d.ts.map

package/dist/types/array/for-each.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-each.d.ts","sourceRoot":"","sources":["../../../src/array/for-each.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAM7E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAChB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAChB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAqCzC,yBAAiB,OAAO,CAAC;IACvB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,GACvB,KAAK,CAAC,CAAC,CAAC,CAAC;IACZ,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,GACvB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;IAIlC,MAAM,IAAI,oIAAe,CAAC;IAC1B,MAAM,WAAW;;KAA6B,CAAC;CACvD"}

package/dist/types/array/group-by.d.ts

@@ -0,0 +1,36 @@
+import type { NonEmptyArray, PredIndexed } from '../utils/types';
+/**
+ * Splits a collection into sets, grouped by the result of running each value through `fn`.
+ * @param items the items to group
+ * @param fn the grouping function. When `undefined` is returned the item would
+ * be skipped and not grouped under any key.
+ * @signature
+ *    P.groupBy(array, fn)
+ *    P.groupBy.strict(array, fn)
+ * @example
+ *    P.groupBy(['one', 'two', 'three'], x => x.length) // => {3: ['one', 'two'], 5: ['three']}
+ *    P.groupBy.strict([{a: 'cat'}, {a: 'dog'}] as const, prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]} typed Partial<Record<'cat' | 'dog', NonEmptyArray<{a: 'cat' | 'dog'}>>>
+ *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
+ * @dataFirst
+ * @indexed
+ * @strict
+ * @category Array
+ */
+export declare function groupBy<T>(items: ReadonlyArray<T>, fn: (item: T) => PropertyKey | undefined): Record<PropertyKey, NonEmptyArray<T>>;
+export declare function groupBy<T>(fn: (item: T) => PropertyKey | undefined): (array: ReadonlyArray<T>) => Record<PropertyKey, NonEmptyArray<T>>;
+interface Strict {
+    <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: (item: Value) => Key | undefined): StrictOut<Value, Key>;
+    <Value, Key extends PropertyKey = PropertyKey>(fn: (item: Value) => Key | undefined): (items: ReadonlyArray<Value>) => StrictOut<Value, Key>;
+    readonly indexed: {
+        <Value, Key extends PropertyKey = PropertyKey>(fn: PredIndexed<Value, Key | undefined>): (items: ReadonlyArray<Value>) => StrictOut<Value, Key>;
+        <Value, Key extends PropertyKey = PropertyKey>(items: ReadonlyArray<Value>, fn: PredIndexed<Value, Key | undefined>): StrictOut<Value, Key>;
+    };
+}
+type StrictOut<Value, Key extends PropertyKey = PropertyKey> = string extends Key ? Record<Key, NonEmptyArray<Value>> : number extends Key ? Record<Key, NonEmptyArray<Value>> : symbol extends Key ? Record<Key, NonEmptyArray<Value>> : Partial<Record<Key, NonEmptyArray<Value>>>;
+export declare namespace groupBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, PropertyKey | undefined>): Record<string, NonEmptyArray<T>>;
+    function indexed<T>(fn: PredIndexed<T, PropertyKey | undefined>): (array: ReadonlyArray<T>) => Record<string, NonEmptyArray<T>>;
+    const strict: Strict;
+}
+export {};
+//# sourceMappingURL=group-by.d.ts.map

package/dist/types/array/group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.d.ts","sourceRoot":"","sources":["../../../src/array/group-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAItF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,GAAG,SAAS,GACvC,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAEzC,wBAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,GAAG,SAAS,GACvC,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAyCtE,UAAU,MAAM;IAEd,CAAC,KAAK,EAAE,GAAG,SAAS,WAAW,GAAG,WAAW,EAC3C,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,EAC3B,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,GAAG,GAAG,SAAS,GACnC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAGzB,CAAC,KAAK,EAAE,GAAG,SAAS,WAAW,GAAG,WAAW,EAC3C,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,GAAG,GAAG,SAAS,GACnC,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAE1D,QAAQ,CAAC,OAAO,EAAE;QAEhB,CAAC,KAAK,EAAE,GAAG,SAAS,WAAW,GAAG,WAAW,EAC3C,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,CAAC,GACtC,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAG1D,CAAC,KAAK,EAAE,GAAG,SAAS,WAAW,GAAG,WAAW,EAC3C,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,EAC3B,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,SAAS,CAAC,GACtC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;KAC1B,CAAC;CACH;AAQD,KAAK,SAAS,CAAC,KAAK,EAAE,GAAG,SAAS,WAAW,GAAG,WAAW,IAGzD,MAAM,SAAS,GAAG,GACd,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,GACjC,MAAM,SAAS,GAAG,GAChB,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,GACjC,MAAM,SAAS,GAAG,GAChB,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,GAInC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEnD,yBAAiB,OAAO,CAAC;IACvB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC,GAC1C,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC,GAC1C,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAK1D,MAAM,MAAM,EAAE,MAAgB,CAAC;CACvC"}

package/dist/types/array/has-at-least.d.ts

@@ -0,0 +1,47 @@
+import type { ReadonlyTuple } from 'type-fest';
+type ArrayMinN<T, N extends number> = number extends N ? Array<T> : N extends 0 ? Array<T> : [...ReadonlyTuple<T, N>, ...Array<T>];
+/**
+ * Checks if the given array has at least the defined number of elements, and
+ * refines the output type 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
+ * @return true if the array's length is *at least* `minimum`.
+ * @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
+ */
+export declare function hasAtLeast<T, N extends number>(data: ReadonlyArray<T>, minimum: N): data is ArrayMinN<T, N>;
+/**
+ * Checks if the given array has at least the defined number of elements, and
+ * refines the output type 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
+ * @return true if the array's length is *at least* `minimum`.
+ * @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
+ */
+export declare function hasAtLeast<N extends number>(minimum: N): <T>(data: ReadonlyArray<T>) => data is ArrayMinN<T, N>;
+export {};
+//# sourceMappingURL=has-at-least.d.ts.map

package/dist/types/array/has-at-least.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least.d.ts","sourceRoot":"","sources":["../../../src/array/has-at-least.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAM/C,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,MAAM,SAAS,CAAC,GAEpD,KAAK,CAAC,CAAC,CAAC,GAGR,CAAC,SAAS,CAAC,GACP,KAAK,CAAC,CAAC,CAAC,GACR,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAC5C,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,CAAC,GACT,IAAI,IAAI,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,OAAO,EAAE,CAAC,GACT,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/types/array/index-by.d.ts

@@ -0,0 +1,34 @@
+import type { PredIndexed } from '../utils/types';
+/**
+ * Converts a list of objects into an object indexing the objects by the given key.
+ * @param array the array
+ * @param fn the indexing function
+ * @signature
+ *    P.indexBy(array, fn)
+ * @example
+ *    P.indexBy(['one', 'two', 'three'], x => x.length) // => {3: 'two', 5: 'three'}
+ * @dataFirst
+ * @indexed
+ * @category Array
+ */
+export declare function indexBy<T>(array: ReadonlyArray<T>, fn: (item: T) => any): Record<string, T>;
+/**
+ * Converts a list of objects into an object indexing the objects by the given key.
+ * @param fn the indexing function
+ * @signature
+ *    P.indexBy(fn)(array)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'three'],
+ *      P.indexBy(x => x.length)
+ *    ) // => {3: 'two', 5: 'three'}
+ * @dataLast
+ * @indexed
+ * @category Array
+ */
+export declare function indexBy<T>(fn: (item: T) => any): (array: ReadonlyArray<T>) => Record<string, T>;
+export declare namespace indexBy {
+    function indexed<T>(array: ReadonlyArray<T>, fn: PredIndexed<T, any>): Record<string, T>;
+    function indexed<T>(fn: PredIndexed<T, any>): (array: ReadonlyArray<T>) => Record<string, T>;
+}
+//# sourceMappingURL=index-by.d.ts.map

package/dist/types/array/index-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-by.d.ts","sourceRoot":"","sources":["../../../src/array/index-by.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gBAAgB,CAAC;AAIvE;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,GACnB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAErB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,GACnB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAiBlD,yBAAiB,OAAO,CAAC;IACvB,SAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,GACtB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACrB,SAAgB,OAAO,CAAC,CAAC,EACvB,EAAE,EAAE,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,GACtB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAInD"}