@naturalcycles/js-lib 14.129.0 → 14.130.0

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

@@ -6,11 +6,11 @@ export interface AsyncMemoOptions {
      * Function that creates an instance of `MemoCache`.
      * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`.
      */
-    cacheFactory?(): AsyncMemoCache;
+    cacheFactory?: () => AsyncMemoCache;
     /**
      * Provide a custom implementation of CacheKey function.
      */
-    cacheKeyFn?(args: any[]): any;
+    cacheKeyFn?: (args: any[]) => any;
     /**
      * Default true.
      *

package/dist/decorators/createPromiseDecorator.d.ts

@@ -4,15 +4,15 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
      * Called BEFORE the original function.
      * If Promise is returned - it will be awaited.
      */
-    beforeFn?(r: PromiseDecoratorResp<PARAMS>): void | Promise<void>;
+    beforeFn?: (r: PromiseDecoratorResp<PARAMS>) => void | Promise<void>;
     /**
      * Called just AFTER the original function.
      * The output of this hook will be passed further,
      * so, pay attention to pass through (or modify) the result.
      */
-    thenFn?(r: PromiseDecoratorResp<PARAMS> & {
+    thenFn?: (r: PromiseDecoratorResp<PARAMS> & {
         res: RES;
-    }): RES;
+    }) => RES;
     /**
      * Called on Promise.reject.
      * If `catchFn` is not present - will re-throw the error,
@@ -20,14 +20,14 @@ export interface PromiseDecoratorCfg<RES = any, PARAMS = any> {
      * If `catchFn` is present - it's responsible for handling or re-throwing the error.
      * Whatever `catchFn` returns - passed to the original output.
      */
-    catchFn?(r: PromiseDecoratorResp<PARAMS> & {
+    catchFn?: (r: PromiseDecoratorResp<PARAMS> & {
         err: any;
-    }): RES;
+    }) => RES;
     /**
      * Fires AFTER thenFn / catchFn, like a usual Promise.finally().
      * Doesn't have access to neither res nor err (same as Promise.finally).
      */
-    finallyFn?(r: PromiseDecoratorResp<PARAMS>): any;
+    finallyFn?: (r: PromiseDecoratorResp<PARAMS>) => any;
 }
 export interface PromiseDecoratorResp<PARAMS> {
     decoratorParams: PARAMS;

package/dist/decorators/debounce.d.ts

@@ -1,7 +1,7 @@
 import type { AnyFunction } from '../types';
 export interface Cancelable {
-    cancel(): void;
-    flush(): void;
+    cancel: () => void;
+    flush: () => void;
 }
 export interface ThrottleOptions {
     /**

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

@@ -6,11 +6,11 @@ export interface MemoOptions {
      * Function that creates an instance of `MemoCache`.
      * e.g LRUMemoCache from `@naturalcycles/nodejs-lib`
      */
-    cacheFactory?(): MemoCache;
+    cacheFactory?: () => MemoCache;
     /**
      * Provide a custom implementation of CacheKey function.
      */
-    cacheKeyFn?(args: any[]): any;
+    cacheKeyFn?: (args: any[]) => any;
     /**
      * Defaults to true.
      * Set to false to skip caching errors.

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

@@ -2,14 +2,14 @@ import type { Promisable } from '../typeFest';
 export type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
 export interface MemoCache<KEY = any, VALUE = any> {
-    has(k: KEY): boolean;
-    get(k: KEY): VALUE | Error | undefined;
-    set(k: KEY, v: VALUE | Error): void;
+    has: (k: KEY) => boolean;
+    get: (k: KEY) => VALUE | Error | undefined;
+    set: (k: KEY, v: VALUE | Error) => void;
     /**
      * Clear is only called when `.dropCache()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
      */
-    clear(): void;
+    clear: () => void;
 }
 export interface AsyncMemoCache<KEY = any, VALUE = any> {
     /**
@@ -17,13 +17,13 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
      * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
      * You CAN store `null` value instead, it will be treated as a HIT.
      */
-    get(k: KEY): Promisable<VALUE | Error | undefined>;
-    set(k: KEY, v: VALUE | Error): Promisable<void>;
+    get: (k: KEY) => Promisable<VALUE | Error | undefined>;
+    set: (k: KEY, v: VALUE | Error) => Promisable<void>;
     /**
      * Clear is only called when `.dropCache()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
      */
-    clear(): Promisable<void>;
+    clear: () => Promisable<void>;
 }
 export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE> {
     private m;

package/dist/error/app.error.d.ts

@@ -10,5 +10,5 @@ import type { ErrorData } from './error.model';
  */
 export declare class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
     data: DATA_TYPE;
-    constructor(message: string, data?: DATA_TYPE);
+    constructor(message: string, data?: DATA_TYPE, opt?: ErrorOptions);
 }

package/dist/error/app.error.js

@@ -11,8 +11,8 @@ exports.AppError = void 0;
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 class AppError extends Error {
-    constructor(message, data = {}) {
-        super(message);
+    constructor(message, data = {}, opt) {
+        super(message, opt);
         Object.defineProperty(this, 'name', {
             value: this.constructor.name,
             configurable: true,

package/dist/error/assert.d.ts

@@ -36,5 +36,4 @@ export declare function _assertIsString(v: any, message?: string): asserts v is
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;
 export declare function _assertTypeOf<T>(v: any, expectedType: string, message?: string): asserts v is T;
 export declare class AssertionError extends AppError {
-    constructor(message: string, data?: ErrorData);
 }

package/dist/error/assert.js

@@ -103,8 +103,5 @@ function _assertTypeOf(v, expectedType, message) {
 }
 exports._assertTypeOf = _assertTypeOf;
 class AssertionError extends app_error_1.AppError {
-    constructor(message, data = {}) {
-        super(message, data);
-    }
 }
 exports.AssertionError = AssertionError;

package/dist/error/error.model.d.ts

@@ -93,6 +93,7 @@ export interface ErrorObject<DATA_TYPE extends ErrorData = ErrorData> {
      * It's non-optional, to save some null-checks.
      */
     data: DATA_TYPE;
+    cause?: any;
 }
 /**
  * JSON HTTP response from the Backend that represents "Error".

package/dist/error/error.util.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, StringifyAnyOptions, Class } from '..';
+import type { ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Class } from '..';
 import { AppError } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -8,15 +8,15 @@ import { AppError } from '..';
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-export declare function _anyToError<ERROR_TYPE extends Error = Error>(o: any, errorClass?: Class<ERROR_TYPE>, errorData?: ErrorData, opt?: StringifyAnyOptions): ERROR_TYPE;
+export declare function _anyToError<ERROR_TYPE extends Error = Error>(o: any, errorClass?: Class<ERROR_TYPE>, errorData?: ErrorData): ERROR_TYPE;
 /**
  * Converts "anything" to ErrorObject.
  * Detects if it's HttpErrorResponse, HttpErrorObject, ErrorObject, Error, etc..
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
-export declare function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(o: any, errorData?: Partial<DATA_TYPE>, opt?: StringifyAnyOptions): ErrorObject<DATA_TYPE>;
-export declare function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(e: AppError<DATA_TYPE> | Error, includeErrorStack?: boolean): ErrorObject<DATA_TYPE>;
+export declare function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(o: any, errorData?: Partial<DATA_TYPE>): ErrorObject<DATA_TYPE>;
+export declare function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(e: AppError<DATA_TYPE> | Error): ErrorObject<DATA_TYPE>;
 export declare function _errorObjectToAppError<DATA_TYPE extends ErrorData>(o: ErrorObject<DATA_TYPE>): AppError<DATA_TYPE>;
 export declare function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE extends Error>(o: ErrorObject<DATA_TYPE>, errorClass?: Class<ERROR_TYPE>): ERROR_TYPE;
 export declare function _isHttpErrorResponse(o: any): o is HttpErrorResponse;

package/dist/error/error.util.js

@@ -10,14 +10,14 @@ const __1 = require("..");
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-function _anyToError(o, errorClass = Error, errorData, opt) {
+function _anyToError(o, errorClass = Error, errorData) {
     let e;
     if (o instanceof errorClass) {
         e = o;
     }
     else {
         // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
-        const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt);
+        const errorObject = _anyToErrorObject(o);
         e = _errorObjectToError(errorObject, errorClass);
     }
     if (errorData) {
@@ -36,10 +36,10 @@ exports._anyToError = _anyToError;
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
-function _anyToErrorObject(o, errorData, opt) {
+function _anyToErrorObject(o, errorData) {
     let eo;
     if (o instanceof Error) {
-        eo = _errorToErrorObject(o, opt?.includeErrorStack ?? true);
+        eo = _errorToErrorObject(o);
     }
     else {
         o = (0, __1._jsonParseIfPossible)(o);
@@ -54,10 +54,7 @@ function _anyToErrorObject(o, errorData, opt) {
             // so, fair to return `data: {}` in the end
             // Also we're sure it includes no "error name", e.g no `Error: ...`,
             // so, fair to include `name: 'Error'`
-            const message = (0, __1._stringifyAny)(o, {
-                includeErrorData: true,
-                ...opt,
-            });
+            const message = (0, __1._stringifyAny)(o);
             eo = {
                 name: 'Error',
                 message,
@@ -69,14 +66,15 @@ function _anyToErrorObject(o, errorData, opt) {
     return eo;
 }
 exports._anyToErrorObject = _anyToErrorObject;
-function _errorToErrorObject(e, includeErrorStack = true) {
+function _errorToErrorObject(e) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: { ...e.data }, // empty by default
+        data: { ...e.data },
+        stack: e.stack,
     };
-    if (includeErrorStack) {
-        obj.stack = e.stack;
+    if (e.cause) {
+        obj.cause = _anyToErrorObject(e.cause);
     }
     return obj;
 }
@@ -106,6 +104,14 @@ function _errorObjectToError(o, errorClass = Error) {
             value: o.stack,
         });
     }
+    if (o.cause) {
+        Object.defineProperty(err, 'cause', {
+            value: o.cause,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
     return err;
 }
 exports._errorObjectToError = _errorObjectToError;
@@ -124,9 +130,16 @@ exports._isHttpErrorObject = _isHttpErrorObject;
  * Note: any instance of AppError is also automatically an ErrorObject
  */
 function _isErrorObject(o) {
-    return (!!o && typeof o.name === 'string' && typeof o.message === 'string' && typeof o.data === 'object');
+    return (!!o &&
+        typeof o === 'object' &&
+        typeof o.name === 'string' &&
+        typeof o.message === 'string' &&
+        typeof o.data === 'object');
 }
 exports._isErrorObject = _isErrorObject;
+// export function _isErrorLike(o: any): o is ErrorLike {
+//   return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string'
+// }
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/dist/error/errorMode.d.ts

@@ -9,7 +9,7 @@ export declare enum ErrorMode {
      */
     THROW_IMMEDIATELY = "THROW_IMMEDIATELY",
     /**
-     * Don't throw on errors, but collect them and throw as AggregatedError in the end.
+     * Don't throw on errors, but collect them and throw as AggregateError in the end.
      */
     THROW_AGGREGATED = "THROW_AGGREGATED",
     /**

package/dist/error/errorMode.js

@@ -13,7 +13,7 @@ var ErrorMode;
      */
     ErrorMode["THROW_IMMEDIATELY"] = "THROW_IMMEDIATELY";
     /**
-     * Don't throw on errors, but collect them and throw as AggregatedError in the end.
+     * Don't throw on errors, but collect them and throw as AggregateError in the end.
      */
     ErrorMode["THROW_AGGREGATED"] = "THROW_AGGREGATED";
     /**

package/dist/error/http.error.d.ts

@@ -4,5 +4,5 @@ import type { HttpErrorData } from './error.model';
  * Base class for HTTP errors - errors that define HTTP error code.
  */
 export declare class HttpError<DATA_TYPE extends HttpErrorData = HttpErrorData> extends AppError<DATA_TYPE> {
-    constructor(message: string, data: DATA_TYPE);
+    constructor(message: string, data: DATA_TYPE, opt?: ErrorOptions);
 }

package/dist/error/http.error.js

@@ -6,8 +6,8 @@ const app_error_1 = require("./app.error");
  * Base class for HTTP errors - errors that define HTTP error code.
  */
 class HttpError extends app_error_1.AppError {
-    constructor(message, data) {
-        super(message, data);
+    constructor(message, data, opt) {
+        super(message, data, opt);
     }
 }
 exports.HttpError = HttpError;

package/dist/error/tryCatch.d.ts

@@ -5,7 +5,7 @@ export interface TryCatchOptions {
      * The value returned from the function will be returned from the wrapped method (!).
      * onError function may be asynchronous.
      */
-    onError?(err: Error): any;
+    onError?: (err: Error) => any;
     /**
      * @default false
      */

package/dist/http/fetcher.js

@@ -151,11 +151,12 @@ class Fetcher {
                                 res.body = JSON.parse(text, req.jsonReviver);
                             }
                             catch (err) {
-                                res.ok = false;
-                                res.err = (0, error_util_1._anyToError)(err, http_error_1.HttpError, (0, object_util_1._filterNullishValues)({
+                                const { message } = (0, error_util_1._anyToError)(err);
+                                res.err = new http_error_1.HttpError([signature, message].join('\n'), {
                                     httpStatusCode: 0,
                                     url: req.url,
-                                }));
+                                });
+                                res.ok = false;
                             }
                         }
                         else {

package/dist/index.d.ts

@@ -37,7 +37,6 @@ export * from './object/deepEquals';
 export * from './object/object.util';
 export * from './object/sortObject';
 export * from './object/sortObjectDeep';
-export * from './promise/AggregatedError';
 export * from './promise/pDefer';
 export * from './promise/pDelay';
 export * from './promise/pFilter';

package/dist/index.js

@@ -41,7 +41,6 @@ tslib_1.__exportStar(require("./object/deepEquals"), exports);
 tslib_1.__exportStar(require("./object/object.util"), exports);
 tslib_1.__exportStar(require("./object/sortObject"), exports);
 tslib_1.__exportStar(require("./object/sortObjectDeep"), exports);
-tslib_1.__exportStar(require("./promise/AggregatedError"), exports);
 tslib_1.__exportStar(require("./promise/pDefer"), exports);
 tslib_1.__exportStar(require("./promise/pDelay"), exports);
 tslib_1.__exportStar(require("./promise/pFilter"), exports);

package/dist/json-schema/jsonSchemaBuilder.d.ts

@@ -2,7 +2,7 @@
 import type { BaseDBEntity, JsonSchemaAllOf, JsonSchemaArray, JsonSchemaOneOf, JsonSchemaTuple, SavedDBEntity, AnyObject } from '../index';
 import type { JsonSchema, JsonSchemaAny, JsonSchemaBoolean, JsonSchemaConst, JsonSchemaEnum, JsonSchemaNull, JsonSchemaNumber, JsonSchemaObject, JsonSchemaRef, JsonSchemaString } from './jsonSchema.model';
 export interface JsonSchemaBuilder<T = unknown> {
-    build(): JsonSchema<T>;
+    build: () => JsonSchema<T>;
 }
 /**
  * Fluent (chainable) API to manually create Json Schemas.

package/dist/promise/pDefer.d.ts

@@ -2,8 +2,8 @@
  * Similar to Deferred object, which is also a promise itself (instead of deferred.promise).
  */
 export interface DeferredPromise<T = void> extends Promise<T> {
-    resolve(a?: T): void;
-    reject(e?: Error): void;
+    resolve: (a?: T) => void;
+    reject: (e?: Error) => void;
 }
 /**
  * Returns DeferredPromise - a Promise that has .resolve() and .reject() methods.

package/dist/promise/pMap.js

@@ -10,7 +10,6 @@ Improvements:
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pMap = void 0;
 const __1 = require("..");
-const AggregatedError_1 = require("./AggregatedError");
 /**
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
  * or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned
@@ -70,7 +69,7 @@ async function pMap(iterable, mapper, opt = {}) {
             }
         }
         if (errors.length) {
-            throw new AggregatedError_1.AggregatedError(errors, ret);
+            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
         }
         return ret;
     }
@@ -90,7 +89,7 @@ async function pMap(iterable, mapper, opt = {}) {
             }
         });
         if (errors.length) {
-            throw new AggregatedError_1.AggregatedError(errors, ret);
+            throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);
         }
         return ret;
     }
@@ -106,7 +105,7 @@ async function pMap(iterable, mapper, opt = {}) {
                     isSettled = true;
                     const r = ret.filter(r => r !== __1.SKIP);
                     if (errors.length) {
-                        reject(new AggregatedError_1.AggregatedError(errors, r));
+                        reject(new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`));
                     }
                     else {
                         resolve(r);

package/dist/promise/pRetry.d.ts

@@ -35,7 +35,7 @@ export interface PRetryOptions {
      *
      * @default () => true
      */
-    predicate?(err: Error, attempt: number, maxAttempts: number): boolean;
+    predicate?: (err: Error, attempt: number, maxAttempts: number) => boolean;
     /**
      * Log the first attempt (which is not a "retry" yet).
      *

package/dist/promise/pTimeout.d.ts

@@ -20,7 +20,7 @@ export interface PTimeoutOptions {
      * err (which is TimeoutError) is passed as an argument for convenience, so it can
      * be logged or such. You don't have to consume it in any way though.
      */
-    onTimeout?(err: TimeoutError): any;
+    onTimeout?: (err: TimeoutError) => any;
     /**
      * Defaults to true.
      * If true - preserves the stack trace in case of a Timeout (usually - very useful!).

package/dist/string/pupa.d.ts

@@ -11,10 +11,10 @@ export interface PupaOptions {
     /**
      * Performs arbitrary operation for each interpolation. If the returned value was `undefined`, it behaves differently depending on the `ignoreMissing` option. Otherwise, the returned value will be interpolated into a string (and escaped when double-braced) and embedded into the template.
      */
-    transform?(data: {
+    transform?: (data: {
         value: any;
         key: string;
-    }): unknown;
+    }) => unknown;
 }
 /**
  * API: https://github.com/sindresorhus/pupa

package/dist/string/readingTime.d.ts

@@ -4,7 +4,7 @@ export interface ReadingTimeOptions {
      * A function that returns a boolean value depending on if a character is considered as a word bound.
      * Default: spaces, new lines and tabs
      */
-    wordBound?(char: string): boolean;
+    wordBound?: (char: string) => boolean;
     /**
      * Default 200
      */

package/dist/string/stringifyAny.d.ts

@@ -32,6 +32,12 @@ export interface StringifyAnyOptions {
      * @default false
      */
     includeErrorStack?: boolean;
+    /**
+     * Set to false to skip including Error.cause.
+     *
+     * @default true
+     */
+    includeErrorCause?: boolean;
     /**
      * Allows to pass custom "stringify function".
      * E.g in Node.js you can pass `util.inspect` instead.

package/dist/string/stringifyAny.js

@@ -4,6 +4,7 @@ exports._stringifyAny = exports.setGlobalStringifyFunction = void 0;
 const error_util_1 = require("../error/error.util");
 const json_util_1 = require("./json.util");
 const safeJsonStringify_1 = require("./safeJsonStringify");
+const supportsAggregateError = typeof globalThis.AggregateError === 'function';
 let globalStringifyFunction = safeJsonStringify_1._safeJsonStringify;
 /**
  * Allows to set Global "stringifyFunction" that will be used to "pretty-print" objects
@@ -59,6 +60,7 @@ function _stringifyAny(obj, opt = {}) {
         return _stringifyAny(obj.error, opt);
     }
     if (obj instanceof Error || (0, error_util_1._isErrorObject)(obj)) {
+        const { includeErrorCause = true } = opt;
         //
         // Error or ErrorObject
         //
@@ -67,7 +69,7 @@ function _stringifyAny(obj, opt = {}) {
         // if (obj?.name === 'Error') {
         //   s = obj.message
         // }
-        s = [obj.name, obj.message].join(': ');
+        s = [obj.name, obj.message].filter(Boolean).join(': ');
         if (opt.includeErrorStack && obj.stack) {
             // Here we're using the previously-generated "title line" (e.g "Error: some_message"),
             // concatenating it with the Stack (but without the title line of the Stack)
@@ -92,6 +94,16 @@ function _stringifyAny(obj, opt = {}) {
             // Error that has no `data`, but has `code` property
             s = [s, `code: ${obj.code}`].join('\n');
         }
+        if (supportsAggregateError && obj instanceof AggregateError && obj.errors.length) {
+            s = [
+                s,
+                `${obj.errors.length} error(s):`,
+                ...obj.errors.map((err, i) => `${i + 1}. ${_stringifyAny(err, opt)}`),
+            ].join('\n');
+        }
+        if (obj.cause && includeErrorCause) {
+            s = s + '\ncaused by: ' + _stringifyAny(obj.cause, opt);
+        }
     }
     else if (typeof obj === 'string') {
         //

package/dist-esm/error/app.error.js

@@ -8,8 +8,8 @@
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 export class AppError extends Error {
-    constructor(message, data = {}) {
-        super(message);
+    constructor(message, data = {}, opt) {
+        super(message, opt);
         Object.defineProperty(this, 'name', {
             value: this.constructor.name,
             configurable: true,

package/dist-esm/error/assert.js

@@ -84,7 +84,4 @@ export function _assertTypeOf(v, expectedType, message) {
     }
 }
 export class AssertionError extends AppError {
-    constructor(message, data = {}) {
-        super(message, data);
-    }
 }

package/dist-esm/error/error.util.js

@@ -7,14 +7,14 @@ import { AppError, _jsonParseIfPossible, _stringifyAny } from '..';
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-export function _anyToError(o, errorClass = Error, errorData, opt) {
+export function _anyToError(o, errorClass = Error, errorData) {
     let e;
     if (o instanceof errorClass) {
         e = o;
     }
     else {
         // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
-        const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt);
+        const errorObject = _anyToErrorObject(o);
         e = _errorObjectToError(errorObject, errorClass);
     }
     if (errorData) {
@@ -29,11 +29,10 @@ export function _anyToError(o, errorClass = Error, errorData, opt) {
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
-export function _anyToErrorObject(o, errorData, opt) {
-    var _a;
+export function _anyToErrorObject(o, errorData) {
     let eo;
     if (o instanceof Error) {
-        eo = _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
+        eo = _errorToErrorObject(o);
     }
     else {
         o = _jsonParseIfPossible(o);
@@ -48,7 +47,7 @@ export function _anyToErrorObject(o, errorData, opt) {
             // so, fair to return `data: {}` in the end
             // Also we're sure it includes no "error name", e.g no `Error: ...`,
             // so, fair to include `name: 'Error'`
-            const message = _stringifyAny(o, Object.assign({ includeErrorData: true }, opt));
+            const message = _stringifyAny(o);
             eo = {
                 name: 'Error',
                 message,
@@ -59,14 +58,15 @@ export function _anyToErrorObject(o, errorData, opt) {
     Object.assign(eo.data, errorData);
     return eo;
 }
-export function _errorToErrorObject(e, includeErrorStack = true) {
+export function _errorToErrorObject(e) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: Object.assign({}, e.data), // empty by default
+        data: Object.assign({}, e.data),
+        stack: e.stack,
     };
-    if (includeErrorStack) {
-        obj.stack = e.stack;
+    if (e.cause) {
+        obj.cause = _anyToErrorObject(e.cause);
     }
     return obj;
 }
@@ -94,6 +94,14 @@ export function _errorObjectToError(o, errorClass = Error) {
             value: o.stack,
         });
     }
+    if (o.cause) {
+        Object.defineProperty(err, 'cause', {
+            value: o.cause,
+            writable: true,
+            configurable: true,
+            enumerable: false,
+        });
+    }
     return err;
 }
 export function _isHttpErrorResponse(o) {
@@ -110,8 +118,15 @@ export function _isHttpErrorObject(o) {
  * Note: any instance of AppError is also automatically an ErrorObject
  */
 export function _isErrorObject(o) {
-    return (!!o && typeof o.name === 'string' && typeof o.message === 'string' && typeof o.data === 'object');
+    return (!!o &&
+        typeof o === 'object' &&
+        typeof o.name === 'string' &&
+        typeof o.message === 'string' &&
+        typeof o.data === 'object');
 }
+// export function _isErrorLike(o: any): o is ErrorLike {
+//   return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string'
+// }
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/dist-esm/error/errorMode.js

@@ -10,7 +10,7 @@ export var ErrorMode;
      */
     ErrorMode["THROW_IMMEDIATELY"] = "THROW_IMMEDIATELY";
     /**
-     * Don't throw on errors, but collect them and throw as AggregatedError in the end.
+     * Don't throw on errors, but collect them and throw as AggregateError in the end.
      */
     ErrorMode["THROW_AGGREGATED"] = "THROW_AGGREGATED";
     /**