@naturalcycles/js-lib 14.78.1 → 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-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/package.json

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

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]))
 }