@naturalcycles/js-lib 14.150.0 → 14.151.0

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

@@ -87,6 +87,17 @@ export interface HttpRequestErrorData extends ErrorData {
      */
     responseStatusCode: HttpStatusCode;
 }
+/**
+ * Sometimes there are cases when Errors come from unexpected places,
+ * where err is not instanceof Error, but still looks like Error.
+ */
+export interface ErrorLike {
+    name: string;
+    message: string;
+    stack?: string;
+    data?: any;
+    cause?: any;
+}
 /**
  * Portable object that represents Error.
  * Has extendable generic `data` property.

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

@@ -1,4 +1,4 @@
-import type { ErrorData, ErrorObject, BackendErrorResponseObject, Class, HttpRequestErrorData } from '..';
+import type { ErrorData, ErrorObject, BackendErrorResponseObject, Class, HttpRequestErrorData, ErrorLike } from '..';
 import { AppError } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -16,7 +16,7 @@ export declare function _anyToError<ERROR_TYPE extends Error = Error>(o: any, er
  * 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>): ErrorObject<DATA_TYPE>;
-export declare function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(e: AppError<DATA_TYPE> | Error): ErrorObject<DATA_TYPE>;
+export declare function _errorLikeToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(e: AppError<DATA_TYPE> | Error | ErrorLike): ErrorObject<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 _isBackendErrorResponseObject(o: any): o is BackendErrorResponseObject;
 export declare function _isHttpRequestErrorObject(o: any): o is ErrorObject<HttpRequestErrorData>;
@@ -24,6 +24,7 @@ export declare function _isHttpRequestErrorObject(o: any): o is ErrorObject<Http
  * Note: any instance of AppError is also automatically an ErrorObject
  */
 export declare function _isErrorObject<DATA_TYPE extends ErrorData = ErrorData>(o: any): o is ErrorObject<DATA_TYPE>;
+export declare function _isErrorLike(o: any): o is ErrorLike;
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/dist/error/error.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._errorDataAppend = exports._isErrorObject = exports._isHttpRequestErrorObject = exports._isBackendErrorResponseObject = exports._errorObjectToError = exports._errorToErrorObject = exports._anyToErrorObject = exports._anyToError = void 0;
+exports._errorDataAppend = exports._isErrorLike = exports._isErrorObject = exports._isHttpRequestErrorObject = exports._isBackendErrorResponseObject = exports._errorObjectToError = exports._errorLikeToErrorObject = exports._anyToErrorObject = exports._anyToError = void 0;
 const __1 = require("..");
 /**
  * Useful to ensure that error in `catch (err) { ... }`
@@ -38,8 +38,9 @@ exports._anyToError = _anyToError;
  */
 function _anyToErrorObject(o, errorData) {
     let eo;
-    if (o instanceof Error) {
-        eo = _errorToErrorObject(o);
+    // if (o instanceof Error) {
+    if (_isErrorLike(o)) {
+        eo = _errorLikeToErrorObject(o);
     }
     else {
         o = (0, __1._jsonParseIfPossible)(o);
@@ -49,6 +50,9 @@ function _anyToErrorObject(o, errorData) {
         else if (_isErrorObject(o)) {
             eo = o;
         }
+        else if (_isErrorLike(o)) {
+            eo = _errorLikeToErrorObject(o);
+        }
         else {
             // Here we are sure it has no `data` property,
             // so, fair to return `data: {}` in the end
@@ -66,19 +70,20 @@ function _anyToErrorObject(o, errorData) {
     return eo;
 }
 exports._anyToErrorObject = _anyToErrorObject;
-function _errorToErrorObject(e) {
+function _errorLikeToErrorObject(e) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: { ...e.data },
-        stack: e.stack,
+        data: { ...e.data }, // empty by default
     };
+    if (e.stack)
+        obj.stack = e.stack;
     if (e.cause) {
         obj.cause = _anyToErrorObject(e.cause);
     }
     return obj;
 }
-exports._errorToErrorObject = _errorToErrorObject;
+exports._errorLikeToErrorObject = _errorLikeToErrorObject;
 function _errorObjectToError(o, errorClass = Error) {
     if (o instanceof errorClass)
         return o;
@@ -136,9 +141,10 @@ function _isErrorObject(o) {
         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'
-// }
+function _isErrorLike(o) {
+    return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string';
+}
+exports._isErrorLike = _isErrorLike;
 /**
  * Convenience function to safely add properties to Error's `data` object
  * (even if it wasn't previously existing)

package/dist/http/fetcher.js

@@ -156,7 +156,8 @@ class Fetcher {
             }
             catch (err) {
                 // For example, CORS error would result in "TypeError: failed to fetch" here
-                res.err = err;
+                // or, `fetch failed` with the cause of `unexpected redirect`
+                res.err = (0, error_util_1._anyToError)(err);
                 res.ok = false;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.fetchResponse = undefined;
@@ -259,9 +260,10 @@ class Fetcher {
         clearTimeout(timeout);
         let cause;
         if (res.err) {
-            // This is only possible on JSON.parse error (or CORS error!)
+            // This is only possible on JSON.parse error, or CORS error,
+            // or `unexpected redirect`
             // This check should go first, to avoid calling .text() twice (which will fail)
-            cause = (0, error_util_1._errorToErrorObject)(res.err);
+            cause = (0, error_util_1._errorLikeToErrorObject)(res.err);
         }
         else if (res.fetchResponse) {
             const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
@@ -467,7 +469,7 @@ class Fetcher {
                 ...this.cfg.init,
                 method: opt.method || this.cfg.init.method,
                 credentials: opt.credentials || this.cfg.init.credentials,
-                redirect: opt.followRedirects ?? this.cfg.followRedirects ?? true ? 'follow' : 'error',
+                redirect: opt.redirect || 'follow',
             }, {
                 headers: (0, object_util_1._mapKeys)(opt.headers || {}, k => k.toLowerCase()),
             }),

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

@@ -123,9 +123,11 @@ export interface FetcherOptions {
     body?: Blob | BufferSource | FormData | URLSearchParams | string;
     credentials?: RequestCredentials;
     /**
-     * Default to true.
+     * Default to 'follow'.
+     * 'error' would throw on redirect.
+     * 'manual' will not throw, but return !ok response with 3xx status.
      */
-    followRedirects?: boolean;
+    redirect?: RequestRedirect;
     headers?: Record<string, any>;
     mode?: FetcherMode;
     searchParams?: Record<string, any>;

package/dist/string/stringifyAny.js

@@ -59,10 +59,10 @@ function _stringifyAny(obj, opt = {}) {
     if ((0, error_util_1._isBackendErrorResponseObject)(obj)) {
         return _stringifyAny(obj.error, opt);
     }
-    if (obj instanceof Error || (0, error_util_1._isErrorObject)(obj)) {
+    if (obj instanceof Error || (0, error_util_1._isErrorLike)(obj)) {
         const { includeErrorCause = true } = opt;
         //
-        // Error or ErrorObject
+        // Error or ErrorLike
         //
         // Omit "default" error name as non-informative
         // UPD: no, it's still important to understand that we're dealing with Error and not just some string

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

@@ -31,8 +31,9 @@ export function _anyToError(o, errorClass = Error, errorData) {
  */
 export function _anyToErrorObject(o, errorData) {
     let eo;
-    if (o instanceof Error) {
-        eo = _errorToErrorObject(o);
+    // if (o instanceof Error) {
+    if (_isErrorLike(o)) {
+        eo = _errorLikeToErrorObject(o);
     }
     else {
         o = _jsonParseIfPossible(o);
@@ -42,6 +43,9 @@ export function _anyToErrorObject(o, errorData) {
         else if (_isErrorObject(o)) {
             eo = o;
         }
+        else if (_isErrorLike(o)) {
+            eo = _errorLikeToErrorObject(o);
+        }
         else {
             // Here we are sure it has no `data` property,
             // so, fair to return `data: {}` in the end
@@ -58,13 +62,14 @@ export function _anyToErrorObject(o, errorData) {
     Object.assign(eo.data, errorData);
     return eo;
 }
-export function _errorToErrorObject(e) {
+export function _errorLikeToErrorObject(e) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: Object.assign({}, e.data),
-        stack: e.stack,
+        data: Object.assign({}, e.data), // empty by default
     };
+    if (e.stack)
+        obj.stack = e.stack;
     if (e.cause) {
         obj.cause = _anyToErrorObject(e.cause);
     }
@@ -124,9 +129,9 @@ export function _isErrorObject(o) {
         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'
-// }
+export function _isErrorLike(o) {
+    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/http/fetcher.js

@@ -1,6 +1,6 @@
 /// <reference lib="dom"/>
 import { isServerSide } from '../env';
-import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
+import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject } from '../error/error.util';
 import { HttpRequestError } from '../error/httpRequestError';
 import { _clamp } from '../number/number.util';
 import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util';
@@ -141,7 +141,8 @@ export class Fetcher {
             }
             catch (err) {
                 // For example, CORS error would result in "TypeError: failed to fetch" here
-                res.err = err;
+                // or, `fetch failed` with the cause of `unexpected redirect`
+                res.err = _anyToError(err);
                 res.ok = false;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.fetchResponse = undefined;
@@ -245,9 +246,10 @@ export class Fetcher {
         clearTimeout(timeout);
         let cause;
         if (res.err) {
-            // This is only possible on JSON.parse error (or CORS error!)
+            // This is only possible on JSON.parse error, or CORS error,
+            // or `unexpected redirect`
             // This check should go first, to avoid calling .text() twice (which will fail)
-            cause = _errorToErrorObject(res.err);
+            cause = _errorLikeToErrorObject(res.err);
         }
         else if (res.fetchResponse) {
             const body = _jsonParseIfPossible(await res.fetchResponse.text());
@@ -431,7 +433,6 @@ export class Fetcher {
         return norm;
     }
     normalizeOptions(opt) {
-        var _a, _b;
         const req = Object.assign(Object.assign(Object.assign(Object.assign({}, _pick(this.cfg, [
             'timeoutSeconds',
             'throwHttpErrors',
@@ -444,7 +445,7 @@ export class Fetcher {
             'logRequestBody',
             'logResponse',
             'logResponseBody',
-        ])), { started: Date.now() }), _omit(opt, ['method', 'headers', 'credentials'])), { inputUrl: opt.url || '', fullUrl: opt.url || '', retry: Object.assign(Object.assign({}, this.cfg.retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign(Object.assign({}, this.cfg.init), { method: opt.method || this.cfg.init.method, credentials: opt.credentials || this.cfg.init.credentials, redirect: ((_b = (_a = opt.followRedirects) !== null && _a !== void 0 ? _a : this.cfg.followRedirects) !== null && _b !== void 0 ? _b : true) ? 'follow' : 'error' }), {
+        ])), { started: Date.now() }), _omit(opt, ['method', 'headers', 'credentials'])), { inputUrl: opt.url || '', fullUrl: opt.url || '', retry: Object.assign(Object.assign({}, this.cfg.retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign(Object.assign({}, this.cfg.init), { method: opt.method || this.cfg.init.method, credentials: opt.credentials || this.cfg.init.credentials, redirect: opt.redirect || 'follow' }), {
                 headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
             }) });
         // setup url

package/dist-esm/string/stringifyAny.js

@@ -1,4 +1,4 @@
-import { _isErrorObject, _isBackendErrorResponseObject } from '../error/error.util';
+import { _isBackendErrorResponseObject, _isErrorLike } from '../error/error.util';
 import { _jsonParseIfPossible } from './json.util';
 import { _safeJsonStringify } from './safeJsonStringify';
 const supportsAggregateError = typeof globalThis.AggregateError === 'function';
@@ -55,10 +55,10 @@ export function _stringifyAny(obj, opt = {}) {
     if (_isBackendErrorResponseObject(obj)) {
         return _stringifyAny(obj.error, opt);
     }
-    if (obj instanceof Error || _isErrorObject(obj)) {
+    if (obj instanceof Error || _isErrorLike(obj)) {
         const { includeErrorCause = true } = opt;
         //
-        // Error or ErrorObject
+        // Error or ErrorLike
         //
         // Omit "default" error name as non-informative
         // UPD: no, it's still important to understand that we're dealing with Error and not just some string

package/package.json

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

package/src/error/error.model.ts

@@ -104,13 +104,17 @@ export interface HttpRequestErrorData extends ErrorData {
   responseStatusCode: HttpStatusCode
 }
 
-// export interface ErrorLike {
-//   name: string
-//   message: string
-//   stack?: string
-//   data?: any
-//   cause?: any
-// }
+/**
+ * Sometimes there are cases when Errors come from unexpected places,
+ * where err is not instanceof Error, but still looks like Error.
+ */
+export interface ErrorLike {
+  name: string
+  message: string
+  stack?: string
+  data?: any
+  cause?: any
+}
 
 /**
  * Portable object that represents Error.

package/src/error/error.util.ts

@@ -4,6 +4,7 @@ import type {
   BackendErrorResponseObject,
   Class,
   HttpRequestErrorData,
+  ErrorLike,
 } from '..'
 import { AppError, _jsonParseIfPossible, _stringifyAny } from '..'
 
@@ -53,8 +54,9 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
 ): ErrorObject<DATA_TYPE> {
   let eo: ErrorObject<DATA_TYPE>
 
-  if (o instanceof Error) {
-    eo = _errorToErrorObject<DATA_TYPE>(o)
+  // if (o instanceof Error) {
+  if (_isErrorLike(o)) {
+    eo = _errorLikeToErrorObject(o)
   } else {
     o = _jsonParseIfPossible(o)
 
@@ -62,6 +64,8 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
       eo = o.error as ErrorObject<DATA_TYPE>
     } else if (_isErrorObject(o)) {
       eo = o as ErrorObject<DATA_TYPE>
+    } else if (_isErrorLike(o)) {
+      eo = _errorLikeToErrorObject(o)
     } else {
       // Here we are sure it has no `data` property,
       // so, fair to return `data: {}` in the end
@@ -81,16 +85,17 @@ export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   return eo
 }
 
-export function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
-  e: AppError<DATA_TYPE> | Error,
+export function _errorLikeToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
+  e: AppError<DATA_TYPE> | Error | ErrorLike,
 ): ErrorObject<DATA_TYPE> {
   const obj: ErrorObject<DATA_TYPE> = {
     name: e.name,
     message: e.message,
     data: { ...(e as any).data }, // empty by default
-    stack: e.stack,
   }
 
+  if (e.stack) obj.stack = e.stack
+
   if (e.cause) {
     obj.cause = _anyToErrorObject(e.cause)
   }
@@ -168,9 +173,9 @@ export function _isErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   )
 }
 
-// export function _isErrorLike(o: any): o is ErrorLike {
-//   return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string'
-// }
+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

package/src/http/fetcher.model.ts

@@ -150,9 +150,11 @@ export interface FetcherOptions {
 
   credentials?: RequestCredentials
   /**
-   * Default to true.
+   * Default to 'follow'.
+   * 'error' would throw on redirect.
+   * 'manual' will not throw, but return !ok response with 3xx status.
    */
-  followRedirects?: boolean
+  redirect?: RequestRedirect
 
   // Removing RequestInit from options to simplify FetcherOptions interface.
   // Will instead only add hand-picked useful options, such as `credentials`.

package/src/http/fetcher.ts

@@ -2,7 +2,7 @@
 
 import { isServerSide } from '../env'
 import { ErrorObject } from '../error/error.model'
-import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util'
+import { _anyToError, _anyToErrorObject, _errorLikeToErrorObject } from '../error/error.util'
 import { HttpRequestError } from '../error/httpRequestError'
 import { _clamp } from '../number/number.util'
 import {
@@ -221,7 +221,8 @@ export class Fetcher {
         res.err = undefined
       } catch (err) {
         // For example, CORS error would result in "TypeError: failed to fetch" here
-        res.err = err as Error
+        // or, `fetch failed` with the cause of `unexpected redirect`
+        res.err = _anyToError(err)
         res.ok = false
         // important to set it to undefined, otherwise it can keep the previous value (from previous try)
         res.fetchResponse = undefined
@@ -336,9 +337,10 @@ export class Fetcher {
     let cause: ErrorObject | undefined
 
     if (res.err) {
-      // This is only possible on JSON.parse error (or CORS error!)
+      // This is only possible on JSON.parse error, or CORS error,
+      // or `unexpected redirect`
       // This check should go first, to avoid calling .text() twice (which will fail)
-      cause = _errorToErrorObject(res.err)
+      cause = _errorLikeToErrorObject(res.err)
     } else if (res.fetchResponse) {
       const body = _jsonParseIfPossible(await res.fetchResponse.text())
       if (body) {
@@ -574,7 +576,7 @@ export class Fetcher {
           ...this.cfg.init,
           method: opt.method || this.cfg.init.method,
           credentials: opt.credentials || this.cfg.init.credentials,
-          redirect: opt.followRedirects ?? this.cfg.followRedirects ?? true ? 'follow' : 'error',
+          redirect: opt.redirect || 'follow',
         },
         {
           headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),

package/src/string/stringifyAny.ts

@@ -1,4 +1,4 @@
-import { _isErrorObject, _isBackendErrorResponseObject } from '../error/error.util'
+import { _isBackendErrorResponseObject, _isErrorLike } from '../error/error.util'
 import type { Reviver } from '../types'
 import { _jsonParseIfPossible } from './json.util'
 import { _safeJsonStringify } from './safeJsonStringify'
@@ -92,10 +92,10 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
     return _stringifyAny(obj.error, opt)
   }
 
-  if (obj instanceof Error || _isErrorObject(obj)) {
+  if (obj instanceof Error || _isErrorLike(obj)) {
     const { includeErrorCause = true } = opt
     //
-    // Error or ErrorObject
+    // Error or ErrorLike
     //
 
     // Omit "default" error name as non-informative