@naturalcycles/js-lib 14.87.0 → 14.88.0

package/dist/index.d.ts

@@ -60,5 +60,6 @@ export * from './string/safeJsonStringify';
 import { PQueue, PQueueCfg } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
+export * from './string/leven';
 export type { AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, AsyncMemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateTime, Reviver, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestamp, Integer, BaseDBEntity, SavedDBEntity, Saved, Unsaved, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
 export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist/index.js

@@ -92,3 +92,4 @@ const pQueue_1 = require("./promise/pQueue");
 Object.defineProperty(exports, "PQueue", { enumerable: true, get: function () { return pQueue_1.PQueue; } });
 (0, tslib_1.__exportStar)(require("./seq/seq"), exports);
 (0, tslib_1.__exportStar)(require("./math/stack.util"), exports);
+(0, tslib_1.__exportStar)(require("./string/leven"), exports);

package/dist/string/leven.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Modified version of: https://github.com/sindresorhus/leven/
+ *
+ * Returns a Levenshtein distance between first and second word.
+ */
+export declare function _leven(first: string, second: string): number;

package/dist/string/leven.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._leven = void 0;
+const array = [];
+const characterCodeCache = [];
+/* eslint-disable unicorn/prefer-code-point, no-bitwise */
+/**
+ * Modified version of: https://github.com/sindresorhus/leven/
+ *
+ * Returns a Levenshtein distance between first and second word.
+ */
+function _leven(first, second) {
+    if (first === second) {
+        return 0;
+    }
+    const swap = first;
+    // Swapping the strings if `a` is longer than `b` so we know which one is the
+    // shortest & which one is the longest
+    if (first.length > second.length) {
+        first = second;
+        second = swap;
+    }
+    let firstLength = first.length;
+    let secondLength = second.length;
+    // Performing suffix trimming:
+    // We can linearly drop suffix common to both strings since they
+    // don't increase distance at all
+    // Note: `~-` is the bitwise way to perform a `- 1` operation
+    while (firstLength > 0 && first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)) {
+        firstLength--;
+        secondLength--;
+    }
+    // Performing prefix trimming
+    // We can linearly drop prefix common to both strings since they
+    // don't increase distance at all
+    let start = 0;
+    while (start < firstLength && first.charCodeAt(start) === second.charCodeAt(start)) {
+        start++;
+    }
+    firstLength -= start;
+    secondLength -= start;
+    if (firstLength === 0) {
+        return secondLength;
+    }
+    let bCharacterCode;
+    let result;
+    let temporary;
+    let temporary2;
+    let index = 0;
+    let index2 = 0;
+    while (index < firstLength) {
+        characterCodeCache[index] = first.charCodeAt(start + index);
+        array[index] = ++index;
+    }
+    while (index2 < secondLength) {
+        bCharacterCode = second.charCodeAt(start + index2);
+        temporary = index2++;
+        result = index2;
+        for (index = 0; index < firstLength; index++) {
+            temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
+            temporary = array[index];
+            // eslint-disable-next-line no-multi-assign
+            result = array[index] =
+                temporary > result
+                    ? temporary2 > result
+                        ? result + 1
+                        : temporary2
+                    : temporary2 > temporary
+                        ? temporary + 1
+                        : temporary2;
+        }
+    }
+    return result;
+}
+exports._leven = _leven;

package/dist-esm/index.js

@@ -56,4 +56,5 @@ export * from './string/safeJsonStringify';
 import { PQueue } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
+export * from './string/leven';
 export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist-esm/string/leven.js

@@ -0,0 +1,71 @@
+const array = [];
+const characterCodeCache = [];
+/* eslint-disable unicorn/prefer-code-point, no-bitwise */
+/**
+ * Modified version of: https://github.com/sindresorhus/leven/
+ *
+ * Returns a Levenshtein distance between first and second word.
+ */
+export function _leven(first, second) {
+    if (first === second) {
+        return 0;
+    }
+    const swap = first;
+    // Swapping the strings if `a` is longer than `b` so we know which one is the
+    // shortest & which one is the longest
+    if (first.length > second.length) {
+        first = second;
+        second = swap;
+    }
+    let firstLength = first.length;
+    let secondLength = second.length;
+    // Performing suffix trimming:
+    // We can linearly drop suffix common to both strings since they
+    // don't increase distance at all
+    // Note: `~-` is the bitwise way to perform a `- 1` operation
+    while (firstLength > 0 && first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)) {
+        firstLength--;
+        secondLength--;
+    }
+    // Performing prefix trimming
+    // We can linearly drop prefix common to both strings since they
+    // don't increase distance at all
+    let start = 0;
+    while (start < firstLength && first.charCodeAt(start) === second.charCodeAt(start)) {
+        start++;
+    }
+    firstLength -= start;
+    secondLength -= start;
+    if (firstLength === 0) {
+        return secondLength;
+    }
+    let bCharacterCode;
+    let result;
+    let temporary;
+    let temporary2;
+    let index = 0;
+    let index2 = 0;
+    while (index < firstLength) {
+        characterCodeCache[index] = first.charCodeAt(start + index);
+        array[index] = ++index;
+    }
+    while (index2 < secondLength) {
+        bCharacterCode = second.charCodeAt(start + index2);
+        temporary = index2++;
+        result = index2;
+        for (index = 0; index < firstLength; index++) {
+            temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
+            temporary = array[index];
+            // eslint-disable-next-line no-multi-assign
+            result = array[index] =
+                temporary > result
+                    ? temporary2 > result
+                        ? result + 1
+                        : temporary2
+                    : temporary2 > temporary
+                        ? temporary + 1
+                        : temporary2;
+        }
+    }
+    return result;
+}

package/package.json

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

package/src/index.ts

@@ -155,6 +155,7 @@ export * from './string/safeJsonStringify'
 import { PQueue, PQueueCfg } from './promise/pQueue'
 export * from './seq/seq'
 export * from './math/stack.util'
+export * from './string/leven'
 
 export type {
   AbortableMapper,

package/src/string/leven.ts

@@ -0,0 +1,86 @@
+const array: number[] = []
+const characterCodeCache: number[] = []
+
+/* eslint-disable unicorn/prefer-code-point, no-bitwise */
+
+/**
+ * Modified version of: https://github.com/sindresorhus/leven/
+ *
+ * Returns a Levenshtein distance between first and second word.
+ */
+export function _leven(first: string, second: string): number {
+  if (first === second) {
+    return 0
+  }
+
+  const swap = first
+
+  // Swapping the strings if `a` is longer than `b` so we know which one is the
+  // shortest & which one is the longest
+  if (first.length > second.length) {
+    first = second
+    second = swap
+  }
+
+  let firstLength = first.length
+  let secondLength = second.length
+
+  // Performing suffix trimming:
+  // We can linearly drop suffix common to both strings since they
+  // don't increase distance at all
+  // Note: `~-` is the bitwise way to perform a `- 1` operation
+  while (firstLength > 0 && first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)) {
+    firstLength--
+    secondLength--
+  }
+
+  // Performing prefix trimming
+  // We can linearly drop prefix common to both strings since they
+  // don't increase distance at all
+  let start = 0
+
+  while (start < firstLength && first.charCodeAt(start) === second.charCodeAt(start)) {
+    start++
+  }
+
+  firstLength -= start
+  secondLength -= start
+
+  if (firstLength === 0) {
+    return secondLength
+  }
+
+  let bCharacterCode
+  let result: number
+  let temporary: number
+  let temporary2: number
+  let index = 0
+  let index2 = 0
+
+  while (index < firstLength) {
+    characterCodeCache[index] = first.charCodeAt(start + index)
+    array[index] = ++index
+  }
+
+  while (index2 < secondLength) {
+    bCharacterCode = second.charCodeAt(start + index2)
+    temporary = index2++
+    result = index2
+
+    for (index = 0; index < firstLength; index++) {
+      temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1
+      temporary = array[index]!
+      // eslint-disable-next-line no-multi-assign
+      result = array[index] =
+        temporary > result
+          ? temporary2 > result
+            ? result + 1
+            : temporary2
+          : temporary2 > temporary
+          ? temporary + 1
+          : temporary2
+    }
+  }
+
+  return result!
+}