@vinicunca/perkakas 0.5.4 → 1.0.0

package/dist/filter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Creates a shallow copy of a portion of a given array, filtered down to just
+ * the elements from the given array that pass the test implemented by the
+ * provided function. Equivalent to `Array.prototype.filter`.
+ *
+ * @param data - The array to filter.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to keep the element in the resulting array, and `false`
+ * otherwise. A type-predicate can also be used to narrow the result.
+ * @returns A shallow copy of the given array containing just the elements that
+ * pass the test. If no elements pass the test, an empty array is returned.
+ * @signature
+ *    P.filter(data, predicate)
+ * @example
+ *    P.filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function filter<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): Array<S>;
+declare function filter<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): Array<T>;
+/**
+ * Creates a shallow copy of a portion of a given array, filtered down to just
+ * the elements from the given array that pass the test implemented by the
+ * provided function. Equivalent to `Array.prototype.filter`.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to keep the element in the resulting array, and `false`
+ * otherwise.
+ * @returns A shallow copy of the given array containing just the elements that
+ * pass the test. If no elements pass the test, an empty array is returned.
+ * @signature
+ *    P.filter(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 3], P.filter(x => x % 2 === 1)) // => [1, 3]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function filter<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => Array<S>;
+declare function filter<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => Array<T>;
+
+export { filter };

package/dist/filter.js

@@ -0,0 +1 @@
+import{a}from"./chunk-BGPRJNRQ.js";import"./chunk-MYLYERXO.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as filter};

package/dist/find-index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVCZBVN24cjs = require('./chunk-VCZBVN24.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.findIndex = _chunkVCZBVN24cjs.a;

package/dist/find-index.d.cts

@@ -0,0 +1,48 @@
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first 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 a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(data, predicate)
+ * @example
+ *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function findIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first 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 a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex(n => n % 2 === 0)
+ *    ); // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function findIndex<T>(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
+
+export { findIndex };

package/dist/find-index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first 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 a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(data, predicate)
+ * @example
+ *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function findIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first 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 a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex(n => n % 2 === 0)
+ *    ); // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function findIndex<T>(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
+
+export { findIndex };

package/dist/find-index.js

@@ -0,0 +1 @@
+import{a}from"./chunk-52GYNLEB.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as findIndex};

package/dist/find-last-index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkMGT2JXCZcjs = require('./chunk-MGT2JXCZ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.findLastIndex = _chunkMGT2JXCZcjs.a;

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

@@ -0,0 +1,48 @@
+/**
+ * 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;
+
+export { findLastIndex };

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

@@ -0,0 +1,48 @@
+/**
+ * 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;
+
+export { findLastIndex };

package/dist/find-last-index.js

@@ -0,0 +1 @@
+import{a}from"./chunk-XOWF2B3H.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as findLastIndex};

package/dist/find-last.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYVGIOTPHcjs = require('./chunk-YVGIOTPH.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.findLast = _chunkYVGIOTPHcjs.a;

package/dist/find-last.d.cts

@@ -0,0 +1,60 @@
+/**
+ * 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;
+
+export { findLast };

package/dist/find-last.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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;
+
+export { findLast };

package/dist/find-last.js

@@ -0,0 +1 @@
+import{a}from"./chunk-HFZNXHUH.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as findLast};

package/dist/find.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkU32YSACLcjs = require('./chunk-U32YSACL.cjs');require('./chunk-GPGITOFN.cjs');require('./chunk-3X6SAJDQ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.find = _chunkU32YSACLcjs.a;

package/dist/find.d.cts

@@ -0,0 +1,62 @@
+/**
+ * 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;
+
+export { find };

package/dist/find.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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;
+
+export { find };

package/dist/find.js

@@ -0,0 +1 @@
+import{a}from"./chunk-BF6VQFQK.js";import"./chunk-SME5FGMA.js";import"./chunk-MYLYERXO.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as find};

package/dist/first-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkXJRGE7WLcjs = require('./chunk-XJRGE7WL.cjs');require('./chunk-FWQYL4Y4.cjs');require('./chunk-G66EZBJS.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.firstBy = _chunkXJRGE7WLcjs.a;

package/dist/first-by.d.cts

@@ -0,0 +1,58 @@
+import { I as IterableContainer, N as NonEmptyArray } from './types-DCY4LHuA.cjs';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.cjs';
+import 'type-fest';
+
+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 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>;
+
+export { firstBy };

package/dist/first-by.d.ts

@@ -0,0 +1,58 @@
+import { I as IterableContainer, N as NonEmptyArray } from './types-DCY4LHuA.js';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.js';
+import 'type-fest';
+
+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 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>;
+
+export { firstBy };

package/dist/first-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-CXRG2GSY.js";import"./chunk-JXXXUJM5.js";import"./chunk-73BYESBE.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as firstBy};

package/dist/first.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkK2MIPOLQcjs = require('./chunk-K2MIPOLQ.cjs');require('./chunk-GPGITOFN.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.first = _chunkK2MIPOLQcjs.a;