@naturalcycles/js-lib 14.76.0 → 14.79.0

package/dist/decorators/logMethod.decorator.js

@@ -56,7 +56,7 @@ function _LogMethod(opt = {}) {
                     })
                         .catch((err) => {
                         logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
-                        return Promise.reject(err);
+                        throw err;
                     });
                 }
                 else {

package/dist/decorators/memo.decorator.js

@@ -80,7 +80,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
                     // Wrap as Error if it's not Error
                     cache.get(ctx).set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

package/dist/decorators/memoFn.js

@@ -49,7 +49,7 @@ function _memoFn(fn, opt = {}) {
                     // Wrap as Error if it's not Error
                     cache.set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

package/dist/error/try.js

@@ -27,8 +27,6 @@ function _try(fn) {
     }
 }
 exports._try = _try;
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Like _try, but for Promises.
  *

package/dist/promise/pProps.d.ts

@@ -1,10 +1,19 @@
-import { PMapOptions } from './pMap';
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
 export declare function pProps<T>(input: {
     [K in keyof T]: T[K] | Promise<T[K]>;
-}, opt?: PMapOptions): Promise<{
+}): Promise<{
     [K in keyof T]: Awaited<T[K]>;
 }>;

package/dist/promise/pProps.js

@@ -1,26 +1,22 @@
 "use strict";
-/*
-Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
-
-Improvements:
-
-- Exported as { pProps }, so IDE auto-completion works
-- Simpler: no support for Map, Mapper, Options
-- Included Typescript typings (no need for @types/p-props)
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pProps = void 0;
-const pMap_1 = require("./pMap");
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
-async function pProps(input, opt) {
-    const r = {};
+async function pProps(input) {
     const keys = Object.keys(input);
-    await (0, pMap_1.pMap)(Object.values(input), (v, i) => (r[keys[i]] = v), opt);
-    return r;
+    return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }
 exports.pProps = pProps;

package/dist/promise/pRetry.d.ts

@@ -1,5 +1,10 @@
-import { CommonLogger } from '..';
+import { AnyFunction, CommonLogger } from '..';
 export interface PRetryOptions {
+    /**
+     * If set - will be included in the error message.
+     * Can be used to identify the place in the code that failed.
+     */
+    name?: string;
     /**
      * How many attempts to try.
      * First attempt is not a retry, but "initial try". It still counts.
@@ -62,4 +67,4 @@ export interface PRetryOptions {
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-export declare function pRetry<T extends Function>(fn: T, opt?: PRetryOptions): T;
+export declare function pRetry<T extends AnyFunction>(fn: T, opt?: PRetryOptions): T;

package/dist/promise/pRetry.js

@@ -8,7 +8,7 @@ const __1 = require("..");
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
 function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, } = opt;
+    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name = fn.name, } = opt;
     let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
     if (opt.logAll) {
         logFirstAttempt = logRetries = logFailures = true;
@@ -16,7 +16,7 @@ function pRetry(fn, opt = {}) {
     if (opt.logNone) {
         logSuccess = logFirstAttempt = logRetries = logFailures = false;
     }
-    const fname = ['pRetry', fn.name].filter(Boolean).join('.');
+    const fname = ['pRetry', name].filter(Boolean).join('.');
     return async function (...args) {
         let delay = initialDelay;
         let attempt = 0;
@@ -36,9 +36,9 @@ function pRetry(fn, opt = {}) {
                 }
                 catch (err) {
                     if (logFailures) {
-                        logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:\n${(0, __1._stringifyAny)(err, {
+                        logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, (0, __1._stringifyAny)(err, {
                             includeErrorData: true,
-                        })}`);
+                        }));
                     }
                     if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                         // Give up

package/dist/promise/pTimeout.d.ts

@@ -17,6 +17,14 @@ export interface PTimeoutOptions {
      * Can be used to thrown a custom error OR resolve a promise without throwing.
      */
     onTimeout?: () => any;
+    /**
+     * Defaults to true.
+     * If true - preserves the stack trace in case of a Timeout (usually - very useful!).
+     * It has a certain perf cost.
+     *
+     * @experimental
+     */
+    keepStackTrace?: boolean;
 }
 /**
  * Decorates a Function with a timeout.

package/dist/promise/pTimeout.js

@@ -24,7 +24,8 @@ exports.pTimeoutFn = pTimeoutFn;
  */
 async function pTimeout(promise, opt) {
     // todo: check how we can automatically infer function name (only applicable to named functions)
-    const { timeout, name, onTimeout } = opt;
+    const { timeout, name, onTimeout, keepStackTrace = true } = opt;
+    const fakeError = keepStackTrace ? new Error('TimeoutError') : undefined;
     // eslint-disable-next-line no-async-promise-executor
     return await new Promise(async (resolve, reject) => {
         // Prepare the timeout timer
@@ -34,11 +35,16 @@ async function pTimeout(promise, opt) {
                     resolve(onTimeout());
                 }
                 catch (err) {
+                    if (fakeError)
+                        err.stack = fakeError.stack; // keep original stack
                     reject(err);
                 }
                 return;
             }
-            reject(new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`));
+            const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`);
+            if (fakeError)
+                err.stack = fakeError.stack; // keep original stack
+            reject(err);
         }, timeout);
         // Execute the Function
         try {

package/dist/types.d.ts

@@ -95,8 +95,8 @@ export declare type ValuesOf<T extends readonly any[]> = T[number];
  */
 export declare type ValueOf<T> = T[keyof T];
 export declare type KeyValueTuple<K, V> = [key: K, value: V];
-export declare type ObjectMapper<OBJ, OUT> = (key: string, value: OBJ[keyof OBJ], obj: OBJ) => OUT;
-export declare type ObjectPredicate<OBJ> = (key: keyof OBJ, value: OBJ[keyof OBJ], obj: OBJ) => boolean;
+export declare type ObjectMapper<OBJ, OUT> = (key: string, value: Exclude<OBJ[keyof OBJ], undefined>, obj: OBJ) => OUT;
+export declare type ObjectPredicate<OBJ> = (key: keyof OBJ, value: Exclude<OBJ[keyof OBJ], undefined>, obj: OBJ) => boolean;
 /**
  * Allows to identify instance of Class by `instanceId`.
  */

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

@@ -53,7 +53,7 @@ export function _LogMethod(opt = {}) {
                     })
                         .catch((err) => {
                         logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
-                        return Promise.reject(err);
+                        throw err;
                     });
                 }
                 else {

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

@@ -77,7 +77,7 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
                     // Wrap as Error if it's not Error
                     cache.get(ctx).set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

package/dist-esm/decorators/memoFn.js

@@ -46,7 +46,7 @@ export function _memoFn(fn, opt = {}) {
                     // Wrap as Error if it's not Error
                     cache.set(cacheKey, err instanceof Error ? err : new Error(err));
                 }
-                return Promise.reject(err);
+                throw err;
             });
         }
         else {

package/dist-esm/error/try.js

@@ -23,8 +23,6 @@ export function _try(fn) {
         return [err, undefined];
     }
 }
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Like _try, but for Promises.
  *

package/dist-esm/promise/pProps.js

@@ -1,22 +1,18 @@
-/*
-Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
-
-Improvements:
-
-- Exported as { pProps }, so IDE auto-completion works
-- Simpler: no support for Map, Mapper, Options
-- Included Typescript typings (no need for @types/p-props)
- */
-import { pMap } from './pMap';
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
-export async function pProps(input, opt) {
-    const r = {};
+export async function pProps(input) {
     const keys = Object.keys(input);
-    await pMap(Object.values(input), (v, i) => (r[keys[i]] = v), opt);
-    return r;
+    return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }

package/dist-esm/promise/pRetry.js

@@ -5,7 +5,7 @@ import { _since, _stringifyAny } from '..';
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function pRetry(fn, opt = {}) {
-    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, } = opt;
+    const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name = fn.name, } = opt;
     let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
     if (opt.logAll) {
         logFirstAttempt = logRetries = logFailures = true;
@@ -13,7 +13,7 @@ export function pRetry(fn, opt = {}) {
     if (opt.logNone) {
         logSuccess = logFirstAttempt = logRetries = logFailures = false;
     }
-    const fname = ['pRetry', fn.name].filter(Boolean).join('.');
+    const fname = ['pRetry', name].filter(Boolean).join('.');
     return async function (...args) {
         let delay = initialDelay;
         let attempt = 0;
@@ -33,9 +33,9 @@ export function pRetry(fn, opt = {}) {
                 }
                 catch (err) {
                     if (logFailures) {
-                        logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:\n${_stringifyAny(err, {
+                        logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, _stringifyAny(err, {
                             includeErrorData: true,
-                        })}`);
+                        }));
                     }
                     if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                         // Give up

package/dist-esm/promise/pTimeout.js

@@ -19,7 +19,8 @@ export function pTimeoutFn(fn, opt) {
  */
 export async function pTimeout(promise, opt) {
     // todo: check how we can automatically infer function name (only applicable to named functions)
-    const { timeout, name, onTimeout } = opt;
+    const { timeout, name, onTimeout, keepStackTrace = true } = opt;
+    const fakeError = keepStackTrace ? new Error('TimeoutError') : undefined;
     // eslint-disable-next-line no-async-promise-executor
     return await new Promise(async (resolve, reject) => {
         // Prepare the timeout timer
@@ -29,11 +30,16 @@ export async function pTimeout(promise, opt) {
                     resolve(onTimeout());
                 }
                 catch (err) {
+                    if (fakeError)
+                        err.stack = fakeError.stack; // keep original stack
                     reject(err);
                 }
                 return;
             }
-            reject(new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`));
+            const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`);
+            if (fakeError)
+                err.stack = fakeError.stack; // keep original stack
+            reject(err);
         }, timeout);
         // Execute the Function
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.76.0",
+  "version": "14.79.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -14,13 +14,14 @@
     "@naturalcycles/bench-lib": "^1.5.0",
     "@naturalcycles/dev-lib": "^12.0.0",
     "@naturalcycles/nodejs-lib": "^12.33.4",
-    "@types/node": "^16.0.0",
+    "@types/node": "^17.0.4",
     "jest": "^27.0.1",
     "patch-package": "^6.2.1",
     "prettier": "^2.1.2",
     "rxjs": "^7.0.1",
     "vuepress": "^1.7.1",
-    "vuepress-plugin-typescript": "^0.3.1"
+    "vuepress-plugin-typescript": "^0.3.1",
+    "weak-napi": "^2.0.2"
   },
   "files": [
     "dist",

package/src/decorators/logMethod.decorator.ts

@@ -110,7 +110,7 @@ export function _LogMethod(opt: LogMethodOptions = {}): MethodDecorator {
             })
             .catch((err: any) => {
               logFinished(logger, callSignature, started, sma, logResultFn, undefined, err)
-              return Promise.reject(err)
+              throw err
             })
         } else {
           // not a Promise

package/src/decorators/memo.decorator.ts

@@ -163,7 +163,7 @@ export const _Memo =
               cache.get(ctx)!.set(cacheKey, err instanceof Error ? err : new Error(err))
             }
 
-            return Promise.reject(err)
+            throw err
           })
       } else {
         if (logMiss) {

package/src/decorators/memoFn.ts

@@ -83,7 +83,7 @@ export function _memoFn<T extends (...args: any[]) => any>(
             cache.set(cacheKey, err instanceof Error ? err : new Error(err))
           }
 
-          return Promise.reject(err)
+          throw err
         }) as any
     } else {
       if (logMiss) {

package/src/error/try.ts

@@ -27,9 +27,6 @@ export function _try<ERR = unknown, RETURN = void>(
   }
 }
 
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
-
 /**
  * Like _try, but for Promises.
  *

package/src/promise/pProps.ts

@@ -1,28 +1,20 @@
-/*
-Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
-
-Improvements:
-
-- Exported as { pProps }, so IDE auto-completion works
-- Simpler: no support for Map, Mapper, Options
-- Included Typescript typings (no need for @types/p-props)
- */
-
-import { pMap, PMapOptions } from './pMap'
-
-// todo: remove when eslint starts to know about Awaited
-/* eslint-disable no-undef */
-
 /**
  * Promise.all for Object instead of Array.
- * Supports concurrency.
+ *
+ * Inspired by Bluebird Promise.props() and https://github.com/sindresorhus/p-props
+ *
+ * Improvements:
+ *
+ * - Exported as { pProps }, so IDE auto-completion works
+ * - Simpler: no support for Map, Mapper, Options
+ * - Included Typescript typings (no need for @types/p-props)
+ *
+ * Concurrency implementation via pMap was removed in favor of preserving async
+ * stack traces (more important!).
  */
-export async function pProps<T>(
-  input: { [K in keyof T]: T[K] | Promise<T[K]> },
-  opt?: PMapOptions,
-): Promise<{ [K in keyof T]: Awaited<T[K]> }> {
-  const r = {} as { [K in keyof T]: Awaited<T[K]> }
-  const keys = Object.keys(input) as (keyof T)[]
-  await pMap(Object.values(input), (v, i) => (r[keys[i]!] = v), opt)
-  return r
+export async function pProps<T>(input: { [K in keyof T]: T[K] | Promise<T[K]> }): Promise<{
+  [K in keyof T]: Awaited<T[K]>
+}> {
+  const keys = Object.keys(input)
+  return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]))
 }

package/src/promise/pRetry.ts

@@ -1,6 +1,12 @@
-import { _since, _stringifyAny, CommonLogger } from '..'
+import { _since, _stringifyAny, AnyFunction, CommonLogger } from '..'
 
 export interface PRetryOptions {
+  /**
+   * If set - will be included in the error message.
+   * Can be used to identify the place in the code that failed.
+   */
+  name?: string
+
   /**
    * How many attempts to try.
    * First attempt is not a retry, but "initial try". It still counts.
@@ -75,13 +81,14 @@ export interface PRetryOptions {
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
+export function pRetry<T extends AnyFunction>(fn: T, opt: PRetryOptions = {}): T {
   const {
     maxAttempts = 4,
     delay: initialDelay = 1000,
     delayMultiplier = 2,
     predicate,
     logger = console,
+    name = fn.name,
   } = opt
 
   let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt
@@ -93,7 +100,7 @@ export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
     logSuccess = logFirstAttempt = logRetries = logFailures = false
   }
 
-  const fname = ['pRetry', fn.name].filter(Boolean).join('.')
+  const fname = ['pRetry', name].filter(Boolean).join('.')
 
   return async function (this: any, ...args: any[]) {
     let delay = initialDelay
@@ -118,9 +125,10 @@ export function pRetry<T extends Function>(fn: T, opt: PRetryOptions = {}): T {
         } catch (err) {
           if (logFailures) {
             logger.warn(
-              `${fname} attempt #${attempt} error in ${_since(started)}:\n${_stringifyAny(err, {
+              `${fname} attempt #${attempt} error in ${_since(started)}:`,
+              _stringifyAny(err, {
                 includeErrorData: true,
-              })}`,
+              }),
             )
           }
 

package/src/promise/pTimeout.ts

@@ -20,6 +20,15 @@ export interface PTimeoutOptions {
    * Can be used to thrown a custom error OR resolve a promise without throwing.
    */
   onTimeout?: () => any
+
+  /**
+   * Defaults to true.
+   * If true - preserves the stack trace in case of a Timeout (usually - very useful!).
+   * It has a certain perf cost.
+   *
+   * @experimental
+   */
+  keepStackTrace?: boolean
 }
 
 /**
@@ -42,7 +51,8 @@ export function pTimeoutFn<T extends AnyFunction>(fn: T, opt: PTimeoutOptions):
  */
 export async function pTimeout<T>(promise: Promise<T>, opt: PTimeoutOptions): Promise<T> {
   // todo: check how we can automatically infer function name (only applicable to named functions)
-  const { timeout, name, onTimeout } = opt
+  const { timeout, name, onTimeout, keepStackTrace = true } = opt
+  const fakeError = keepStackTrace ? new Error('TimeoutError') : undefined
 
   // eslint-disable-next-line no-async-promise-executor
   return await new Promise(async (resolve, reject) => {
@@ -51,13 +61,16 @@ export async function pTimeout<T>(promise: Promise<T>, opt: PTimeoutOptions): Pr
       if (onTimeout) {
         try {
           resolve(onTimeout())
-        } catch (err) {
+        } catch (err: any) {
+          if (fakeError) err.stack = fakeError.stack // keep original stack
           reject(err)
         }
         return
       }
 
-      reject(new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`))
+      const err = new TimeoutError(`"${name || 'pTimeout function'}" timed out after ${timeout} ms`)
+      if (fakeError) err.stack = fakeError.stack // keep original stack
+      reject(err)
     }, timeout)
 
     // Execute the Function

package/src/types.ts

@@ -122,9 +122,18 @@ export type ValueOf<T> = T[keyof T]
 
 export type KeyValueTuple<K, V> = [key: K, value: V]
 
-export type ObjectMapper<OBJ, OUT> = (key: string, value: OBJ[keyof OBJ], obj: OBJ) => OUT
-
-export type ObjectPredicate<OBJ> = (key: keyof OBJ, value: OBJ[keyof OBJ], obj: OBJ) => boolean
+// Exclude<something, undefined> is used here to support StringMap<OBJ> (because values of StringMap add `undefined`)
+export type ObjectMapper<OBJ, OUT> = (
+  key: string,
+  value: Exclude<OBJ[keyof OBJ], undefined>,
+  obj: OBJ,
+) => OUT
+
+export type ObjectPredicate<OBJ> = (
+  key: keyof OBJ,
+  value: Exclude<OBJ[keyof OBJ], undefined>,
+  obj: OBJ,
+) => boolean
 
 /**
  * Allows to identify instance of Class by `instanceId`.