@naturalcycles/js-lib 14.172.0 → 14.173.0

package/dist/error/assert.d.ts

@@ -1,6 +1,5 @@
 import type { ErrorData, ErrorObject } from '..';
 import { Class } from '..';
-import { AppError } from './app.error';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -43,6 +42,3 @@ export declare function _assertIsErrorObject<DATA_TYPE extends ErrorData = Error
 export declare function _assertIsString(v: any, message?: string): asserts v is string;
 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

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertionError = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsErrorObject = exports._assertErrorClassOrRethrow = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
+exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsErrorObject = exports._assertErrorClassOrRethrow = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
 const __1 = require("..");
-const app_error_1 = require("./app.error");
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -21,7 +20,7 @@ const app_error_1 = require("./app.error");
 function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new AssertionError(message || 'see stacktrace', {
+        throw new __1.AssertionError(message || 'see stacktrace', {
             userFriendly: true,
             ...errorData,
         });
@@ -40,7 +39,7 @@ function _assertEquals(actual, expected, message, errorData) {
             ['not equal', `expected: ${(0, __1._stringifyAny)(expected)}`, `got     : ${(0, __1._stringifyAny)(actual)}`]
                 .filter(Boolean)
                 .join('\n');
-        throw new AssertionError(msg, {
+        throw new __1.AssertionError(msg, {
             userFriendly: true,
             ...errorData,
         });
@@ -63,7 +62,7 @@ function _assertDeepEquals(actual, expected, message, errorData) {
             ]
                 .filter(Boolean)
                 .join('\n');
-        throw new AssertionError(msg, {
+        throw new __1.AssertionError(msg, {
             userFriendly: true,
             ...errorData,
         });
@@ -76,7 +75,7 @@ function _assertIsError(err, errorClass = Error) {
             `expected to be instanceof ${errorClass.name}`,
             `actual typeof: ${typeof err}`,
         ].join('\n');
-        throw new AssertionError(msg, {
+        throw new __1.AssertionError(msg, {
             userFriendly: true,
         });
     }
@@ -97,7 +96,7 @@ exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
 function _assertIsErrorObject(obj) {
     if (!(0, __1._isErrorObject)(obj)) {
         const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');
-        throw new AssertionError(msg, {
+        throw new __1.AssertionError(msg, {
             userFriendly: true,
         });
     }
@@ -118,15 +117,9 @@ function _assertTypeOf(v, expectedType, message) {
             `expected: ${expectedType}`,
             `got     : ${typeof v}`,
         ].join('\n');
-        throw new AssertionError(msg, {
+        throw new __1.AssertionError(msg, {
             userFriendly: true,
         });
     }
 }
 exports._assertTypeOf = _assertTypeOf;
-class AssertionError extends app_error_1.AppError {
-    constructor(message, data) {
-        super(message, data, { name: 'AssertionError' });
-    }
-}
-exports.AssertionError = AssertionError;

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

@@ -1,5 +1,4 @@
 import type { ErrorData, ErrorObject, BackendErrorResponseObject, Class, HttpRequestErrorData, ErrorLike } from '..';
-import { AppError } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).
@@ -56,3 +55,83 @@ export declare function _isErrorLike(o: any): o is ErrorLike;
  * }
  */
 export declare function _errorDataAppend<ERR>(err: ERR, data?: ErrorData): ERR;
+/**
+ * Base class for all our (not system) errors.
+ *
+ * message - "technical" message. Frontend decides to show it or not.
+ * data - optional "any" payload.
+ * 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?: 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.
+     * It is transformed with _anyToErrorObject()
+     */
+    cause?: any;
+}
+/**
+ * Error that is thrown when Http Request was made and returned an error.
+ * Thrown by, for example, Fetcher.
+ *
+ * On the Frontend this Error class represents the error when calling the API,
+ * contains all the necessary request and response information.
+ *
+ * On the Backend, similarly, it represents the error when calling some 3rd-party API
+ * (backend-to-backend call).
+ * On the Backend it often propagates all the way to the Backend error handler,
+ * where it would be wrapped in BackendErrorResponseObject.
+ *
+ * Please note that `ErrorData.backendResponseStatusCode` is NOT exactly the same as
+ * `HttpRequestErrorData.responseStatusCode`.
+ * E.g 3rd-party call may return 401, but our Backend will still wrap it into an 500 error
+ * (by default).
+ */
+export declare class HttpRequestError extends AppError<HttpRequestErrorData> {
+    constructor(message: string, data: HttpRequestErrorData, opt?: AppErrorOptions);
+    /**
+     * Cause is strictly-defined for HttpRequestError,
+     * so it always has a cause.
+     * (for dev convenience)
+     */
+    cause: ErrorObject;
+}
+export declare class AssertionError extends AppError {
+    constructor(message: string, data?: ErrorData);
+}
+export interface JsonParseErrorData extends ErrorData {
+    /**
+     * Original text that failed to get parsed.
+     */
+    text?: string;
+}
+export declare class JsonParseError extends AppError<JsonParseErrorData> {
+    constructor(data: JsonParseErrorData);
+}
+export declare class TimeoutError extends AppError {
+    constructor(message: string, data?: ErrorData, opt?: AppErrorOptions);
+}
+/**
+ * It is thrown when Error was expected, but didn't happen
+ * ("pass" happened instead).
+ * "Pass" means "no error".
+ */
+export declare class UnexpectedPassError extends AppError {
+    constructor();
+}

package/dist/error/error.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._errorDataAppend = exports._isErrorLike = exports._isErrorObject = exports._isHttpRequestErrorObject = exports._isBackendErrorResponseObject = exports._errorSnippet = exports._errorObjectToError = exports._errorLikeToErrorObject = exports._anyToErrorObject = exports._anyToError = void 0;
+exports.UnexpectedPassError = exports.TimeoutError = exports.JsonParseError = exports.AssertionError = exports.HttpRequestError = exports.AppError = exports._errorDataAppend = exports._isErrorLike = exports._isErrorObject = exports._isHttpRequestErrorObject = exports._isBackendErrorResponseObject = exports._errorSnippet = exports._errorObjectToError = exports._errorLikeToErrorObject = exports._anyToErrorObject = exports._anyToError = void 0;
 const __1 = require("..");
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -106,7 +106,7 @@ function _errorObjectToError(o, errorClass = Error) {
             value: o.stack,
         });
     }
-    if (!(err instanceof __1.AppError)) {
+    if (!(err instanceof AppError)) {
         // Following actions are only needed for non-AppError-like errors
         Object.defineProperties(err, {
             name: {
@@ -225,3 +225,118 @@ function _errorDataAppend(err, data) {
     return err;
 }
 exports._errorDataAppend = _errorDataAppend;
+/**
+ * Base class for all our (not system) errors.
+ *
+ * message - "technical" message. Frontend decides to show it or not.
+ * data - optional "any" payload.
+ * 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 = {}, opt = {}) {
+        super(message);
+        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', {
+                value: _anyToErrorObject(cause),
+                writable: true,
+                configurable: true,
+                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)
+        // } else {
+        //   Object.defineProperty(this, 'stack', {
+        //     value: new Error().stack, // eslint-disable-line unicorn/error-message
+        //     writable: true,
+        //     configurable: true,
+        //   })
+        // }
+    }
+}
+exports.AppError = AppError;
+/**
+ * Error that is thrown when Http Request was made and returned an error.
+ * Thrown by, for example, Fetcher.
+ *
+ * On the Frontend this Error class represents the error when calling the API,
+ * contains all the necessary request and response information.
+ *
+ * On the Backend, similarly, it represents the error when calling some 3rd-party API
+ * (backend-to-backend call).
+ * On the Backend it often propagates all the way to the Backend error handler,
+ * where it would be wrapped in BackendErrorResponseObject.
+ *
+ * Please note that `ErrorData.backendResponseStatusCode` is NOT exactly the same as
+ * `HttpRequestErrorData.responseStatusCode`.
+ * E.g 3rd-party call may return 401, but our Backend will still wrap it into an 500 error
+ * (by default).
+ */
+class HttpRequestError extends AppError {
+    constructor(message, data, opt) {
+        if (data.response) {
+            Object.defineProperty(data, 'response', {
+                enumerable: false,
+            });
+        }
+        super(message, data, { ...opt, name: 'HttpRequestError' });
+    }
+}
+exports.HttpRequestError = HttpRequestError;
+class AssertionError extends AppError {
+    constructor(message, data) {
+        super(message, data, { name: 'AssertionError' });
+    }
+}
+exports.AssertionError = AssertionError;
+class JsonParseError extends AppError {
+    constructor(data) {
+        const message = ['Failed to parse', data.text && (0, __1._truncateMiddle)(data.text, 200)]
+            .filter(Boolean)
+            .join(': ');
+        super(message, data, { name: 'JsonParseError' });
+    }
+}
+exports.JsonParseError = JsonParseError;
+class TimeoutError extends AppError {
+    constructor(message, data, opt) {
+        super(message, data, { ...opt, name: 'TimeoutError' });
+    }
+}
+exports.TimeoutError = TimeoutError;
+/**
+ * It is thrown when Error was expected, but didn't happen
+ * ("pass" happened instead).
+ * "Pass" means "no error".
+ */
+class UnexpectedPassError extends AppError {
+    constructor() {
+        super('expected error was not thrown', {}, {
+            name: 'UnexpectedPassError',
+        });
+    }
+}
+exports.UnexpectedPassError = UnexpectedPassError;

package/dist/error/try.d.ts

@@ -1,6 +1,5 @@
 import type { Class } from '../typeFest';
 import type { AnyFunction, ErrorDataTuple } from '../types';
-import { AppError } from './app.error';
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -25,14 +24,6 @@ export declare function _try<T, ERR extends Error = Error>(fn: () => T, errorCla
  * Like _try, but for Promises.
  */
 export declare function pTry<T, ERR extends Error = Error>(promise: Promise<T>, errorClass?: Class<ERR>): Promise<ErrorDataTuple<Awaited<T>, ERR>>;
-/**
- * It is thrown when Error was expected, but didn't happen
- * ("pass" happened instead).
- * "Pass" means "no error".
- */
-export declare class UnexpectedPassError extends AppError {
-    constructor();
-}
 /**
  * Calls `fn`, expects is to throw, catches the expected error and returns.
  * If error was NOT thrown - throws UnexpectedPassError instead.

package/dist/error/try.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._expectedErrorString = exports.pExpectedErrorString = exports.pExpectedError = exports._expectedError = exports.UnexpectedPassError = exports.pTry = exports._try = void 0;
+exports._expectedErrorString = exports.pExpectedErrorString = exports.pExpectedError = exports._expectedError = exports.pTry = exports._try = void 0;
 const stringifyAny_1 = require("../string/stringifyAny");
-const app_error_1 = require("./app.error");
 const assert_1 = require("./assert");
+const error_util_1 = require("./error.util");
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -50,19 +50,6 @@ async function pTry(promise, errorClass) {
     }
 }
 exports.pTry = pTry;
-/**
- * It is thrown when Error was expected, but didn't happen
- * ("pass" happened instead).
- * "Pass" means "no error".
- */
-class UnexpectedPassError extends app_error_1.AppError {
-    constructor() {
-        super('expected error was not thrown', {}, {
-            name: 'UnexpectedPassError',
-        });
-    }
-}
-exports.UnexpectedPassError = UnexpectedPassError;
 /**
  * Calls `fn`, expects is to throw, catches the expected error and returns.
  * If error was NOT thrown - throws UnexpectedPassError instead.
@@ -75,10 +62,10 @@ function _expectedError(fn, errorClass) {
     try {
         fn();
         // Unexpected!
-        throw new UnexpectedPassError();
+        throw new error_util_1.UnexpectedPassError();
     }
     catch (err) {
-        if (err instanceof UnexpectedPassError)
+        if (err instanceof error_util_1.UnexpectedPassError)
             throw err; // re-throw
         if (errorClass && !(err instanceof errorClass)) {
             console.warn(`_expectedError expected ${errorClass.constructor.name} but got different error class`);
@@ -100,10 +87,10 @@ async function pExpectedError(promise, errorClass) {
     try {
         await promise;
         // Unexpected!
-        throw new UnexpectedPassError();
+        throw new error_util_1.UnexpectedPassError();
     }
     catch (err) {
-        if (err instanceof UnexpectedPassError)
+        if (err instanceof error_util_1.UnexpectedPassError)
             throw err; // re-throw
         if (errorClass && !(err instanceof errorClass)) {
             console.warn(`pExpectedError expected ${errorClass.constructor.name} but got different error class`);

package/dist/http/fetcher.d.ts

@@ -1,6 +1,6 @@
 /// <reference lib="dom" />
 /// <reference lib="dom.iterable" />
-import { HttpRequestError } from '../error/httpRequestError';
+import { HttpRequestError } from '../error/error.util';
 import { ErrorDataTuple } from '../types';
 import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherResponse, RequestInitNormalized } from './fetcher.model';
 /**

package/dist/http/fetcher.js

@@ -6,7 +6,6 @@ exports.getFetcher = exports.Fetcher = void 0;
 const env_1 = require("../env");
 const assert_1 = require("../error/assert");
 const error_util_1 = require("../error/error.util");
-const httpRequestError_1 = require("../error/httpRequestError");
 const number_util_1 = require("../number/number.util");
 const object_util_1 = require("../object/object.util");
 const pDelay_1 = require("../promise/pDelay");
@@ -131,7 +130,7 @@ class Fetcher {
     async tryFetch(opt) {
         const res = await this.doFetch(opt);
         if (res.err) {
-            (0, assert_1._assertErrorClassOrRethrow)(res.err, httpRequestError_1.HttpRequestError);
+            (0, assert_1._assertErrorClassOrRethrow)(res.err, error_util_1.HttpRequestError);
             return [res.err, null];
         }
         return [null, res.body];
@@ -174,7 +173,7 @@ class Fetcher {
                     // console.log(`actual request timed out in ${_since(req.started)}`)
                     // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
                     // so, we're wrapping it in a TimeoutError instance
-                    abortController.abort(new pTimeout_1.TimeoutError(`request timed out after ${timeoutSeconds} sec`));
+                    abortController.abort(new error_util_1.TimeoutError(`request timed out after ${timeoutSeconds} sec`));
                 }, timeoutSeconds * 1000);
             }
             if (this.cfg.logRequest) {
@@ -316,7 +315,7 @@ class Fetcher {
             data: {},
         };
         const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ');
-        res.err = new httpRequestError_1.HttpRequestError(message, (0, object_util_1._filterNullishValues)({
+        res.err = new error_util_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

package/dist/index.d.ts

@@ -14,16 +14,13 @@ export * from './decorators/memoFn';
 export * from './decorators/memoFnAsync';
 export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
-export * from './error/app.error';
 export * from './error/assert';
 export * from './enum.util';
 export * from './error/error.model';
 export * from './error/error.util';
 export * from './error/errorMode';
-export * from './error/httpRequestError';
 export * from './error/try';
 export * from './error/tryCatch';
-export * from './error/jsonParseError';
 export * from './json-schema/from-data/generateJsonSchemaFromData';
 export * from './json-schema/jsonSchema.cnst';
 export * from './json-schema/jsonSchema.model';

package/dist/index.js

@@ -18,16 +18,13 @@ tslib_1.__exportStar(require("./decorators/memoFn"), exports);
 tslib_1.__exportStar(require("./decorators/memoFnAsync"), exports);
 tslib_1.__exportStar(require("./decorators/retry.decorator"), exports);
 tslib_1.__exportStar(require("./decorators/timeout.decorator"), exports);
-tslib_1.__exportStar(require("./error/app.error"), exports);
 tslib_1.__exportStar(require("./error/assert"), exports);
 tslib_1.__exportStar(require("./enum.util"), exports);
 tslib_1.__exportStar(require("./error/error.model"), exports);
 tslib_1.__exportStar(require("./error/error.util"), exports);
 tslib_1.__exportStar(require("./error/errorMode"), exports);
-tslib_1.__exportStar(require("./error/httpRequestError"), exports);
 tslib_1.__exportStar(require("./error/try"), exports);
 tslib_1.__exportStar(require("./error/tryCatch"), exports);
-tslib_1.__exportStar(require("./error/jsonParseError"), exports);
 tslib_1.__exportStar(require("./json-schema/from-data/generateJsonSchemaFromData"), exports);
 tslib_1.__exportStar(require("./json-schema/jsonSchema.cnst"), exports);
 tslib_1.__exportStar(require("./json-schema/jsonSchema.model"), exports);

package/dist/promise/pTimeout.d.ts

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

package/dist/promise/pTimeout.js

@@ -1,14 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pTimeout = exports.pTimeoutFn = exports.TimeoutError = void 0;
-const app_error_1 = require("../error/app.error");
+exports.pTimeout = exports.pTimeoutFn = void 0;
 const error_util_1 = require("../error/error.util");
-class TimeoutError extends app_error_1.AppError {
-    constructor(message, data, opt) {
-        super(message, data, { ...opt, name: 'TimeoutError' });
-    }
-}
-exports.TimeoutError = TimeoutError;
 /**
  * Decorates a Function with a timeout.
  * Returns a decorated Function.
@@ -36,7 +29,7 @@ async function pTimeout(fn, opt) {
     return await new Promise(async (resolve, reject) => {
         // Prepare the timeout timer
         const timer = setTimeout(() => {
-            const err = new TimeoutError(`"${name}" timed out after ${timeout} ms`, opt.errorData);
+            const err = new error_util_1.TimeoutError(`"${name}" timed out after ${timeout} ms`, opt.errorData);
             // keep original stack
             err.stack = fakeError.stack.replace('Error: TimeoutError', 'TimeoutError: ' + err.message);
             if (onTimeout) {

package/dist/string/json.util.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._jsonParse = exports._jsonParseOrUndefined = exports._jsonParseIfPossible = void 0;
-const jsonParseError_1 = require("../error/jsonParseError");
+const error_util_1 = require("../error/error.util");
 // const possibleJsonStartTokens = ['{', '[', '"']
 const DETECT_JSON = /^\s*[{["\-\d]/;
 /**
@@ -44,7 +44,7 @@ function _jsonParse(s, reviver) {
         return JSON.parse(s, reviver);
     }
     catch {
-        throw new jsonParseError_1.JsonParseError({
+        throw new error_util_1.JsonParseError({
             text: s,
         });
     }

package/dist-esm/error/assert.js

@@ -1,5 +1,4 @@
-import { _deepEquals, _isErrorObject, _stringifyAny } from '..';
-import { AppError } from './app.error';
+import { _deepEquals, _isErrorObject, _stringifyAny, AssertionError } from '..';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -103,8 +102,3 @@ export function _assertTypeOf(v, expectedType, message) {
         });
     }
 }
-export class AssertionError extends AppError {
-    constructor(message, data) {
-        super(message, data, { name: 'AssertionError' });
-    }
-}

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

@@ -1,4 +1,4 @@
-import { AppError, _jsonParseIfPossible, _stringifyAny, _truncate } from '..';
+import { _jsonParseIfPossible, _stringifyAny, _truncate, _truncateMiddle } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).
@@ -207,3 +207,112 @@ export function _errorDataAppend(err, data) {
     err.data = Object.assign(Object.assign({}, err.data), data);
     return err;
 }
+/**
+ * Base class for all our (not system) errors.
+ *
+ * message - "technical" message. Frontend decides to show it or not.
+ * data - optional "any" payload.
+ * 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 class AppError extends Error {
+    constructor(message, data = {}, opt = {}) {
+        super(message);
+        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', {
+                value: _anyToErrorObject(cause),
+                writable: true,
+                configurable: true,
+                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)
+        // } else {
+        //   Object.defineProperty(this, 'stack', {
+        //     value: new Error().stack, // eslint-disable-line unicorn/error-message
+        //     writable: true,
+        //     configurable: true,
+        //   })
+        // }
+    }
+}
+/**
+ * Error that is thrown when Http Request was made and returned an error.
+ * Thrown by, for example, Fetcher.
+ *
+ * On the Frontend this Error class represents the error when calling the API,
+ * contains all the necessary request and response information.
+ *
+ * On the Backend, similarly, it represents the error when calling some 3rd-party API
+ * (backend-to-backend call).
+ * On the Backend it often propagates all the way to the Backend error handler,
+ * where it would be wrapped in BackendErrorResponseObject.
+ *
+ * Please note that `ErrorData.backendResponseStatusCode` is NOT exactly the same as
+ * `HttpRequestErrorData.responseStatusCode`.
+ * E.g 3rd-party call may return 401, but our Backend will still wrap it into an 500 error
+ * (by default).
+ */
+export class HttpRequestError extends AppError {
+    constructor(message, data, opt) {
+        if (data.response) {
+            Object.defineProperty(data, 'response', {
+                enumerable: false,
+            });
+        }
+        super(message, data, Object.assign(Object.assign({}, opt), { name: 'HttpRequestError' }));
+    }
+}
+export class AssertionError extends AppError {
+    constructor(message, data) {
+        super(message, data, { name: 'AssertionError' });
+    }
+}
+export class JsonParseError extends AppError {
+    constructor(data) {
+        const message = ['Failed to parse', data.text && _truncateMiddle(data.text, 200)]
+            .filter(Boolean)
+            .join(': ');
+        super(message, data, { name: 'JsonParseError' });
+    }
+}
+export class TimeoutError extends AppError {
+    constructor(message, data, opt) {
+        super(message, data, Object.assign(Object.assign({}, opt), { name: 'TimeoutError' }));
+    }
+}
+/**
+ * It is thrown when Error was expected, but didn't happen
+ * ("pass" happened instead).
+ * "Pass" means "no error".
+ */
+export class UnexpectedPassError extends AppError {
+    constructor() {
+        super('expected error was not thrown', {}, {
+            name: 'UnexpectedPassError',
+        });
+    }
+}