@naturalcycles/js-lib 14.159.0 → 14.161.0

package/dist/{lazy.d.ts → define.d.ts}

@@ -28,3 +28,29 @@ export declare function _defineLazyProperty<OBJ extends AnyObject>(obj: OBJ, pro
  * Like _defineLazyProperty, but allows to define multiple props at once.
  */
 export declare function _defineLazyProps<OBJ extends AnyObject>(obj: OBJ, props: Partial<Record<keyof OBJ, AnyFunction>>): OBJ;
+/**
+ * Same as Object.defineProperty, but with better (least restricting) defaults.
+ *
+ * Defaults are:
+ * writable: true
+ * configurable: true
+ * enumerable: true
+ * value: existing obj[prop] value
+ *
+ * Original defaults:
+ * writable: false
+ * configurable: false
+ * enumerable: false
+ * value: existing obj[prop] value
+ *
+ */
+export declare function _defineProperty<T extends AnyObject>(obj: T, prop: keyof T, pd: PropertyDescriptor): T;
+/**
+ * Object.defineProperties with better defaults.
+ * See _defineProperty for exact defaults definition.
+ */
+export declare function _defineProps<T extends AnyObject>(obj: T, props: Partial<Record<keyof T, PropertyDescriptor>>): T;
+/**
+ * Like _defineProps, but skips props with nullish values.
+ */
+export declare function _defineNonNullishProps<T extends AnyObject>(obj: T, props: Partial<Record<keyof T, PropertyDescriptor>>): T;

package/dist/define.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._defineNonNullishProps = exports._defineProps = exports._defineProperty = exports._defineLazyProps = exports._defineLazyProperty = exports._lazyValue = void 0;
+const object_util_1 = require("./object/object.util");
+const types_1 = require("./types");
+/**
+ * const value = lazyValue(() => expensiveComputation())
+ *
+ * value() // calls expensiveComputation() once
+ * value() // returns cached result
+ * value() // returns cached result
+ *
+ * Based on: https://github.com/sindresorhus/lazy-value
+ */
+function _lazyValue(fn) {
+    let isCalled = false;
+    let result;
+    return (() => {
+        if (!isCalled) {
+            isCalled = true;
+            result = fn();
+        }
+        return result;
+    });
+}
+exports._lazyValue = _lazyValue;
+/**
+ * interface Obj {
+ *   v: number
+ * }
+ *
+ * const obj = {} as Obj
+ *
+ * _defineLazyProperty(obj, 'v', () => expensiveComputation())
+ * obj.v // runs expensiveComputation() once
+ * obj.v // cached value
+ * obj.v // cached value
+ *
+ * Based on: https://github.com/sindresorhus/define-lazy-prop
+ */
+function _defineLazyProperty(obj, propertyName, fn) {
+    const define = (value) => {
+        Object.defineProperty(obj, propertyName, { value, enumerable: true, writable: true });
+    };
+    Object.defineProperty(obj, propertyName, {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const result = fn();
+            define(result);
+            return result;
+        },
+        set(value) {
+            define(value);
+        },
+    });
+    return obj;
+}
+exports._defineLazyProperty = _defineLazyProperty;
+/**
+ * Like _defineLazyProperty, but allows to define multiple props at once.
+ */
+function _defineLazyProps(obj, props) {
+    Object.entries(props).forEach(([k, fn]) => _defineLazyProperty(obj, k, fn));
+    return obj;
+}
+exports._defineLazyProps = _defineLazyProps;
+/**
+ * Same as Object.defineProperty, but with better (least restricting) defaults.
+ *
+ * Defaults are:
+ * writable: true
+ * configurable: true
+ * enumerable: true
+ * value: existing obj[prop] value
+ *
+ * Original defaults:
+ * writable: false
+ * configurable: false
+ * enumerable: false
+ * value: existing obj[prop] value
+ *
+ */
+function _defineProperty(obj, prop, pd) {
+    return Object.defineProperty(obj, prop, {
+        writable: true,
+        configurable: true,
+        enumerable: true,
+        // value: obj[prop], // existing value is already kept by default
+        ...pd,
+    });
+}
+exports._defineProperty = _defineProperty;
+/**
+ * Object.defineProperties with better defaults.
+ * See _defineProperty for exact defaults definition.
+ */
+function _defineProps(obj, props) {
+    return Object.defineProperties(obj, (0, object_util_1._mapValues)(props, (k, pd) => ({
+        writable: true,
+        configurable: true,
+        enumerable: true,
+        // value: obj[k], // existing value is already kept by default
+        ...pd,
+    })));
+}
+exports._defineProps = _defineProps;
+/**
+ * Like _defineProps, but skips props with nullish values.
+ */
+function _defineNonNullishProps(obj, props) {
+    return _defineProps(obj, (0, object_util_1._mapObject)(props, (k, pd) => {
+        if (pd.value === null || pd.value === undefined)
+            return types_1.SKIP;
+        return [k, pd];
+    }));
+}
+exports._defineNonNullishProps = _defineNonNullishProps;

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

@@ -4,15 +4,28 @@ import type { ErrorData, ErrorObject } from './error.model';
  *
  * message - "technical" message. Frontend decides to show it or not.
  * data - optional "any" payload.
- * data.userMessage - if present, will be displayed to the User as is.
+ * data.userFriendly - if present, will be displayed to the User as is.
  *
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 export declare class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
     data: DATA_TYPE;
     /**
-     * cause here is normalized to be an ErrorObject
+     * `cause` here is normalized to be an ErrorObject
+     */
+    cause?: ErrorObject;
+    constructor(message: string, data?: DATA_TYPE, opt?: AppErrorOptions);
+}
+/**
+ * Extra options for AppError constructor.
+ */
+export interface AppErrorOptions {
+    /**
+     * Overrides Error.name and Error.constructor.name
+     */
+    name?: string;
+    /**
+     * Sets Error.cause
      */
     cause?: ErrorObject;
-    constructor(message: string, data?: DATA_TYPE, cause?: ErrorObject, name?: string);
 }

package/dist/error/app.error.js

@@ -6,29 +6,26 @@ exports.AppError = void 0;
  *
  * message - "technical" message. Frontend decides to show it or not.
  * data - optional "any" payload.
- * data.userMessage - if present, will be displayed to the User as is.
+ * data.userFriendly - if present, will be displayed to the User as is.
  *
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 class AppError extends Error {
-    constructor(message, data = {}, cause, name) {
+    constructor(message, data = {}, opt = {}) {
         super(message);
-        Object.defineProperty(this, 'name', {
-            value: name || this.constructor.name,
-            configurable: true,
-            writable: true,
-        });
-        // this is to allow changing this.constuctor.name to a non-minified version
-        Object.defineProperty(this.constructor, 'name', {
-            value: name || this.constructor.name,
-            configurable: true,
-            writable: true,
-        });
-        Object.defineProperty(this, 'data', {
-            value: data,
-            writable: true,
-            configurable: true,
-            enumerable: false,
+        const { name = this.constructor.name, cause } = opt;
+        Object.defineProperties(this, {
+            name: {
+                value: name,
+                configurable: true,
+                writable: true,
+            },
+            data: {
+                value: data,
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            },
         });
         if (cause) {
             Object.defineProperty(this, 'cause', {
@@ -36,9 +33,15 @@ class AppError extends Error {
                 value: cause,
                 writable: true,
                 configurable: true,
-                enumerable: false,
+                enumerable: true, // unlike standard - setting it to true for "visibility"
             });
         }
+        // this is to allow changing this.constuctor.name to a non-minified version
+        Object.defineProperty(this.constructor, 'name', {
+            value: name,
+            configurable: true,
+            writable: true,
+        });
         // todo: check if it's needed at all!
         // if (Error.captureStackTrace) {
         //   Error.captureStackTrace(this, this.constructor)

package/dist/error/assert.d.ts

@@ -44,5 +44,5 @@ 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?: {}, cause?: ErrorObject);
+    constructor(message: string, data?: ErrorData);
 }

package/dist/error/assert.js

@@ -127,8 +127,8 @@ function _assertTypeOf(v, expectedType, message) {
 }
 exports._assertTypeOf = _assertTypeOf;
 class AssertionError extends app_error_1.AppError {
-    constructor(message, data = {}, cause) {
-        super(message, data, cause, 'AssertionError');
+    constructor(message, data) {
+        super(message, data, { name: 'AssertionError' });
     }
 }
 exports.AssertionError = AssertionError;

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

@@ -69,6 +69,13 @@ export interface ErrorData {
     [k: string]: any;
 }
 export interface HttpRequestErrorData extends ErrorData {
+    /**
+     * Actual `fetch` Response as it was returned.
+     * Note that not every Request has a Response, hence it's optional.
+     *
+     * Non-enumerable.
+     */
+    response?: Response;
     requestUrl: string;
     requestBaseUrl?: string;
     requestMethod: HttpMethod;

package/dist/error/error.util.js

@@ -87,36 +87,43 @@ exports._errorLikeToErrorObject = _errorLikeToErrorObject;
 function _errorObjectToError(o, errorClass = Error) {
     if (o instanceof errorClass)
         return o;
-    const err = new errorClass(o.message);
+    // Here we pass constructor values assuming it's AppError or sub-class of it
+    // If not - will be checked at the next step
+    // We cannot check `if (errorClass instanceof AppError)`, only `err instanceof AppError`
+    const { name, cause } = o;
+    const err = new errorClass(o.message, o.data, { name, cause });
     // name: err.name, // cannot be assigned to a readonly property like this
     // stack: o.stack, // also readonly e.g in Firefox
-    Object.defineProperty(err, 'name', {
-        value: o.name,
-        configurable: true,
-        writable: true,
-    });
-    Object.defineProperty(err.constructor, 'name', {
-        value: o.name,
-        configurable: true,
-        writable: true,
-    });
-    Object.defineProperty(err, 'data', {
-        value: o.data,
-        writable: true,
-        configurable: true,
-        enumerable: false,
-    });
     if (o.stack) {
         Object.defineProperty(err, 'stack', {
             value: o.stack,
         });
     }
-    if (o.cause) {
-        Object.defineProperty(err, 'cause', {
-            value: o.cause,
-            writable: true,
+    if (!(err instanceof __1.AppError)) {
+        // Following actions are only needed for non-AppError-like errors
+        Object.defineProperties(err, {
+            name: {
+                value: name,
+                configurable: true,
+                writable: true,
+            },
+            data: {
+                value: o.data,
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            },
+            cause: {
+                value: cause,
+                writable: true,
+                configurable: true,
+                enumerable: true,
+            },
+        });
+        Object.defineProperty(err.constructor, 'name', {
+            value: name,
             configurable: true,
-            enumerable: false,
+            writable: true,
         });
     }
     return err;

package/dist/error/httpRequestError.d.ts

@@ -1,4 +1,4 @@
-import { AppError } from './app.error';
+import { AppError, AppErrorOptions } from './app.error';
 import type { ErrorObject, HttpRequestErrorData } from './error.model';
 /**
  * Error that is thrown when Http Request was made and returned an error.
@@ -18,7 +18,7 @@ import type { ErrorObject, HttpRequestErrorData } from './error.model';
  * (by default).
  */
 export declare class HttpRequestError extends AppError<HttpRequestErrorData> {
-    constructor(message: string, data: HttpRequestErrorData, cause: ErrorObject);
+    constructor(message: string, data: HttpRequestErrorData, opt?: AppErrorOptions);
     /**
      * Cause is strictly-defined for HttpRequestError,
      * so it always has a cause.

package/dist/error/httpRequestError.js

@@ -20,8 +20,13 @@ const app_error_1 = require("./app.error");
  * (by default).
  */
 class HttpRequestError extends app_error_1.AppError {
-    constructor(message, data, cause) {
-        super(message, data, cause, 'HttpRequestError');
+    constructor(message, data, opt) {
+        if (data.response) {
+            Object.defineProperty(data, 'response', {
+                enumerable: false,
+            });
+        }
+        super(message, data, { ...opt, name: 'HttpRequestError' });
     }
 }
 exports.HttpRequestError = HttpRequestError;

package/dist/error/jsonParseError.d.ts

@@ -1,5 +1,5 @@
 import { AppError } from './app.error';
-import { ErrorData, ErrorObject } from './error.model';
+import { ErrorData } from './error.model';
 export interface JsonParseErrorData extends ErrorData {
     /**
      * Original text that failed to get parsed.
@@ -7,5 +7,5 @@ export interface JsonParseErrorData extends ErrorData {
     text?: string;
 }
 export declare class JsonParseError extends AppError<JsonParseErrorData> {
-    constructor(data: JsonParseErrorData, cause?: ErrorObject);
+    constructor(data: JsonParseErrorData);
 }

package/dist/error/jsonParseError.js

@@ -4,8 +4,11 @@ exports.JsonParseError = void 0;
 const string_util_1 = require("../string/string.util");
 const app_error_1 = require("./app.error");
 class JsonParseError extends app_error_1.AppError {
-    constructor(data, cause) {
-        super(['Failed to parse', data.text && (0, string_util_1._truncateMiddle)(data.text, 200)].filter(Boolean).join(': '), data, cause, 'JsonParseError');
+    constructor(data) {
+        const message = ['Failed to parse', data.text && (0, string_util_1._truncateMiddle)(data.text, 200)]
+            .filter(Boolean)
+            .join(': ');
+        super(message, data, { name: 'JsonParseError' });
     }
 }
 exports.JsonParseError = JsonParseError;

package/dist/error/try.js

@@ -57,7 +57,9 @@ exports.pTry = pTry;
  */
 class UnexpectedPassError extends app_error_1.AppError {
     constructor() {
-        super('expected error was not thrown', {}, undefined, 'UnexpectedPassError');
+        super('expected error was not thrown', {}, {
+            name: 'UnexpectedPassError',
+        });
     }
 }
 exports.UnexpectedPassError = UnexpectedPassError;

package/dist/http/fetcher.js

@@ -309,6 +309,7 @@ class Fetcher {
         };
         const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ');
         res.err = new httpRequestError_1.HttpRequestError(message, (0, object_util_1._filterNullishValues)({
+            response: res.fetchResponse,
             responseStatusCode: res.fetchResponse?.status || 0,
             // These properties are provided to be used in e.g custom Sentry error grouping
             // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
@@ -316,11 +317,13 @@ class Fetcher {
             // method: req.method,
             // tryCount: req.tryCount,
             requestUrl: res.req.fullUrl,
-            requestBaseUrl: this.cfg.baseUrl || null,
+            requestBaseUrl: this.cfg.baseUrl || undefined,
             requestMethod: res.req.init.method,
             requestSignature: res.signature,
             requestDuration: Date.now() - res.req.started,
-        }), cause);
+        }), {
+            cause,
+        });
         await this.processRetry(res);
     }
     async processRetry(res) {
@@ -543,7 +546,7 @@ class Fetcher {
         });
         if (Object.keys(searchParams).length) {
             const qs = new URLSearchParams(searchParams).toString();
-            req.fullUrl += req.fullUrl.includes('?') ? '&' : '?' + qs;
+            req.fullUrl += (req.fullUrl.includes('?') ? '&' : '?') + qs;
         }
         // setup request body
         if (opt.json !== undefined) {

package/dist/http/fetcher.model.d.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 import type { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
 import type { AnyObject, NumberOfMilliseconds, Reviver, UnixTimestampMillisNumber } from '../types';

package/dist/http/fetcher.model.js

@@ -1,2 +1,3 @@
 "use strict";
+/// <reference lib="dom"/>
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './array/array.util';
-export * from './lazy';
+export * from './define';
 export * from './string/url.util';
 export * from './array/range';
 export * from './decorators/createPromiseDecorator';

package/dist/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodError = exports.ZodSchema = exports.z = exports.is = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./array/array.util"), exports);
-tslib_1.__exportStar(require("./lazy"), exports);
+tslib_1.__exportStar(require("./define"), exports);
 tslib_1.__exportStar(require("./string/url.util"), exports);
 tslib_1.__exportStar(require("./array/range"), exports);
 tslib_1.__exportStar(require("./decorators/createPromiseDecorator"), exports);

package/dist/object/object.util.d.ts

@@ -1,5 +1,6 @@
 import type { PropertyPath } from '../lodash.types';
-import type { AnyObject, ObjectMapper, ObjectPredicate, StringMap, ValueOf } from '../types';
+import { KeyValueTuple, SKIP } from '../types';
+import type { AnyObject, ObjectMapper, ObjectPredicate, ValueOf } from '../types';
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
@@ -44,21 +45,21 @@ export declare function _filterObject<T extends AnyObject>(obj: T, predicate: Ob
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(_key, value) { return value.age; });
+ * _mapValues(users, (_key, value) => value.age)
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
- * // The `_.property` iteratee shorthand.
- * _.mapValues(users, 'age')
- * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ * To skip some key-value pairs - use _mapObject instead.
  */
-export declare function _mapValues<T extends AnyObject, OUT = T>(obj: T, mapper: ObjectMapper<T, any>, mutate?: boolean): OUT;
+export declare function _mapValues<T extends AnyObject>(obj: T, mapper: ObjectMapper<T, any>, mutate?: boolean): T;
 /**
  * _.mapKeys({ 'a': 1, 'b': 2 }, (key, value) => key + value)
  * // => { 'a1': 1, 'b2': 2 }
  *
  * Does not support `mutate` flag.
+ *
+ * To skip some key-value pairs - use _mapObject instead.
  */
-export declare function _mapKeys<T extends AnyObject>(obj: T, mapper: ObjectMapper<T, string>): StringMap<T[keyof T]>;
+export declare function _mapKeys<T extends AnyObject>(obj: T, mapper: ObjectMapper<T, string>): Record<string, T[keyof T]>;
 /**
  * Maps object through predicate - a function that receives (k, v, obj)
  * k - key
@@ -71,13 +72,11 @@ export declare function _mapKeys<T extends AnyObject>(obj: T, mapper: ObjectMapp
  * 0 - key of returned object (string)
  * 1 - value of returned object (any)
  *
- * If predicate returns falsy value (e.g undefined), or a tuple where key (first item) is falsy - then such key/value pair is ignored (filtered out).
+ * If predicate returns SKIP symbol - such key/value pair is ignored (filtered out).
  *
  * Non-string keys are passed via String(...)
  */
-export declare function _mapObject<IN extends AnyObject, OUT>(obj: IN, mapper: ObjectMapper<IN, [key: string, value: any]>): {
-    [P in keyof IN]: OUT;
-};
+export declare function _mapObject<T extends AnyObject>(obj: T, mapper: ObjectMapper<T, KeyValueTuple<string, any> | typeof SKIP>): T;
 export declare function _findKeyByValue<T extends AnyObject>(obj: T, v: ValueOf<T>): keyof T | undefined;
 export declare function _objectNullValuesToUndefined<T extends AnyObject>(obj: T, mutate?: boolean): T;
 /**
@@ -184,3 +183,9 @@ export declare function _set<T extends AnyObject>(obj: T, path: PropertyPath, va
  * // => false
  */
 export declare function _has<T extends AnyObject>(obj: T, path: string): boolean;
+/**
+ * Does Object.freeze recursively for given object.
+ *
+ * Based on: https://github.com/substack/deep-freeze/blob/master/index.js
+ */
+export declare function _deepFreeze(o: any): void;

package/dist/object/object.util.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._has = exports._set = exports._get = exports._invertMap = exports._invert = exports._unset = exports._deepTrim = exports._merge = exports._filterEmptyValues = exports._undefinedIfEmpty = exports._deepCopy = exports._objectNullValuesToUndefined = exports._findKeyByValue = exports._mapObject = exports._mapKeys = exports._mapValues = exports._filterObject = exports._filterEmptyArrays = exports._filterUndefinedValues = exports._filterNullishValues = exports._filterFalsyValues = exports._mask = exports._omit = exports._pick = void 0;
+exports._deepFreeze = exports._has = exports._set = exports._get = exports._invertMap = exports._invert = exports._unset = exports._deepTrim = exports._merge = exports._filterEmptyValues = exports._undefinedIfEmpty = exports._deepCopy = exports._objectNullValuesToUndefined = exports._findKeyByValue = exports._mapObject = exports._mapKeys = exports._mapValues = exports._filterObject = exports._filterEmptyArrays = exports._filterUndefinedValues = exports._filterNullishValues = exports._filterFalsyValues = exports._mask = exports._omit = exports._pick = void 0;
 const is_util_1 = require("../is.util");
+const types_1 = require("../types");
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
@@ -93,18 +94,16 @@ exports._filterObject = _filterObject;
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(_key, value) { return value.age; });
+ * _mapValues(users, (_key, value) => value.age)
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
- * // The `_.property` iteratee shorthand.
- * _.mapValues(users, 'age')
- * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ * To skip some key-value pairs - use _mapObject instead.
  */
 function _mapValues(obj, mapper, mutate = false) {
-    return Object.entries(obj).reduce((map, [k, v]) => {
+    return (0, types_1._objectEntries)(obj).reduce((map, [k, v]) => {
         map[k] = mapper(k, v, obj);
         return map;
-    }, (mutate ? obj : {}));
+    }, mutate ? obj : {});
 }
 exports._mapValues = _mapValues;
 /**
@@ -112,9 +111,11 @@ exports._mapValues = _mapValues;
  * // => { 'a1': 1, 'b2': 2 }
  *
  * Does not support `mutate` flag.
+ *
+ * To skip some key-value pairs - use _mapObject instead.
  */
 function _mapKeys(obj, mapper) {
-    return Object.entries(obj).reduce((map, [k, v]) => {
+    return (0, types_1._objectEntries)(obj).reduce((map, [k, v]) => {
         map[mapper(k, v, obj)] = v;
         return map;
     }, {});
@@ -132,15 +133,14 @@ exports._mapKeys = _mapKeys;
  * 0 - key of returned object (string)
  * 1 - value of returned object (any)
  *
- * If predicate returns falsy value (e.g undefined), or a tuple where key (first item) is falsy - then such key/value pair is ignored (filtered out).
+ * If predicate returns SKIP symbol - such key/value pair is ignored (filtered out).
  *
  * Non-string keys are passed via String(...)
  */
 function _mapObject(obj, mapper) {
     return Object.entries(obj).reduce((map, [k, v]) => {
-        const r = mapper(k, v, obj) || [];
-        if (r[0]) {
-            ;
+        const r = mapper(k, v, obj);
+        if (r !== types_1.SKIP) {
             map[r[0]] = r[1];
         }
         return map;
@@ -367,3 +367,20 @@ function _has(obj, path) {
     return v !== undefined && v !== null;
 }
 exports._has = _has;
+/**
+ * Does Object.freeze recursively for given object.
+ *
+ * Based on: https://github.com/substack/deep-freeze/blob/master/index.js
+ */
+function _deepFreeze(o) {
+    Object.freeze(o);
+    Object.getOwnPropertyNames(o).forEach(prop => {
+        if (o.hasOwnProperty(prop) && // eslint-disable-line no-prototype-builtins
+            o[prop] !== null &&
+            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
+            !Object.isFrozen(o[prop])) {
+            _deepFreeze(o[prop]);
+        }
+    });
+}
+exports._deepFreeze = _deepFreeze;

package/dist/promise/pTimeout.d.ts

@@ -1,8 +1,8 @@
-import { AppError } from '../error/app.error';
-import type { ErrorData, ErrorObject } from '../error/error.model';
+import { AppError, AppErrorOptions } from '../error/app.error';
+import type { ErrorData } from '../error/error.model';
 import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types';
 export declare class TimeoutError extends AppError {
-    constructor(message: string, data?: {}, cause?: ErrorObject);
+    constructor(message: string, data?: ErrorData, opt?: AppErrorOptions);
 }
 export interface PTimeoutOptions {
     /**

package/dist/promise/pTimeout.js

@@ -4,8 +4,8 @@ exports.pTimeout = exports.pTimeoutFn = exports.TimeoutError = void 0;
 const app_error_1 = require("../error/app.error");
 const error_util_1 = require("../error/error.util");
 class TimeoutError extends app_error_1.AppError {
-    constructor(message, data = {}, cause) {
-        super(message, data, cause, 'TimeoutError');
+    constructor(message, data, opt) {
+        super(message, data, { ...opt, name: 'TimeoutError' });
     }
 }
 exports.TimeoutError = TimeoutError;