@naturalcycles/js-lib 14.172.0 → 14.173.0

package/dist-esm/error/try.js

@@ -1,6 +1,6 @@
 import { _stringifyAny } from '../string/stringifyAny';
-import { AppError } from './app.error';
 import { _assertErrorClassOrRethrow } from './assert';
+import { UnexpectedPassError } from './error.util';
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -45,18 +45,6 @@ export async function pTry(promise, errorClass) {
         return [err, null];
     }
 }
-/**
- * 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',
-        });
-    }
-}
 /**
  * Calls `fn`, expects is to throw, catches the expected error and returns.
  * If error was NOT thrown - throws UnexpectedPassError instead.

package/dist-esm/http/fetcher.js

@@ -3,12 +3,11 @@
 var _a;
 import { isServerSide } from '../env';
 import { _assertErrorClassOrRethrow } from '../error/assert';
-import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject } from '../error/error.util';
-import { HttpRequestError } from '../error/httpRequestError';
+import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject, HttpRequestError, TimeoutError, } from '../error/error.util';
 import { _clamp } from '../number/number.util';
 import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util';
 import { pDelay } from '../promise/pDelay';
-import { pTimeout, TimeoutError } from '../promise/pTimeout';
+import { pTimeout } from '../promise/pTimeout';
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util';
 import { _stringifyAny } from '../string/stringifyAny';
 import { _ms, _since } from '../time/time.util';

package/dist-esm/index.js

@@ -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-esm/promise/pTimeout.js

@@ -1,10 +1,4 @@
-import { AppError } from '../error/app.error';
-import { _errorDataAppend } from '../error/error.util';
-export class TimeoutError extends AppError {
-    constructor(message, data, opt) {
-        super(message, data, Object.assign(Object.assign({}, opt), { name: 'TimeoutError' }));
-    }
-}
+import { _errorDataAppend, TimeoutError } from '../error/error.util';
 /**
  * Decorates a Function with a timeout.
  * Returns a decorated Function.

package/dist-esm/string/json.util.js

@@ -1,4 +1,4 @@
-import { JsonParseError } from '../error/jsonParseError';
+import { JsonParseError } from '../error/error.util';
 // const possibleJsonStartTokens = ['{', '[', '"']
 const DETECT_JSON = /^\s*[{["\-\d]/;
 /**

package/package.json

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

package/src/error/assert.ts

@@ -1,6 +1,5 @@
 import type { ErrorData, ErrorObject } from '..'
-import { _deepEquals, _isErrorObject, _stringifyAny, Class } from '..'
-import { AppError } from './app.error'
+import { _deepEquals, _isErrorObject, _stringifyAny, AssertionError, Class } from '..'
 
 /**
  * Evaluates the `condition` (casts it to Boolean).
@@ -150,9 +149,3 @@ export function _assertTypeOf<T>(v: any, expectedType: string, message?: string)
     })
   }
 }
-
-export class AssertionError extends AppError {
-  constructor(message: string, data?: ErrorData) {
-    super(message, data, { name: 'AssertionError' })
-  }
-}

package/src/error/error.util.ts

@@ -6,7 +6,7 @@ import type {
   HttpRequestErrorData,
   ErrorLike,
 } from '..'
-import { AppError, _jsonParseIfPossible, _stringifyAny, _truncate } from '..'
+import { _jsonParseIfPossible, _stringifyAny, _truncate, _truncateMiddle } from '..'
 
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -272,3 +272,165 @@ export function _errorDataAppend<ERR>(err: ERR, data?: ErrorData): ERR {
 
   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<DATA_TYPE extends ErrorData = ErrorData> extends Error {
+  data!: DATA_TYPE
+
+  /**
+   * `cause` here is normalized to be an ErrorObject
+   */
+  override cause?: ErrorObject
+
+  constructor(message: string, data = {} as DATA_TYPE, opt: AppErrorOptions = {}) {
+    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,
+    //   })
+    // }
+  }
+}
+
+/**
+ * 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 class HttpRequestError extends AppError<HttpRequestErrorData> {
+  constructor(message: string, data: HttpRequestErrorData, opt?: AppErrorOptions) {
+    if (data.response) {
+      Object.defineProperty(data, 'response', {
+        enumerable: false,
+      })
+    }
+
+    super(message, data, { ...opt, name: 'HttpRequestError' })
+  }
+
+  /**
+   * Cause is strictly-defined for HttpRequestError,
+   * so it always has a cause.
+   * (for dev convenience)
+   */
+  override cause!: ErrorObject
+}
+
+export class AssertionError extends AppError {
+  constructor(message: string, data?: ErrorData) {
+    super(message, data, { name: 'AssertionError' })
+  }
+}
+
+export interface JsonParseErrorData extends ErrorData {
+  /**
+   * Original text that failed to get parsed.
+   */
+  text?: string
+}
+
+export class JsonParseError extends AppError<JsonParseErrorData> {
+  constructor(data: JsonParseErrorData) {
+    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: string, data?: ErrorData, opt?: AppErrorOptions) {
+    super(message, data, { ...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',
+      },
+    )
+  }
+}

package/src/error/try.ts

@@ -1,8 +1,8 @@
 import { _stringifyAny } from '../string/stringifyAny'
 import type { Class } from '../typeFest'
 import type { AnyFunction, ErrorDataTuple } from '../types'
-import { AppError } from './app.error'
 import { _assertErrorClassOrRethrow } from './assert'
+import { UnexpectedPassError } from './error.util'
 
 /**
  * Calls a function, returns a Tuple of [error, value].
@@ -55,23 +55,6 @@ export async function pTry<T, ERR extends Error = Error>(
   }
 }
 
-/**
- * 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',
-      },
-    )
-  }
-}
-
 /**
  * Calls `fn`, expects is to throw, catches the expected error and returns.
  * If error was NOT thrown - throws UnexpectedPassError instead.

package/src/http/fetcher.ts

@@ -4,8 +4,13 @@
 import { isServerSide } from '../env'
 import { _assertErrorClassOrRethrow } from '../error/assert'
 import { ErrorLike, ErrorObject } from '../error/error.model'
-import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject } from '../error/error.util'
-import { HttpRequestError } from '../error/httpRequestError'
+import {
+  _anyToError,
+  _anyToErrorObject,
+  _errorLikeToErrorObject,
+  HttpRequestError,
+  TimeoutError,
+} from '../error/error.util'
 import { _clamp } from '../number/number.util'
 import {
   _filterNullishValues,
@@ -16,7 +21,7 @@ import {
   _pick,
 } from '../object/object.util'
 import { pDelay } from '../promise/pDelay'
-import { pTimeout, TimeoutError } from '../promise/pTimeout'
+import { pTimeout } from '../promise/pTimeout'
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _stringifyAny } from '../string/stringifyAny'
 import { _ms, _since } from '../time/time.util'

package/src/index.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/src/promise/pTimeout.ts

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

package/src/string/json.util.ts

@@ -1,4 +1,4 @@
-import { JsonParseError } from '../error/jsonParseError'
+import { JsonParseError } from '../error/error.util'
 import { Reviver } from '../types'
 
 // const possibleJsonStartTokens = ['{', '[', '"']

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

@@ -1,31 +0,0 @@
-import type { ErrorData, ErrorObject } from './error.model';
-/**
- * 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
-     */
-    cause?: ErrorObject;
-}

package/dist/error/app.error.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppError = void 0;
-/**
- * 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', {
-                // I'd love to do _anyToError(opt.cause) here, but it causes circular dep ;(
-                value: 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;

package/dist/error/httpRequestError.d.ts

@@ -1,28 +0,0 @@
-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.
- * 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;
-}

package/dist/error/httpRequestError.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpRequestError = void 0;
-const app_error_1 = require("./app.error");
-/**
- * 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 app_error_1.AppError {
-    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,11 +0,0 @@
-import { AppError } from './app.error';
-import { ErrorData } from './error.model';
-export interface JsonParseErrorData extends ErrorData {
-    /**
-     * Original text that failed to get parsed.
-     */
-    text?: string;
-}
-export declare class JsonParseError extends AppError<JsonParseErrorData> {
-    constructor(data: JsonParseErrorData);
-}

package/dist/error/jsonParseError.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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) {
-        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-esm/error/app.error.js

@@ -1,53 +0,0 @@
-/**
- * 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', {
-                // I'd love to do _anyToError(opt.cause) here, but it causes circular dep ;(
-                value: 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,
-        //   })
-        // }
-    }
-}

package/dist-esm/error/httpRequestError.js

@@ -1,28 +0,0 @@
-import { AppError } from './app.error';
-/**
- * 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' }));
-    }
-}

package/dist-esm/error/jsonParseError.js

@@ -1,10 +0,0 @@
-import { _truncateMiddle } from '../string/string.util';
-import { AppError } from './app.error';
-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' });
-    }
-}