@naturalcycles/js-lib 14.78.0 → 14.78.1

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-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.78.0",
+  "version": "14.78.1",
   "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/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