@naturalcycles/js-lib 14.85.0 → 14.88.0

package/dist/decorators/asyncMemo.decorator.d.ts

@@ -12,9 +12,12 @@ export interface AsyncMemoOptions {
      */
     cacheKeyFn?: (args: any[]) => any;
     /**
-     * Set to `true` to cache rejected promises (errors).
+     * Default true.
      *
-     * Default false.
+     * Set to `false` to skip caching rejected promises (errors).
+     *
+     * True will ensure "max 1 execution", but will "remember" rejection.
+     * False will allow >1 execution in case of errors.
      */
     cacheRejections?: boolean;
     /**

package/dist/decorators/asyncMemo.decorator.js

@@ -18,7 +18,7 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
     const originalFn = descriptor.value;
     // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
     const cache = new Map();
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheRejections = true, } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = async function (...args) {
@@ -42,7 +42,10 @@ const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_AsyncMemo hit`);
             }
-            return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         // Here we know it's a MISS, let's execute the real method
         const started = Date.now();

package/dist/decorators/createPromiseDecorator.d.ts

@@ -2,9 +2,9 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
     decoratorName: string;
     /**
      * Called BEFORE the original function.
-     * Returns void.
+     * If Promise is returned - it will be awaited.
      */
-    beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void;
+    beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void | Promise<void>;
     /**
      * Called just AFTER the original function.
      * The output of this hook will be passed further,

package/dist/decorators/createPromiseDecorator.js

@@ -24,12 +24,11 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
         pd.value = async function (...args) {
             // console.log(`@${cfg.decoratorName} called inside function`)
             const started = Date.now();
-            return (Promise.resolve()
+            try {
                 // Before function
-                .then(() => {
                 // console.log(`@${cfg.decoratorName} Before`)
                 if (cfg.beforeFn) {
-                    return cfg.beforeFn({
+                    await cfg.beforeFn({
                         decoratorParams,
                         args,
                         key,
@@ -38,10 +37,8 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
                         started,
                     });
                 }
-            })
                 // Original function
-                .then(() => originalMethod.apply(this, args))
-                .then(res => {
+                let res = await originalMethod.apply(this, args);
                 // console.log(`${cfg.decoratorName} After`)
                 const resp = {
                     decoratorParams,
@@ -59,8 +56,8 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
                 }
                 cfg.finallyFn?.(resp);
                 return res;
-            })
-                .catch(err => {
+            }
+            catch (err) {
                 console.error(`@${decoratorName} ${methodSignature} catch:`, err);
                 const resp = {
                     decoratorParams,
@@ -82,10 +79,7 @@ function _createPromiseDecorator(cfg, decoratorParams = {}) {
                 if (!handled) {
                     throw err; // rethrow
                 }
-            })
-            // es2018 only
-            // .finally(() => {})
-            );
+            }
         };
         return pd;
     };

package/dist/decorators/memo.decorator.d.ts

@@ -12,8 +12,11 @@ export interface MemoOptions {
      */
     cacheKeyFn?: (args: any[]) => any;
     /**
-     * Defaults to false.
-     * Set to true to cache thrown errors.
+     * Defaults to true.
+     * Set to false to skip caching errors.
+     *
+     * True will ensure "max 1 execution", but will "remember" errors.
+     * False will allow >1 execution in case of errors.
      */
     cacheErrors?: boolean;
     /**

package/dist/decorators/memo.decorator.js

@@ -37,12 +37,13 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     // UPD: tests show that normal Map also doesn't leak (to be tested further)
     // Normal Map is needed to allow .dropCache()
     const cache = new Map();
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, cacheErrors = true, } = opt;
     const keyStr = String(key);
     const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
+        let value;
         if (!cache.has(ctx)) {
             cache.set(ctx, cacheFactory());
         }
@@ -50,18 +51,31 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${(0, decorator_util_1._getMethodSignature)(ctx, keyStr)}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) @_Memo hit`);
             }
-            return cache.get(ctx).get(cacheKey);
+            value = cache.get(ctx).get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = originalFn.apply(ctx, args);
-            cache.get(ctx).set(cacheKey, value);
+            try {
+                cache.get(ctx).set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.get(ctx).set(cacheKey, err);
+                try {
+                    cache.get(ctx).set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist/decorators/memoFn.js

@@ -10,28 +10,42 @@ const memo_util_1 = require("./memo.util");
  * Technically, you can use it with Async functions, but it'll return the Promise without awaiting it.
  */
 function _memoFn(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = false, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const fnName = fn.name;
     const memoizedFn = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
+        let value;
         if (cache.has(cacheKey)) {
             if (logHit) {
                 logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFn hit`);
             }
-            return cache.get(cacheKey);
+            value = cache.get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = fn.apply(ctx, args);
-            cache.set(cacheKey, value);
+            try {
+                cache.set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.set(cacheKey, err);
+                try {
+                    cache.set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist/decorators/memoFnAsync.js

@@ -9,7 +9,7 @@ const memo_util_1 = require("./memo.util");
  * To support Async functions - use _memoFnAsync
  */
 function _memoFnAsync(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = false, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = true, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const fnName = fn.name;
     const memoizedFn = async function (...args) {
@@ -26,6 +26,9 @@ function _memoFnAsync(fn, opt = {}) {
             if (logHit) {
                 logger.log(`${fnName}(${(0, decorator_util_1._getArgsSignature)(args, logArgs)}) memoFnAsync hit`);
             }
+            if (value instanceof Error) {
+                throw value;
+            }
             return value;
         }
         const started = Date.now();

package/dist/index.d.ts

@@ -52,7 +52,7 @@ export * from './string/string.util';
 import { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './string/stringifyAny';
 export * from './time/time.util';
 import { Class, ConditionalExcept, ConditionalPick, Merge, Promisable, ReadonlyDeep, Simplify } from './typeFest';
-import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, BatchResult, InstanceId, IsoDate, IsoDateTime, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestamp, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
+import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, BatchResult, InstanceId, IsoDate, IsoDateTime, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestamp, Integer, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
 export * from './unit/size.util';
 import { is } from './vendor/is';
 import { CommonLogLevel, CommonLogFunction, CommonLogger, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, CommonLogWithLevelFunction, commonLoggerCreate } from './log/commonLogger';
@@ -60,5 +60,6 @@ export * from './string/safeJsonStringify';
 import { PQueue, PQueueCfg } from './promise/pQueue';
 export * from './seq/seq';
 export * from './math/stack.util';
-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, 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 * 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/types.d.ts

@@ -124,6 +124,10 @@ export declare type IsoDateTime = string;
  * @example 1628945450
  */
 export declare type UnixTimestamp = number;
+/**
+ * Same as `number`, but with semantic meaning that it's an Integer.
+ */
+export declare type Integer = number;
 /**
  * Base interface for any Entity that was saved to DB.
  */

package/dist-esm/decorators/asyncMemo.decorator.js

@@ -15,7 +15,7 @@ export const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
     const originalFn = descriptor.value;
     // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
     const cache = new Map();
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheRejections = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheRejections = true, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = async function (...args) {
@@ -39,7 +39,10 @@ export const _AsyncMemo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_AsyncMemo hit`);
             }
-            return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         // Here we know it's a MISS, let's execute the real method
         const started = Date.now();

package/dist-esm/decorators/createPromiseDecorator.js

@@ -19,14 +19,14 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
         const key = String(propertyKey);
         const methodSignature = _getTargetMethodSignature(target, key);
         pd.value = async function (...args) {
+            var _a, _b;
             // console.log(`@${cfg.decoratorName} called inside function`)
             const started = Date.now();
-            return (Promise.resolve()
+            try {
                 // Before function
-                .then(() => {
                 // console.log(`@${cfg.decoratorName} Before`)
                 if (cfg.beforeFn) {
-                    return cfg.beforeFn({
+                    await cfg.beforeFn({
                         decoratorParams,
                         args,
                         key,
@@ -35,11 +35,8 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
                         started,
                     });
                 }
-            })
                 // Original function
-                .then(() => originalMethod.apply(this, args))
-                .then(res => {
-                var _a;
+                let res = await originalMethod.apply(this, args);
                 // console.log(`${cfg.decoratorName} After`)
                 const resp = {
                     decoratorParams,
@@ -54,9 +51,8 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
                 }
                 (_a = cfg.finallyFn) === null || _a === void 0 ? void 0 : _a.call(cfg, resp);
                 return res;
-            })
-                .catch(err => {
-                var _a;
+            }
+            catch (err) {
                 console.error(`@${decoratorName} ${methodSignature} catch:`, err);
                 const resp = {
                     decoratorParams,
@@ -71,14 +67,11 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
                     cfg.catchFn(Object.assign(Object.assign({}, resp), { err }));
                     handled = true;
                 }
-                (_a = cfg.finallyFn) === null || _a === void 0 ? void 0 : _a.call(cfg, resp);
+                (_b = cfg.finallyFn) === null || _b === void 0 ? void 0 : _b.call(cfg, resp);
                 if (!handled) {
                     throw err; // rethrow
                 }
-            })
-            // es2018 only
-            // .finally(() => {})
-            );
+            }
         };
         return pd;
     };

package/dist-esm/decorators/memo.decorator.js

@@ -34,12 +34,13 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
     // UPD: tests show that normal Map also doesn't leak (to be tested further)
     // Normal Map is needed to allow .dropCache()
     const cache = new Map();
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheErrors = false, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, cacheErrors = true, } = opt;
     const keyStr = String(key);
     const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
+        let value;
         if (!cache.has(ctx)) {
             cache.set(ctx, cacheFactory());
         }
@@ -47,18 +48,31 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
             if (logHit) {
                 logger.log(`${_getMethodSignature(ctx, keyStr)}(${_getArgsSignature(args, logArgs)}) @_Memo hit`);
             }
-            return cache.get(ctx).get(cacheKey);
+            value = cache.get(ctx).get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = originalFn.apply(ctx, args);
-            cache.get(ctx).set(cacheKey, value);
+            try {
+                cache.get(ctx).set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.get(ctx).set(cacheKey, err);
+                try {
+                    cache.get(ctx).set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist-esm/decorators/memoFn.js

@@ -7,28 +7,42 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util';
  * Technically, you can use it with Async functions, but it'll return the Promise without awaiting it.
  */
 export function _memoFn(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheErrors = true, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const fnName = fn.name;
     const memoizedFn = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
+        let value;
         if (cache.has(cacheKey)) {
             if (logHit) {
                 logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFn hit`);
             }
-            return cache.get(cacheKey);
+            value = cache.get(cacheKey);
+            if (value instanceof Error) {
+                throw value;
+            }
+            return value;
         }
         const started = Date.now();
-        let value;
         try {
             value = fn.apply(ctx, args);
-            cache.set(cacheKey, value);
+            try {
+                cache.set(cacheKey, value);
+            }
+            catch (err) {
+                logger.error(err);
+            }
             return value;
         }
         catch (err) {
             if (cacheErrors) {
-                cache.set(cacheKey, err);
+                try {
+                    cache.set(cacheKey, err);
+                }
+                catch (err) {
+                    logger.error(err);
+                }
             }
             throw err;
         }

package/dist-esm/decorators/memoFnAsync.js

@@ -6,7 +6,7 @@ import { jsonMemoSerializer, MapMemoCache } from './memo.util';
  * To support Async functions - use _memoFnAsync
  */
 export function _memoFnAsync(fn, opt = {}) {
-    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = false, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
+    const { logHit = false, logMiss = false, logArgs = true, logger = console, cacheRejections = true, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const fnName = fn.name;
     const memoizedFn = async function (...args) {
@@ -23,6 +23,9 @@ export function _memoFnAsync(fn, opt = {}) {
             if (logHit) {
                 logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync hit`);
             }
+            if (value instanceof Error) {
+                throw value;
+            }
             return value;
         }
         const started = Date.now();

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.85.0",
+  "version": "14.88.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/decorators/asyncMemo.decorator.ts

@@ -18,9 +18,12 @@ export interface AsyncMemoOptions {
   cacheKeyFn?: (args: any[]) => any
 
   /**
-   * Set to `true` to cache rejected promises (errors).
+   * Default true.
    *
-   * Default false.
+   * Set to `false` to skip caching rejected promises (errors).
+   *
+   * True will ensure "max 1 execution", but will "remember" rejection.
+   * False will allow >1 execution in case of errors.
    */
   cacheRejections?: boolean
 
@@ -73,7 +76,7 @@ export const _AsyncMemo =
       logger = console,
       cacheFactory = () => new MapMemoCache(),
       cacheKeyFn = jsonMemoSerializer,
-      cacheRejections = false,
+      cacheRejections = true,
     } = opt
 
     const keyStr = String(key)
@@ -110,7 +113,11 @@ export const _AsyncMemo =
           )
         }
 
-        return value instanceof Error ? Promise.reject(value) : Promise.resolve(value)
+        if (value instanceof Error) {
+          throw value
+        }
+
+        return value
       }
 
       // Here we know it's a MISS, let's execute the real method

package/src/decorators/createPromiseDecorator.ts

@@ -5,9 +5,9 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
 
   /**
    * Called BEFORE the original function.
-   * Returns void.
+   * If Promise is returned - it will be awaited.
    */
-  beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void
+  beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void | Promise<void>
 
   /**
    * Called just AFTER the original function.
@@ -73,77 +73,71 @@ export function _createPromiseDecorator<RES = any, PARAMS = any>(
       // console.log(`@${cfg.decoratorName} called inside function`)
       const started = Date.now()
 
-      return (
-        Promise.resolve()
-          // Before function
-          .then(() => {
-            // console.log(`@${cfg.decoratorName} Before`)
-            if (cfg.beforeFn) {
-              return cfg.beforeFn({
-                decoratorParams,
-                args,
-                key,
-                target,
-                decoratorName,
-                started,
-              })
-            }
+      try {
+        // Before function
+        // console.log(`@${cfg.decoratorName} Before`)
+        if (cfg.beforeFn) {
+          await cfg.beforeFn({
+            decoratorParams,
+            args,
+            key,
+            target,
+            decoratorName,
+            started,
           })
-          // Original function
-          .then(() => originalMethod.apply(this, args))
-          .then(res => {
-            // console.log(`${cfg.decoratorName} After`)
-            const resp: PromiseDecoratorResp<PARAMS> = {
-              decoratorParams,
-              args,
-              key,
-              target,
-              decoratorName,
-              started,
-            }
-
-            if (cfg.thenFn) {
-              res = cfg.thenFn({
-                ...resp,
-                res,
-              })
-            }
-
-            cfg.finallyFn?.(resp)
-
-            return res
+        }
+
+        // Original function
+        let res = await originalMethod.apply(this, args)
+
+        // console.log(`${cfg.decoratorName} After`)
+        const resp: PromiseDecoratorResp<PARAMS> = {
+          decoratorParams,
+          args,
+          key,
+          target,
+          decoratorName,
+          started,
+        }
+
+        if (cfg.thenFn) {
+          res = cfg.thenFn({
+            ...resp,
+            res,
           })
-          .catch(err => {
-            console.error(`@${decoratorName} ${methodSignature} catch:`, err)
-
-            const resp: PromiseDecoratorResp<PARAMS> = {
-              decoratorParams,
-              args,
-              key,
-              target,
-              decoratorName,
-              started,
-            }
-
-            let handled = false
-
-            if (cfg.catchFn) {
-              cfg.catchFn({
-                ...resp,
-                err,
-              })
-              handled = true
-            }
-
-            cfg.finallyFn?.(resp)
-
-            if (!handled) {
-              throw err // rethrow
-            }
+        }
+
+        cfg.finallyFn?.(resp)
+
+        return res
+      } catch (err) {
+        console.error(`@${decoratorName} ${methodSignature} catch:`, err)
+
+        const resp: PromiseDecoratorResp<PARAMS> = {
+          decoratorParams,
+          args,
+          key,
+          target,
+          decoratorName,
+          started,
+        }
+
+        let handled = false
+
+        if (cfg.catchFn) {
+          cfg.catchFn({
+            ...resp,
+            err,
           })
-        // es2018 only
-        // .finally(() => {})
-      )
+          handled = true
+        }
+
+        cfg.finallyFn?.(resp)
+
+        if (!handled) {
+          throw err // rethrow
+        }
+      }
     }
 
     return pd

package/src/decorators/memo.decorator.ts

@@ -18,8 +18,11 @@ export interface MemoOptions {
   cacheKeyFn?: (args: any[]) => any
 
   /**
-   * Defaults to false.
-   * Set to true to cache thrown errors.
+   * Defaults to true.
+   * Set to false to skip caching errors.
+   *
+   * True will ensure "max 1 execution", but will "remember" errors.
+   * False will allow >1 execution in case of errors.
    */
   cacheErrors?: boolean
 
@@ -89,7 +92,7 @@ export const _Memo =
       logger = console,
       cacheFactory = () => new MapMemoCache(),
       cacheKeyFn = jsonMemoSerializer,
-      cacheErrors = false,
+      cacheErrors = true,
     } = opt
 
     const keyStr = String(key)
@@ -97,8 +100,8 @@ export const _Memo =
 
     descriptor.value = function (this: typeof target, ...args: any[]): any {
       const ctx = this
-
       const cacheKey = cacheKeyFn(args)
+      let value: any
 
       if (!cache.has(ctx)) {
         cache.set(ctx, cacheFactory())
@@ -109,21 +112,34 @@ export const _Memo =
           )
         }
 
-        return cache.get(ctx)!.get(cacheKey)
+        value = cache.get(ctx)!.get(cacheKey)
+
+        if (value instanceof Error) {
+          throw value
+        }
+
+        return value
       }
 
       const started = Date.now()
-      let value: any
 
       try {
         value = originalFn.apply(ctx, args)
 
-        cache.get(ctx)!.set(cacheKey, value)
+        try {
+          cache.get(ctx)!.set(cacheKey, value)
+        } catch (err) {
+          logger.error(err)
+        }
 
         return value
       } catch (err) {
         if (cacheErrors) {
-          cache.get(ctx)!.set(cacheKey, err)
+          try {
+            cache.get(ctx)!.set(cacheKey, err)
+          } catch (err) {
+            logger.error(err)
+          }
         }
 
         throw err

package/src/decorators/memoFn.ts

@@ -21,7 +21,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
     logMiss = false,
     logArgs = true,
     logger = console,
-    cacheErrors = false,
+    cacheErrors = true,
     cacheFactory = () => new MapMemoCache(),
     cacheKeyFn = jsonMemoSerializer,
   } = opt
@@ -32,28 +32,41 @@ export function _memoFn<T extends (...args: any[]) => any>(
   const memoizedFn = function (this: any, ...args: any[]): T {
     const ctx = this
     const cacheKey = cacheKeyFn(args)
+    let value: any
 
     if (cache.has(cacheKey)) {
       if (logHit) {
         logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFn hit`)
       }
 
-      return cache.get(cacheKey)
+      value = cache.get(cacheKey)
+
+      if (value instanceof Error) {
+        throw value
+      }
+
+      return value
     }
 
     const started = Date.now()
 
-    let value: any
-
     try {
       value = fn.apply(ctx, args)
 
-      cache.set(cacheKey, value)
+      try {
+        cache.set(cacheKey, value)
+      } catch (err) {
+        logger.error(err)
+      }
 
       return value
     } catch (err) {
       if (cacheErrors) {
-        cache.set(cacheKey, err)
+        try {
+          cache.set(cacheKey, err)
+        } catch (err) {
+          logger.error(err)
+        }
       }
 
       throw err

package/src/decorators/memoFnAsync.ts

@@ -20,7 +20,7 @@ export function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(
     logMiss = false,
     logArgs = true,
     logger = console,
-    cacheRejections = false,
+    cacheRejections = true,
     cacheFactory = () => new MapMemoCache(),
     cacheKeyFn = jsonMemoSerializer,
   } = opt
@@ -44,6 +44,10 @@ export function _memoFnAsync<T extends (...args: any[]) => Promise<any>>(
         logger.log(`${fnName}(${_getArgsSignature(args, logArgs)}) memoFnAsync hit`)
       }
 
+      if (value instanceof Error) {
+        throw value
+      }
+
       return value
     }
 

package/src/index.ts

@@ -119,6 +119,7 @@ import {
   SavedDBEntity,
   StringMap,
   UnixTimestamp,
+  Integer,
   ValueOf,
   ValuesOf,
   AbortableMapper,
@@ -154,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,
@@ -204,6 +206,7 @@ export type {
   ConditionalExcept,
   Class,
   UnixTimestamp,
+  Integer,
   BaseDBEntity,
   SavedDBEntity,
   Saved,

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!
+}

package/src/types.ts

@@ -166,6 +166,11 @@ export type IsoDateTime = string
  */
 export type UnixTimestamp = number
 
+/**
+ * Same as `number`, but with semantic meaning that it's an Integer.
+ */
+export type Integer = number
+
 /**
  * Base interface for any Entity that was saved to DB.
  */