@vinicunca/perkakas 1.13.2 → 1.14.0

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

@@ -1,50 +0,0 @@
-//#region src/find-last-index.d.ts
-/**
- * Iterates the array in reverse order and returns the index of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, -1 is returned.
- *
- * See also `findLast` which returns the value of last element that satisfies
- * the testing function (rather than its index).
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise.
- * @returns The index of the last (highest-index) element in the array that
- * passes the test. Otherwise -1 if no matching element is found.
- * @signature
- *    P.findLastIndex(data, predicate)
- * @example
- *    P.findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1
- * @dataFirst
- * @category Array
- */
-declare function findLastIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
-/**
- * Iterates the array in reverse order and returns the index of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, -1 is returned.
- *
- * See also `findLast` which returns the value of last element that satisfies
- * the testing function (rather than its index).
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise.
- * @returns The index of the last (highest-index) element in the array that
- * passes the test. Otherwise -1 if no matching element is found.
- * @signature
- *    P.findLastIndex(fn)(items)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.findLastIndex(n => n % 2 === 1)
- *    ) // => 1
- * @dataLast
- * @category Array
- */
-declare function findLastIndex<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => number;
-//#endregion
-export { findLastIndex };
-//# sourceMappingURL=find-last-index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"find-last-index.d.ts","names":[],"sources":["../src/find-last-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;AA4BA;;;;;;;;;;;;;iBA5BgB,uBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B3C,oCACK,wBAAwB,cAAc,yBAChD,cAAc"}

package/dist/find-last.d.cts

@@ -1,62 +0,0 @@
-//#region src/find-last.d.ts
-/**
- * Iterates the array in reverse order and returns the value of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, undefined is returned.
- *
- * Similar functions:
- * `find` - If you need the first element that satisfies the provided testing function.
- * `findLastIndex` - If you need the index of the found element in the array.
- * `lastIndexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The last (highest-index) element in the array that satisfies the
- * provided testing function; undefined if no matching element is found.
- * @signature
- *    P.findLast(data, predicate)
- * @example
- *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
- * @dataFirst
- * @category Array
- */
-declare function findLast<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
-declare function findLast<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
-/**
- * Iterates the array in reverse order and returns the value of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, undefined is returned.
- *
- * Similar functions:
- * `find` - If you need the first element that satisfies the provided testing function.
- * `findLastIndex` - If you need the index of the found element in the array.
- * `lastIndexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The last (highest-index) element in the array that satisfies the
- * provided testing function; undefined if no matching element is found.
- * @signature
- *    P.findLast(predicate)(data)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.findLast(n => n % 2 === 1)
- *    ) // => 3
- * @dataLast
- * @category Array
- */
-declare function findLast<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
-declare function findLast<T = never>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
-//#endregion
-export { findLast };
-//# sourceMappingURL=find-last.d.cts.map

package/dist/find-last.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-last.d.cts","names":[],"sources":["../src/find-last.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;;;;;AAIA;;;;;;;;AAiCA;;;;;;;AAEU,iBAvCM,QAuCN,CAAA,CAAA,EAAA,UAvC4B,CAuC5B,CAAA,CAAA,IAAA,EAtCF,aAsCE,CAtCY,CAsCZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EArCW,CAqCX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArCmC,aAqCnC,CArCiD,CAqCjD,CAAA,EAAA,GAAA,KAAA,IArCiE,CAqCjE,CAAA,EApCP,CAoCO,GAAA,SAAA;AAAqB,iBAnCf,QAmCe,CAAA,CAAA,CAAA,CAAA,IAAA,EAlCvB,aAkCuB,CAlCT,CAkCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAjCV,CAiCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAjCc,aAiCd,CAjC4B,CAiC5B,CAAA,EAAA,GAAA,OAAA,CAAA,EAhC5B,CAgC4B,GAAA,SAAA;;AAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,sBAAsB,sBACjB,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,uCACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find-last.d.ts

@@ -1,62 +0,0 @@
-//#region src/find-last.d.ts
-/**
- * Iterates the array in reverse order and returns the value of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, undefined is returned.
- *
- * Similar functions:
- * `find` - If you need the first element that satisfies the provided testing function.
- * `findLastIndex` - If you need the index of the found element in the array.
- * `lastIndexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The last (highest-index) element in the array that satisfies the
- * provided testing function; undefined if no matching element is found.
- * @signature
- *    P.findLast(data, predicate)
- * @example
- *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
- * @dataFirst
- * @category Array
- */
-declare function findLast<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
-declare function findLast<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
-/**
- * Iterates the array in reverse order and returns the value of the first
- * element that satisfies the provided testing function. If no elements satisfy
- * the testing function, undefined is returned.
- *
- * Similar functions:
- * `find` - If you need the first element that satisfies the provided testing function.
- * `findLastIndex` - If you need the index of the found element in the array.
- * `lastIndexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The last (highest-index) element in the array that satisfies the
- * provided testing function; undefined if no matching element is found.
- * @signature
- *    P.findLast(predicate)(data)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.findLast(n => n % 2 === 1)
- *    ) // => 3
- * @dataLast
- * @category Array
- */
-declare function findLast<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
-declare function findLast<T = never>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
-//#endregion
-export { findLast };
-//# sourceMappingURL=find-last.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"find-last.d.ts","names":[],"sources":["../src/find-last.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;;;;;AAIA;;;;;;;;AAiCA;;;;;;;AAEU,iBAvCM,QAuCN,CAAA,CAAA,EAAA,UAvC4B,CAuC5B,CAAA,CAAA,IAAA,EAtCF,aAsCE,CAtCY,CAsCZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EArCW,CAqCX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArCmC,aAqCnC,CArCiD,CAqCjD,CAAA,EAAA,GAAA,KAAA,IArCiE,CAqCjE,CAAA,EApCP,CAoCO,GAAA,SAAA;AAAqB,iBAnCf,QAmCe,CAAA,CAAA,CAAA,CAAA,IAAA,EAlCvB,aAkCuB,CAlCT,CAkCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAjCV,CAiCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAjCc,aAiCd,CAjC4B,CAiC5B,CAAA,EAAA,GAAA,OAAA,CAAA,EAhC5B,CAgC4B,GAAA,SAAA;;AAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,sBAAsB,sBACjB,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,uCACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find.d.cts

@@ -1,64 +0,0 @@
-//#region src/find.d.ts
-/**
- * Returns the first element in the provided array that satisfies the provided
- * testing function. If no values satisfy the testing function, `undefined` is
- * returned.
- *
- * Similar functions:
- * `findLast` - If you need the last element that satisfies the provided testing function.
- * `findIndex` - If you need the index of the found element in the array.
- * `indexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The first element in the array that satisfies the provided testing
- * function. Otherwise, `undefined` is returned.
- * @signature
- *    P.find(data, predicate)
- * @example
- *    P.find([1, 3, 4, 6], n => n % 2 === 0) // => 4
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function find<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
-declare function find<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
-/**
- * Returns the first element in the provided array that satisfies the provided
- * testing function. If no values satisfy the testing function, `undefined` is
- * returned.
- *
- * Similar functions:
- * `findLast` - If you need the last element that satisfies the provided testing function.
- * `findIndex` - If you need the index of the found element in the array.
- * `indexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The first element in the array that satisfies the provided testing
- * function. Otherwise, `undefined` is returned.
- * @signature
- *    P.find(predicate)(data)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.find(n => n % 2 === 0)
- *    ) // => 4
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function find<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
-declare function find<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
-//#endregion
-export { find };
-//# sourceMappingURL=find.d.cts.map

package/dist/find.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find.d.cts","names":[],"sources":["../src/find.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;AAIA;;;;;;;;AAkCA;;;;;;;;AAE+B,iBAxCf,IAwCe,CAAA,CAAA,EAAA,UAxCG,CAwCH,CAAA,CAAA,IAAA,EAvCvB,aAuCuB,CAvCT,CAuCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAtCV,CAsCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAtCc,aAsCd,CAtC4B,CAsC5B,CAAA,EAAA,GAAA,KAAA,IAtC4C,CAsC5C,CAAA,EArC5B,CAqC4B,GAAA,SAAA;AAAC,iBApChB,IAoCgB,CAAA,CAAA,CAAA,CAAA,IAAA,EAnCxB,aAmCwB,CAnCV,CAmCU,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAlCX,CAkCW,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlCa,aAkCb,CAlC2B,CAkC3B,CAAA,EAAA,GAAA,OAAA,CAAA,EAjC7B,CAiC6B,GAAA,SAAA;AAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,kBAAkB,sBACb,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,2BACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find.d.ts

@@ -1,64 +0,0 @@
-//#region src/find.d.ts
-/**
- * Returns the first element in the provided array that satisfies the provided
- * testing function. If no values satisfy the testing function, `undefined` is
- * returned.
- *
- * Similar functions:
- * `findLast` - If you need the last element that satisfies the provided testing function.
- * `findIndex` - If you need the index of the found element in the array.
- * `indexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param data - The items to search in.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The first element in the array that satisfies the provided testing
- * function. Otherwise, `undefined` is returned.
- * @signature
- *    P.find(data, predicate)
- * @example
- *    P.find([1, 3, 4, 6], n => n % 2 === 0) // => 4
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function find<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
-declare function find<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
-/**
- * Returns the first element in the provided array that satisfies the provided
- * testing function. If no values satisfy the testing function, `undefined` is
- * returned.
- *
- * Similar functions:
- * `findLast` - If you need the last element that satisfies the provided testing function.
- * `findIndex` - If you need the index of the found element in the array.
- * `indexOf` - If you need to find the index of a value.
- * `includes` - If you need to find if a value exists in an array.
- * `some` - If you need to find if any element satisfies the provided testing function.
- * `filter` - If you need to find all elements that satisfy the provided testing function.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to indicate a matching element has been found, and
- * `false` otherwise. A type-predicate can also be used to narrow the result.
- * @returns The first element in the array that satisfies the provided testing
- * function. Otherwise, `undefined` is returned.
- * @signature
- *    P.find(predicate)(data)
- * @example
- *    P.pipe(
- *      [1, 3, 4, 6],
- *      P.find(n => n % 2 === 0)
- *    ) // => 4
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function find<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
-declare function find<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
-//#endregion
-export { find };
-//# sourceMappingURL=find.d.ts.map

package/dist/find.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find.d.ts","names":[],"sources":["../src/find.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;AAIA;;;;;;;;AAkCA;;;;;;;;AAE+B,iBAxCf,IAwCe,CAAA,CAAA,EAAA,UAxCG,CAwCH,CAAA,CAAA,IAAA,EAvCvB,aAuCuB,CAvCT,CAuCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAtCV,CAsCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAtCc,aAsCd,CAtC4B,CAsC5B,CAAA,EAAA,GAAA,KAAA,IAtC4C,CAsC5C,CAAA,EArC5B,CAqC4B,GAAA,SAAA;AAAC,iBApChB,IAoCgB,CAAA,CAAA,CAAA,CAAA,IAAA,EAnCxB,aAmCwB,CAnCV,CAmCU,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAlCX,CAkCW,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlCa,aAkCb,CAlC2B,CAkC3B,CAAA,EAAA,GAAA,OAAA,CAAA,EAjC7B,CAiC6B,GAAA,SAAA;AAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,kBAAkB,sBACb,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,2BACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/first-by.d.cts

@@ -1,60 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
-import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
-import { t as OrderRule } from "./curry-order-rules-BoF09Dq2.cjs";
-
-//#region src/first-by.d.ts
-type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
-/**
- * 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 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 order.
- * @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(P.identity())); // => 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
- */
-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 order.
- * @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
- */
-declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
-//#endregion
-export { firstBy };
-//# sourceMappingURL=first-by.d.cts.map

package/dist/first-by.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"first-by.d.cts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;AAoCtE;;;;;;;;;;AA6BA;;;;;AAEqB,iBA/BL,OA+BK,CAAA,UA/Ba,iBA+Bb,CAAA,CAAA,GAAA,KAAA,EA9BT,QA8BS,CA9BA,aA8BA,CA9Bc,SA8Bd,CA9BwB,CA8BxB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA7BX,CA6BW,EAAA,GA7BL,OA6BK,CA7BG,CA6BH,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAFL,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

package/dist/first-by.d.ts

@@ -1,60 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
-import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
-import { t as OrderRule } from "./curry-order-rules-CoO4bk5I.js";
-
-//#region src/first-by.d.ts
-type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
-/**
- * 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 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 order.
- * @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(P.identity())); // => 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
- */
-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 order.
- * @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
- */
-declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
-//#endregion
-export { firstBy };
-//# sourceMappingURL=first-by.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"first-by.d.ts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;AAoCtE;;;;;;;;;;AA6BA;;;;;AAEqB,iBA/BL,OA+BK,CAAA,UA/Ba,iBA+Bb,CAAA,CAAA,GAAA,KAAA,EA9BT,QA8BS,CA9BA,aA8BA,CA9Bc,SA8Bd,CA9BwB,CA8BxB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA7BX,CA6BW,EAAA,GA7BL,OA6BK,CA7BG,CA6BH,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAFL,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

package/dist/first.d.cts

@@ -1,40 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
-
-//#region src/first.d.ts
-type First<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`.
- *
- * @param data - The array.
- * @returns The first element of the array.
- * @signature
- *    P.first(array)
- * @example
- *    P.first([1, 2, 3]) // => 1
- *    P.first([]) // => undefined
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function first<T extends IterableContainer>(data: T): First<T>;
-/**
- * Gets the first element of `array`.
- *
- * @returns The first element of the array.
- * @signature
- *    P.first()(array)
- * @example
- *    P.pipe(
- *      [1, 2, 4, 8, 16],
- *      P.filter(x => x > 3),
- *      P.first(),
- *      x => x + 1
- *    ); // => 5
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function first(): <T extends IterableContainer>(data: T) => First<T>;
-//#endregion
-export { first };
-//# sourceMappingURL=first.d.cts.map

package/dist/first.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"first.d.cts","names":[],"sources":["../src/first.ts"],"sourcesContent":[],"mappings":";;;KAKK,gBAAgB,qBAAqB,2BAEtC,gCAAgC,kBAC9B,OACA,gDACE,OAAO,SACP;;AAXqE;;;;;;;;;;;AA2B7E;;AAAyD,iBAAzC,KAAyC,CAAA,UAAzB,iBAAyB,CAAA,CAAA,IAAA,EAAA,CAAA,CAAA,EAAI,KAAJ,CAAU,CAAV,CAAA;;;;AAmBzD;;;;;;;;;;;;;;iBAAgB,KAAA,CAAA,cAAoB,yBAAyB,MAAM,MAAM"}

package/dist/first.d.ts

@@ -1,40 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
-
-//#region src/first.d.ts
-type First<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`.
- *
- * @param data - The array.
- * @returns The first element of the array.
- * @signature
- *    P.first(array)
- * @example
- *    P.first([1, 2, 3]) // => 1
- *    P.first([]) // => undefined
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function first<T extends IterableContainer>(data: T): First<T>;
-/**
- * Gets the first element of `array`.
- *
- * @returns The first element of the array.
- * @signature
- *    P.first()(array)
- * @example
- *    P.pipe(
- *      [1, 2, 4, 8, 16],
- *      P.filter(x => x > 3),
- *      P.first(),
- *      x => x + 1
- *    ); // => 5
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function first(): <T extends IterableContainer>(data: T) => First<T>;
-//#endregion
-export { first };
-//# sourceMappingURL=first.d.ts.map

package/dist/first.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"first.d.ts","names":[],"sources":["../src/first.ts"],"sourcesContent":[],"mappings":";;;KAKK,gBAAgB,qBAAqB,2BAEtC,gCAAgC,kBAC9B,OACA,gDACE,OAAO,SACP;;AAXqE;;;;;;;;;;;AA2B7E;;AAAyD,iBAAzC,KAAyC,CAAA,UAAzB,iBAAyB,CAAA,CAAA,IAAA,EAAA,CAAA,CAAA,EAAI,KAAJ,CAAU,CAAV,CAAA;;;;AAmBzD;;;;;;;;;;;;;;iBAAgB,KAAA,CAAA,cAAoB,yBAAyB,MAAM,MAAM"}

package/dist/flat-map.d.cts

@@ -1,47 +0,0 @@
-//#region src/flat-map.d.ts
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param data - The items to map and flatten.
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(data, callbackfn)
- * @example
- *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(callbackfn)(data)
- * @example
- *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
-//#endregion
-export { flatMap };
-//# sourceMappingURL=flat-map.d.cts.map

package/dist/flat-map.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-map.d.cts","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;;;;;;;;AA6BA;;;;;;;;AAMU,iBAnCM,OAmCN,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAlCF,aAkCE,CAlCY,CAkCZ,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EAhCC,CAgCD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA9BA,aA8BA,CA9Bc,CA8Bd,CAAA,EAAA,GA7BH,aA6BG,CA7BW,CA6BX,CAAA,GA7BgB,CA6BhB,CAAA,EA5BP,KA4BO,CA5BD,CA4BC,CAAA;;;;;;;;;;;;;;;;;;;;;iBANM,kCAEL,wBAED,cAAc,OACjB,cAAc,KAAK,WAChB,cAAc,OAAO,MAAM"}

package/dist/flat-map.d.ts

@@ -1,47 +0,0 @@
-//#region src/flat-map.d.ts
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param data - The items to map and flatten.
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(data, callbackfn)
- * @example
- *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(callbackfn)(data)
- * @example
- *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
-//#endregion
-export { flatMap };
-//# sourceMappingURL=flat-map.d.ts.map