@difizen/libro-common 0.0.2-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Difizen Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/es/array.d.ts

@@ -0,0 +1,368 @@
+/**
+ * Find the index of the first occurrence of a value in an array.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param value - The value to locate in the array. Values are
+ *   compared using strict `===` equality.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first occurrence of the value, or `-1`
+ *   if the value is not found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * let data = ['one', 'two', 'three', 'four', 'one'];
+ * firstIndexOfArray(data, 'red');        // -1
+ * firstIndexOfArray(data, 'one');        // 0
+ * firstIndexOfArray(data, 'one', 1);     // 4
+ * firstIndexOfArray(data, 'two', 2);     // -1
+ * firstIndexOfArray(data, 'two', 2, 1);  // 1
+ * ```
+ */
+export declare function firstIndexOfArray<T>(array: ArrayLike<T>, value: T, start?: number, stop?: number): number;
+/**
+ * Find the index of the first value which matches a predicate.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first matching value, or `-1` if no
+ *   matching value is found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findFirstArrayIndex(data, isEven);       // 1
+ * findFirstArrayIndex(data, isEven, 4);    // 5
+ * findFirstArrayIndex(data, isEven, 6);    // -1
+ * findFirstArrayIndex(data, isEven, 6, 5); // 1
+ * ```
+ */
+export declare function findFirstArrayIndex<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): number;
+/**
+ * Find the index of the last value which matches a predicate.
+ *
+ * @param object - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the last matching value, or `-1` if no
+ *   matching value is found.
+ *
+ * #### Notes
+ * If `start < stop` the search will wrap at the front of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findLastArrayIndex(data, isEven);        // 5
+ * findLastArrayIndex(data, isEven, 4);     // 3
+ * findLastArrayIndex(data, isEven, 0);     // -1
+ * findLastArrayIndex(data, isEven, 0, 1);  // 5
+ * ```
+ */
+export declare function findLastArrayIndex<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): number;
+/**
+ * Find the first value which matches a predicate.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The first matching value, or `undefined` if no matching
+ *   value is found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findFirstArrayValue(data, isEven);       // 2
+ * findFirstArrayValue(data, isEven, 2);    // 4
+ * findFirstArrayValue(data, isEven, 6);    // undefined
+ * findFirstArrayValue(data, isEven, 6, 5); // 2
+ * ```
+ */
+export declare function findFirstArrayValue<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): T | undefined;
+/**
+ * Find the last value which matches a predicate.
+ *
+ * @param object - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The last matching value, or `undefined` if no matching
+ *   value is found.
+ *
+ * #### Notes
+ * If `start < stop` the search will wrap at the front of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findLastArrayValue(data, isEven);        // 2
+ * findLastArrayValue(data, isEven, 4);     // 4
+ * findLastArrayValue(data, isEven, 0);     // undefined
+ * findLastArrayValue(data, isEven, 0, 1);  // 2
+ * ```
+ */
+export declare function findLastArrayValue<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): T | undefined;
+/**
+ * Find the index of the first element which compares `>=` to a value.
+ *
+ * @param array - The sorted array-like object to search.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param fn - The 3-way comparison function to apply to the values.
+ *   It should return `< 0` if an element is less than a value, `0` if
+ *   an element is equal to a value, or `> 0` if an element is greater
+ *   than a value.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first element which compares `>=` to the
+ *   value, or `length` if there is no such element. If the computed
+ *   index for `stop` is less than `start`, then the computed index
+ *   for `start` is returned.
+ *
+ * #### Notes
+ * The array must already be sorted in ascending order according to
+ * the comparison function.
+ *
+ * #### Complexity
+ * Logarithmic.
+ *
+ * #### Undefined Behavior
+ * Searching a range which is not sorted in ascending order.
+ *
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a - b;
+ * }
+ *
+ * let data = [0, 3, 4, 7, 7, 9];
+ * lowerArrayBound(data, 0, numberCmp);   // 0
+ * lowerArrayBound(data, 6, numberCmp);   // 3
+ * lowerArrayBound(data, 7, numberCmp);   // 3
+ * lowerArrayBound(data, -1, numberCmp);  // 0
+ * lowerArrayBound(data, 10, numberCmp);  // 6
+ * ```
+ */
+export declare function lowerArrayBound<T, U>(array: ArrayLike<T>, value: U, fn: (element: T, value: U) => number, start?: number, stop?: number): number;
+/**
+ * Find the index of the first element which compares `>` than a value.
+ *
+ * @param array - The sorted array-like object to search.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param fn - The 3-way comparison function to apply to the values.
+ *   It should return `< 0` if an element is less than a value, `0` if
+ *   an element is equal to a value, or `> 0` if an element is greater
+ *   than a value.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first element which compares `>` than the
+ *   value, or `length` if there is no such element. If the computed
+ *   index for `stop` is less than `start`, then the computed index
+ *   for `start` is returned.
+ *
+ * #### Notes
+ * The array must already be sorted in ascending order according to
+ * the comparison function.
+ *
+ * #### Complexity
+ * Logarithmic.
+ *
+ * #### Undefined Behavior
+ * Searching a range which is not sorted in ascending order.
+ *
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a - b;
+ * }
+ *
+ * let data = [0, 3, 4, 7, 7, 9];
+ * upperArrayBound(data, 0, numberCmp);   // 1
+ * upperArrayBound(data, 6, numberCmp);   // 3
+ * upperArrayBound(data, 7, numberCmp);   // 5
+ * upperArrayBound(data, -1, numberCmp);  // 0
+ * upperArrayBound(data, 10, numberCmp);  // 6
+ * ```
+ */
+export declare function upperArrayBound<T, U>(array: ArrayLike<T>, value: U, fn: (element: T, value: U) => number, start?: number, stop?: number): number;
+/**
+ * Remove all occurrences of values which match a predicate.
+ *
+ * @param array - The array of interest.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The number of elements removed from the array.
+ *
+ * #### Notes
+ * If `stop < start` the search will conceptually wrap at the end of
+ * the array, however the array will be traversed front-to-back.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * function isNegative(value: number): boolean {
+ *   return value < 0;
+ * }
+ *
+ * let data = [0, 12, -13, -9, 23, 39, 14, -15, 12, 75];
+ * removeAllWhereFromArray(data, isEven);            // 4
+ * removeAllWhereFromArray(data, isNegative, 0, 3);  // 2
+ * ```
+ */
+export declare function removeAllWhereFromArray<T>(array: T[], fn: (value: T, index: number) => boolean, start?: number, stop?: number): number;
+//# sourceMappingURL=array.d.ts.map

package/es/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAK,EACV,IAAI,SAAI,GACP,MAAM,CA+BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,CAAC,GAAG,SAAS,CAGf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAK,EACV,IAAI,SAAI,GACP,CAAC,GAAG,SAAS,CAGf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,EACpC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,EACpC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CAmCR"}