@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/sort-by.d.cts

@@ -1,88 +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";
-import { t as ReorderedArray } from "./reordered-array-CmReuxDi.cjs";
-
-//#region src/sort-by.d.ts
-
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(...rules)(data)
- * @example
- *    P.pipe(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      P.sortBy(P.prop('a')),
- *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- * @dataLast
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => ReorderedArray<T>;
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param array - The input array.
- * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(data, ...rules)
- * @example
- *    P.sortBy(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      prop('a'),
- *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- *    P.sortBy(
- *      [
- *        {color: 'red', weight: 2},
- *        {color: 'blue', weight: 3},
- *        {color: 'green', weight: 1},
- *        {color: 'purple', weight: 1},
- *      ],
- *      [prop('weight'), 'asc'],
- *      prop('color'),
- *    ); // => [
- *    //   {color: 'green', weight: 1},
- *    //   {color: 'purple', weight: 1},
- *    //   {color: 'red', weight: 2},
- *    //   {color: 'blue', weight: 3},
- *    // ]
- * @dataFirst
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): ReorderedArray<T>;
-//#endregion
-export { sortBy };
-//# sourceMappingURL=sort-by.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by.d.cts","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAqCA;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;;iBAlDgB,iBAAiB,iCACjB,SAAS,cAAc,UAAU,uBACtC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDhB,iBAAiB,0BACxB,iBACO,SAAS,cAAc,UAAU,eAC9C,eAAe"}

package/dist/sort-by.d.ts

@@ -1,88 +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";
-import { t as ReorderedArray } from "./reordered-array-BWG6tVSK.js";
-
-//#region src/sort-by.d.ts
-
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(...rules)(data)
- * @example
- *    P.pipe(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      P.sortBy(P.prop('a')),
- *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- * @dataLast
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => ReorderedArray<T>;
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param array - The input array.
- * @param sortRules - 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 A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(data, ...rules)
- * @example
- *    P.sortBy(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      prop('a'),
- *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- *    P.sortBy(
- *      [
- *        {color: 'red', weight: 2},
- *        {color: 'blue', weight: 3},
- *        {color: 'green', weight: 1},
- *        {color: 'purple', weight: 1},
- *      ],
- *      [prop('weight'), 'asc'],
- *      prop('color'),
- *    ); // => [
- *    //   {color: 'green', weight: 1},
- *    //   {color: 'purple', weight: 1},
- *    //   {color: 'red', weight: 2},
- *    //   {color: 'blue', weight: 3},
- *    // ]
- * @dataFirst
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): ReorderedArray<T>;
-//#endregion
-export { sortBy };
-//# sourceMappingURL=sort-by.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by.d.ts","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAqCA;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;;iBAlDgB,iBAAiB,iCACjB,SAAS,cAAc,UAAU,uBACtC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDhB,iBAAiB,0BACxB,iBACO,SAAS,cAAc,UAAU,eAC9C,eAAe"}

package/dist/sort.d.cts

@@ -1,39 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
-import { t as ReorderedArray } from "./reordered-array-CmReuxDi.cjs";
-
-//#region src/sort.d.ts
-
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param items - The array to sort.
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(items, cmp)
- * @example
- *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]
- * @dataFirst
- * @category Array
- */
-declare function sort<T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): ReorderedArray<T>;
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(cmp)(items)
- * @example
- *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]
- * @dataLast
- * @category Array
- */
-declare function sort<T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => ReorderedArray<T>;
-//#endregion
-export { sort };
-//# sourceMappingURL=sort.d.cts.map

package/dist/sort.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort.d.cts","names":[],"sources":["../src/sort.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;;;AAmBA;;;;;AAEgC,iBArBhB,IAqBgB,CAAA,UArBD,iBAqBC,CAAA,CAAA,KAAA,EApBvB,CAoBuB,EAAA,GAAA,EAAA,CAAA,CAAA,EAnBrB,CAmBqB,CAAA,MAAA,CAAA,EAAA,CAAA,EAnBP,CAmBO,CAAA,MAAA,CAAA,EAAA,GAAA,MAAA,CAAA,EAlB7B,cAkB6B,CAlBd,CAkBc,CAAA;;;;;;;;;;;;;;;iBAFhB,eAAe,4BACpB,cAAc,+BACd,MAAM,eAAe"}

package/dist/sort.d.ts

@@ -1,39 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
-import { t as ReorderedArray } from "./reordered-array-BWG6tVSK.js";
-
-//#region src/sort.d.ts
-
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param items - The array to sort.
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(items, cmp)
- * @example
- *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]
- * @dataFirst
- * @category Array
- */
-declare function sort<T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): ReorderedArray<T>;
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(cmp)(items)
- * @example
- *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]
- * @dataLast
- * @category Array
- */
-declare function sort<T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => ReorderedArray<T>;
-//#endregion
-export { sort };
-//# sourceMappingURL=sort.d.ts.map

package/dist/sort.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort.d.ts","names":[],"sources":["../src/sort.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;;;AAmBA;;;;;AAEgC,iBArBhB,IAqBgB,CAAA,UArBD,iBAqBC,CAAA,CAAA,KAAA,EApBvB,CAoBuB,EAAA,GAAA,EAAA,CAAA,CAAA,EAnBrB,CAmBqB,CAAA,MAAA,CAAA,EAAA,CAAA,EAnBP,CAmBO,CAAA,MAAA,CAAA,EAAA,GAAA,MAAA,CAAA,EAlB7B,cAkB6B,CAlBd,CAkBc,CAAA;;;;;;;;;;;;;;;iBAFhB,eAAe,4BACpB,cAAc,+BACd,MAAM,eAAe"}

package/dist/sorted-index-by.d.cts

@@ -1,70 +0,0 @@
-//#region src/sorted-index-by.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order using a value function; so that
- * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
- * ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @param valueFunction - All comparisons would be performed on the result of
- * calling this function on each compared item. Preferably this function should
- * return a `number` or `string`. This function should be the same as the one
- * provided to sortBy to sort the array. The function is called exactly once on
- * each items that is compared against in the array, and once at the beginning
- * on `item`. When called on `item` the `index` argument is `undefined`.
- * @returns Insertion index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @category Array
- */
-declare function sortedIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): number;
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order using a value function; so that
- * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
- * ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param item - The item to insert.
- * @param valueFunction - All comparisons would be performed on the result of
- * calling this function on each compared item. Preferably this function should
- * return a `number` or `string`. This function should be the same as the one
- * provided to sortBy to sort the array. The function is called exactly once on
- * each items that is compared against in the array, and once at the beginning
- * on `item`. When called on `item` the `index` argument is `undefined`.
- * @signature
- *    P.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndexBy };
-//# sourceMappingURL=sorted-index-by.d.cts.map

package/dist/sorted-index-by.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by.d.cts","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;iBAzCgB,uBACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCS,uBACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

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

@@ -1,70 +0,0 @@
-//#region src/sorted-index-by.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order using a value function; so that
- * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
- * ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @param valueFunction - All comparisons would be performed on the result of
- * calling this function on each compared item. Preferably this function should
- * return a `number` or `string`. This function should be the same as the one
- * provided to sortBy to sort the array. The function is called exactly once on
- * each items that is compared against in the array, and once at the beginning
- * on `item`. When called on `item` the `index` argument is `undefined`.
- * @returns Insertion index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @category Array
- */
-declare function sortedIndexBy<T>(data: ReadonlyArray<T>, item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): number;
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order using a value function; so that
- * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-
- * ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param item - The item to insert.
- * @param valueFunction - All comparisons would be performed on the result of
- * calling this function on each compared item. Preferably this function should
- * return a `number` or `string`. This function should be the same as the one
- * provided to sortBy to sort the array. The function is called exactly once on
- * each items that is compared against in the array, and once at the beginning
- * on `item`. When called on `item` the `index` argument is `undefined`.
- * @signature
- *    P.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndexBy };
-//# sourceMappingURL=sorted-index-by.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by.d.ts","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;iBAzCgB,uBACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCS,uBACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

package/dist/sorted-index-with.d.cts

@@ -1,72 +0,0 @@
-//#region src/sorted-index-with.d.ts
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param data - Array, "sorted" by `predicate`.
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(data, predicate)
- * @example
- *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
- * @dataFirst
- * @category Array
- * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(predicate)(data)
- * @example
- *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexWith<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndexWith };
-//# sourceMappingURL=sorted-index-with.d.cts.map

package/dist/sorted-index-with.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-with.d.cts","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":[],"mappings":";;AAqCA;;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;iBArCgB,yBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC3C,sCACK,wBAAwB,cAAc,wBACjD,cAAc"}

package/dist/sorted-index-with.d.ts

@@ -1,72 +0,0 @@
-//#region src/sorted-index-with.d.ts
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param data - Array, "sorted" by `predicate`.
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(data, predicate)
- * @example
- *    P.sortedIndexWith(['a','ab','abc'], (item) => item.length < 2) // => 1
- * @dataFirst
- * @category Array
- * @see findIndex, sortedIndex, sortedIndexBy, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndexWith<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
-/**
- * Performs a **binary search** for the index of the item at which the predicate
- * stops returning `true`. This function assumes that the array is "sorted" in
- * regards to the predicate, meaning that running the predicate as a mapper on
- * it would result in an array `[...true[], ...false[]]`.
- * This stricter requirement from the predicate provides us 2 benefits over
- * `findIndex` which does a similar thing:
- * 1. It would run at O(logN) time instead of O(N) time.
- * 2. It always returns a value (it would return `data.length` if the
- * predicate returns `true` for all items).
- *
- * This function is the basis for all other sortedIndex functions which search
- * for a specific item in a sorted array, and it could be used to perform
- * similar efficient searches.
- * `sortedIndex` - scans a sorted array with a binary search, find the first suitable index.
- * `sortedIndexBy` - like `sortedIndex`, but assumes sorting is based on a callbackfn.
- * `sortedLastIndex` - scans a sorted array with a binary search, finding the last suitable index.
- * `sortedLastIndexBy` - like `sortedLastIndex`, but assumes sorting is based on a callbackfn.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.
- *
- * @param predicate - A predicate which also defines the array's order.
- * @returns Index (In the range 0..data.length).
- * @signature
- *    P.sortedIndexWith(predicate)(data)
- * @example
- *    P.pipe(['a','ab','abc'], P.sortedIndexWith((item) => item.length < 2)) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexWith<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndexWith };
-//# sourceMappingURL=sorted-index-with.d.ts.map

package/dist/sorted-index-with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-with.d.ts","names":[],"sources":["../src/sorted-index-with.ts"],"sourcesContent":[],"mappings":";;AAqCA;;;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;iBArCgB,yBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmC3C,sCACK,wBAAwB,cAAc,wBACjD,cAAc"}

package/dist/sorted-index.d.cts

@@ -1,45 +0,0 @@
-//#region src/sorted-index.d.ts
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
- * maintaining the array's sort-ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param data - The (ascending) sorted array.
- * @param item - The item to insert.
- * @returns Insertion index (In the range 0..array.length).
- * @signature
- *    P.sortedIndex(data, item)
- * @example
- *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3
- * @dataFirst
- * @category Array
- * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndex<T>(data: ReadonlyArray<T>, item: T): number;
-/**
- * Find the insertion position (index) of an item in an array with items sorted
- * in ascending order; so that `splice(sortedIndex, 0, item)` would result in
- * maintaining the array's sort-ness. The array can contain duplicates.
- * If the item already exists in the array the index would be of the *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * @param item - The item to insert.
- * @returns Insertion index (In the range 0..array.length).
- * @signature
- *    P.sortedIndex(item)(data)
- * @example
- *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3
- * @dataLast
- * @category Array
- * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy
- */
-declare function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndex };
-//# sourceMappingURL=sorted-index.d.cts.map

package/dist/sorted-index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index.d.cts","names":[],"sources":["../src/sorted-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;AAqBA;;;;;;;;;;;;;;iBArBgB,qBAAqB,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;iBAqB7C,qBAAqB,WAAW,cAAc"}