@naturalcycles/js-lib 14.217.0 → 14.218.0

package/dist/array/array.util.d.ts

@@ -115,8 +115,13 @@ export declare function _dropWhile<T>(items: T[], predicate: Predicate<T>): T[];
 export declare function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[];
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
+export declare function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number;
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export declare function _count<T>(items: T[], predicate: AbortablePredicate<T>): number;
 export declare function _countBy<T>(items: T[], mapper: Mapper<T, any>): StringMap<number>;
 /**
  * Returns an intersection between 2 arrays.

package/dist/array/array.util.js

@@ -206,19 +206,29 @@ function _dropRightWhile(items, predicate) {
 exports._dropRightWhile = _dropRightWhile;
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-function _count(items, predicate) {
+function _count(items, predicate, limit) {
+    if (limit === 0)
+        return 0;
     let count = 0;
     for (const [i, item] of items.entries()) {
         const r = predicate(item, i);
         if (r === types_1.END)
             break;
-        if (r)
+        if (r) {
             count++;
+            if (limit && count >= limit)
+                break;
+        }
     }
     return count;
 }
 exports._count = _count;
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
 function _countBy(items, mapper) {
     const map = {};
     items.forEach((item, i) => {

package/dist/string/leven.d.ts

@@ -2,5 +2,8 @@
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-export declare function _leven(first: string, second: string): number;
+export declare function _leven(first: string, second: string, limit?: number): number;

package/dist/string/leven.js

@@ -8,9 +8,12 @@ const characterCodeCache = [];
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-function _leven(first, second) {
-    if (first === second) {
+function _leven(first, second, limit) {
+    if (first === second || limit === 0) {
         return 0;
     }
     const swap = first;
@@ -40,6 +43,8 @@ function _leven(first, second) {
     firstLength -= start;
     secondLength -= start;
     if (firstLength === 0) {
+        if (limit && secondLength >= limit)
+            return limit;
         return secondLength;
     }
     let bCharacterCode;
@@ -56,6 +61,8 @@ function _leven(first, second) {
         bCharacterCode = second.charCodeAt(start + index2);
         temporary = index2++;
         result = index2;
+        if (limit && result >= limit)
+            return limit; // exit early on limit
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];

package/dist-esm/array/array.util.js

@@ -188,18 +188,28 @@ export function _dropRightWhile(items, predicate) {
 }
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export function _count(items, predicate) {
+export function _count(items, predicate, limit) {
+    if (limit === 0)
+        return 0;
     let count = 0;
     for (const [i, item] of items.entries()) {
         const r = predicate(item, i);
         if (r === END)
             break;
-        if (r)
+        if (r) {
             count++;
+            if (limit && count >= limit)
+                break;
+        }
     }
     return count;
 }
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
 export function _countBy(items, mapper) {
     const map = {};
     items.forEach((item, i) => {

package/dist-esm/string/leven.js

@@ -5,9 +5,12 @@ const characterCodeCache = [];
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-export function _leven(first, second) {
-    if (first === second) {
+export function _leven(first, second, limit) {
+    if (first === second || limit === 0) {
         return 0;
     }
     const swap = first;
@@ -37,6 +40,8 @@ export function _leven(first, second) {
     firstLength -= start;
     secondLength -= start;
     if (firstLength === 0) {
+        if (limit && secondLength >= limit)
+            return limit;
         return secondLength;
     }
     let bCharacterCode;
@@ -53,6 +58,8 @@ export function _leven(first, second) {
         bCharacterCode = second.charCodeAt(start + index2);
         temporary = index2++;
         result = index2;
+        if (limit && result >= limit)
+            return limit; // exit early on limit
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.217.0",
+  "version": "14.218.0",
   "scripts": {
     "prepare": "husky",
     "build-prod": "build-prod-esm-cjs",

package/src/array/array.util.ts

@@ -229,19 +229,28 @@ export function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
 
 /**
  * Counts how many items match the predicate.
+ *
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
  */
-export function _count<T>(items: T[], predicate: AbortablePredicate<T>): number {
+export function _count<T>(items: T[], predicate: AbortablePredicate<T>, limit?: number): number {
+  if (limit === 0) return 0
   let count = 0
 
   for (const [i, item] of items.entries()) {
     const r = predicate(item, i)
     if (r === END) break
-    if (r) count++
+    if (r) {
+      count++
+      if (limit && count >= limit) break
+    }
   }
 
   return count
 }
 
+/**
+ * `limit` allows to exit early when limit count is reached, skipping further iterations (perf optimization).
+ */
 export function _countBy<T>(items: T[], mapper: Mapper<T, any>): StringMap<number> {
   const map: StringMap<number> = {}
 

package/src/string/leven.ts

@@ -7,9 +7,12 @@ const characterCodeCache: number[] = []
  * Modified version of: https://github.com/sindresorhus/leven/
  *
  * Returns a Levenshtein distance between first and second word.
+ *
+ * `limit` optional parameter can be used to limit the distance calculation
+ * and skip unnecessary iterations when limit is reached.
  */
-export function _leven(first: string, second: string): number {
-  if (first === second) {
+export function _leven(first: string, second: string, limit?: number): number {
+  if (first === second || limit === 0) {
     return 0
   }
 
@@ -47,6 +50,7 @@ export function _leven(first: string, second: string): number {
   secondLength -= start
 
   if (firstLength === 0) {
+    if (limit && secondLength >= limit) return limit
     return secondLength
   }
 
@@ -66,6 +70,7 @@ export function _leven(first: string, second: string): number {
     bCharacterCode = second.charCodeAt(start + index2)
     temporary = index2++
     result = index2
+    if (limit && result >= limit) return limit // exit early on limit
 
     for (index = 0; index < firstLength; index++) {
       temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1