@naturalcycles/js-lib 14.123.2 → 14.124.0

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

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

package/dist/error/error.util.js

@@ -10,11 +10,12 @@ const __1 = require("..");
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-function _anyToError(o, errorClass = Error, opt) {
+function _anyToError(o, errorClass = Error, errorData, opt) {
     if (o instanceof errorClass)
         return o;
     // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
-    const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, opt);
+    const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt);
+    Object.assign(errorObject.data, errorData);
     return _errorObjectToError(errorObject, errorClass);
 }
 exports._anyToError = _anyToError;
@@ -24,30 +25,37 @@ exports._anyToError = _anyToError;
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
-function _anyToErrorObject(o, opt) {
+function _anyToErrorObject(o, errorData, opt) {
+    let eo;
     if (o instanceof Error) {
-        return _errorToErrorObject(o, opt?.includeErrorStack ?? true);
+        eo = _errorToErrorObject(o, opt?.includeErrorStack ?? true);
     }
-    o = (0, __1._jsonParseIfPossible)(o);
-    if (_isHttpErrorResponse(o)) {
-        return o.error;
+    else {
+        o = (0, __1._jsonParseIfPossible)(o);
+        if (_isHttpErrorResponse(o)) {
+            eo = o.error;
+        }
+        else if (_isErrorObject(o)) {
+            eo = o;
+        }
+        else {
+            // Here we are sure it has no `data` property,
+            // so, fair to return `data: {}` in the end
+            // Also we're sure it includes no "error name", e.g no `Error: ...`,
+            // so, fair to include `name: 'Error'`
+            const message = (0, __1._stringifyAny)(o, {
+                includeErrorData: true,
+                ...opt,
+            });
+            eo = {
+                name: 'Error',
+                message,
+                data: {}, // empty
+            };
+        }
     }
-    if (_isErrorObject(o)) {
-        return o;
-    }
-    // Here we are sure it has no `data` property,
-    // so, fair to return `data: {}` in the end
-    // Also we're sure it includes no "error name", e.g no `Error: ...`,
-    // so, fair to include `name: 'Error'`
-    const message = (0, __1._stringifyAny)(o, {
-        includeErrorData: true,
-        ...opt,
-    });
-    return {
-        name: 'Error',
-        message,
-        data: {}, // empty
-    };
+    Object.assign(eo.data, errorData);
+    return eo;
 }
 exports._anyToErrorObject = _anyToErrorObject;
 function _errorToErrorObject(e, includeErrorStack = true) {

package/dist/http/fetcher.d.ts

@@ -1,6 +1,7 @@
 /// <reference lib="dom" />
 import { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
+import { Reviver } from '../types';
 import type { HttpMethod, HttpStatusFamily } from './http.model';
 export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
     logger: CommonLogger;
@@ -61,6 +62,7 @@ export interface FetcherRetryOptions {
 export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers'> {
     url: string;
     init: RequestInitNormalized;
+    mode: FetcherMode;
     throwHttpErrors: boolean;
     timeoutSeconds: number;
     retry: FetcherRetryOptions;
@@ -108,6 +110,7 @@ export interface FetcherOptions {
      * Defaults to true.
      */
     retry5xx?: boolean;
+    jsonReviver?: Reviver;
 }
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
     method: HttpMethod;
@@ -129,7 +132,7 @@ export interface FetcherResponse<BODY = unknown> {
     body?: BODY;
     retryStatus: FetcherRetryStatus;
 }
-export type FetcherMode = 'json' | 'text';
+export type FetcherMode = 'json' | 'text' | 'void';
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -146,22 +149,22 @@ export declare class Fetcher {
     onBeforeRetry(hook: FetcherBeforeRetryHook): this;
     cfg: FetcherNormalizedCfg;
     static create(cfg?: FetcherCfg & FetcherOptions): Fetcher;
-    get: (url: string, opt?: FetcherOptions) => Promise<void>;
-    post: (url: string, opt?: FetcherOptions) => Promise<void>;
-    put: (url: string, opt?: FetcherOptions) => Promise<void>;
-    patch: (url: string, opt?: FetcherOptions) => Promise<void>;
-    delete: (url: string, opt?: FetcherOptions) => Promise<void>;
-    head: (url: string, opt?: FetcherOptions) => Promise<void>;
+    get: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    post: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    put: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    patch: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    delete: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
     getText: (url: string, opt?: FetcherOptions) => Promise<string>;
     postText: (url: string, opt?: FetcherOptions) => Promise<string>;
     putText: (url: string, opt?: FetcherOptions) => Promise<string>;
     patchText: (url: string, opt?: FetcherOptions) => Promise<string>;
     deleteText: (url: string, opt?: FetcherOptions) => Promise<string>;
-    getJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    postJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    putJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    patchJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
-    deleteJson: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
+    getVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    postVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    putVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    patchVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    deleteVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    headVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
     fetch<T = unknown>(url: string, opt?: FetcherOptions): Promise<T>;
     rawFetch<T = unknown>(url: string, rawOpt?: FetcherOptions): Promise<FetcherResponse<T>>;
     private processRetry;

package/dist/http/fetcher.js

@@ -31,12 +31,16 @@ class Fetcher {
         // Dynamically create all helper methods
         http_model_1.HTTP_METHODS.forEach(method => {
             // mode=void
-            this[method] = async (url, opt) => {
+            this[`${method}Void`] = async (url, opt) => {
                 return await this.fetch(url, {
                     ...opt,
                     method,
+                    mode: 'void',
                 });
             };
+            if (method === 'head')
+                return // mode=text
+                ;
             this[`${method}Text`] = async (url, opt) => {
                 return await this.fetch(url, {
                     ...opt,
@@ -44,7 +48,8 @@ class Fetcher {
                     mode: 'text',
                 });
             };
-            this[`${method}Json`] = async (url, opt) => {
+            // mode=json
+            this[method] = async (url, opt) => {
                 return await this.fetch(url, {
                     ...opt,
                     method,
@@ -74,7 +79,6 @@ class Fetcher {
     static create(cfg = {}) {
         return new Fetcher(cfg);
     }
-    // headJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
     async fetch(url, opt) {
         const res = await this.rawFetch(url, opt);
         if (res.err) {
@@ -115,7 +119,7 @@ class Fetcher {
             const started = Date.now();
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
-                logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`]
+                logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
                     .filter(Boolean)
                     .join(' '));
                 if (this.cfg.logRequestBody && req.init.body) {
@@ -132,22 +136,38 @@ class Fetcher {
             res.statusFamily = this.getStatusFamily(res);
             if (res.fetchResponse?.ok) {
                 if (mode === 'json') {
-                    // if no body: set responseBody as {}
-                    // do not throw a "cannot parse null as Json" error
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.json() : {};
+                    if (res.fetchResponse.body) {
+                        const text = await res.fetchResponse.text();
+                        res.body = text;
+                        try {
+                            res.body = JSON.parse(text, req.jsonReviver);
+                        }
+                        catch (err) {
+                            res.err = (0, error_util_1._anyToError)(err, http_error_1.HttpError, (0, object_util_1._filterNullishValues)({
+                                httpStatusCode: 0,
+                                url: req.url,
+                            }));
+                        }
+                    }
+                    else {
+                        // if no body: set responseBody as {}
+                        // do not throw a "cannot parse null as Json" error
+                        res.body = {};
+                    }
                 }
                 else if (mode === 'text') {
                     res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
                 }
                 clearTimeout(timeout);
                 res.retryStatus.retryStopped = true;
-                if (this.cfg.logResponse) {
+                // res.err can happen on JSON.parse error
+                if (!res.err && this.cfg.logResponse) {
                     const { retryAttempt } = res.retryStatus;
                     logger.log([
                         ' <<',
                         res.fetchResponse.status,
                         signature,
-                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`,
+                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
                         (0, time_util_1._since)(started),
                     ]
                         .filter(Boolean)
@@ -158,6 +178,7 @@ class Fetcher {
                 }
             }
             else {
+                // !res.ok
                 clearTimeout(timeout);
                 let errObj;
                 if (res.fetchResponse) {
@@ -268,6 +289,7 @@ class Fetcher {
         const norm = (0, object_util_1._merge)({
             baseUrl: '',
             url: '',
+            mode: 'void',
             searchParams: {},
             timeoutSeconds: 30,
             throwHttpErrors: true,
@@ -292,8 +314,9 @@ class Fetcher {
         return norm;
     }
     normalizeOptions(url, opt) {
-        const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry } = this.cfg;
+        const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode } = this.cfg;
         const req = {
+            mode,
             url,
             timeoutSeconds,
             throwHttpErrors,

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

@@ -7,11 +7,12 @@ import { AppError, _jsonParseIfPossible, _stringifyAny } from '..';
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-export function _anyToError(o, errorClass = Error, opt) {
+export function _anyToError(o, errorClass = Error, errorData, opt) {
     if (o instanceof errorClass)
         return o;
     // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
-    const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, opt);
+    const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt);
+    Object.assign(errorObject.data, errorData);
     return _errorObjectToError(errorObject, errorClass);
 }
 /**
@@ -20,28 +21,35 @@ export function _anyToError(o, errorClass = Error, opt) {
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
-export function _anyToErrorObject(o, opt) {
+export function _anyToErrorObject(o, errorData, opt) {
     var _a;
+    let eo;
     if (o instanceof Error) {
-        return _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
+        eo = _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
     }
-    o = _jsonParseIfPossible(o);
-    if (_isHttpErrorResponse(o)) {
-        return o.error;
+    else {
+        o = _jsonParseIfPossible(o);
+        if (_isHttpErrorResponse(o)) {
+            eo = o.error;
+        }
+        else if (_isErrorObject(o)) {
+            eo = o;
+        }
+        else {
+            // Here we are sure it has no `data` property,
+            // so, fair to return `data: {}` in the end
+            // Also we're sure it includes no "error name", e.g no `Error: ...`,
+            // so, fair to include `name: 'Error'`
+            const message = _stringifyAny(o, Object.assign({ includeErrorData: true }, opt));
+            eo = {
+                name: 'Error',
+                message,
+                data: {}, // empty
+            };
+        }
     }
-    if (_isErrorObject(o)) {
-        return o;
-    }
-    // Here we are sure it has no `data` property,
-    // so, fair to return `data: {}` in the end
-    // Also we're sure it includes no "error name", e.g no `Error: ...`,
-    // so, fair to include `name: 'Error'`
-    const message = _stringifyAny(o, Object.assign({ includeErrorData: true }, opt));
-    return {
-        name: 'Error',
-        message,
-        data: {}, // empty
-    };
+    Object.assign(eo.data, errorData);
+    return eo;
 }
 export function _errorToErrorObject(e, includeErrorStack = true) {
     const obj = {

package/dist-esm/http/fetcher.js

@@ -1,6 +1,6 @@
 /// <reference lib="dom"/>
 import { __asyncValues } from "tslib";
-import { _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
+import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
 import { HttpError } from '../error/http.error';
 import { _clamp } from '../number/number.util';
 import { _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, } from '../object/object.util';
@@ -29,13 +29,17 @@ export class Fetcher {
         // Dynamically create all helper methods
         HTTP_METHODS.forEach(method => {
             // mode=void
-            this[method] = async (url, opt) => {
-                return await this.fetch(url, Object.assign(Object.assign({}, opt), { method }));
+            this[`${method}Void`] = async (url, opt) => {
+                return await this.fetch(url, Object.assign(Object.assign({}, opt), { method, mode: 'void' }));
             };
+            if (method === 'head')
+                return // mode=text
+                ;
             this[`${method}Text`] = async (url, opt) => {
                 return await this.fetch(url, Object.assign(Object.assign({}, opt), { method, mode: 'text' }));
             };
-            this[`${method}Json`] = async (url, opt) => {
+            // mode=json
+            this[method] = async (url, opt) => {
                 return await this.fetch(url, Object.assign(Object.assign({}, opt), { method, mode: 'json' }));
             };
         });
@@ -64,7 +68,6 @@ export class Fetcher {
     static create(cfg = {}) {
         return new Fetcher(cfg);
     }
-    // headJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
     async fetch(url, opt) {
         const res = await this.rawFetch(url, opt);
         if (res.err) {
@@ -124,7 +127,7 @@ export class Fetcher {
             const started = Date.now();
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
-                logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`]
+                logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
                     .filter(Boolean)
                     .join(' '));
                 if (this.cfg.logRequestBody && req.init.body) {
@@ -141,22 +144,38 @@ export class Fetcher {
             res.statusFamily = this.getStatusFamily(res);
             if ((_g = res.fetchResponse) === null || _g === void 0 ? void 0 : _g.ok) {
                 if (mode === 'json') {
-                    // if no body: set responseBody as {}
-                    // do not throw a "cannot parse null as Json" error
-                    res.body = res.fetchResponse.body ? await res.fetchResponse.json() : {};
+                    if (res.fetchResponse.body) {
+                        const text = await res.fetchResponse.text();
+                        res.body = text;
+                        try {
+                            res.body = JSON.parse(text, req.jsonReviver);
+                        }
+                        catch (err) {
+                            res.err = _anyToError(err, HttpError, _filterNullishValues({
+                                httpStatusCode: 0,
+                                url: req.url,
+                            }));
+                        }
+                    }
+                    else {
+                        // if no body: set responseBody as {}
+                        // do not throw a "cannot parse null as Json" error
+                        res.body = {};
+                    }
                 }
                 else if (mode === 'text') {
                     res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
                 }
                 clearTimeout(timeout);
                 res.retryStatus.retryStopped = true;
-                if (this.cfg.logResponse) {
+                // res.err can happen on JSON.parse error
+                if (!res.err && this.cfg.logResponse) {
                     const { retryAttempt } = res.retryStatus;
                     logger.log([
                         ' <<',
                         res.fetchResponse.status,
                         signature,
-                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`,
+                        retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
                         _since(started),
                     ]
                         .filter(Boolean)
@@ -167,6 +186,7 @@ export class Fetcher {
                 }
             }
             else {
+                // !res.ok
                 clearTimeout(timeout);
                 let errObj;
                 if (res.fetchResponse) {
@@ -310,6 +330,7 @@ export class Fetcher {
         const norm = _merge({
             baseUrl: '',
             url: '',
+            mode: 'void',
             searchParams: {},
             timeoutSeconds: 30,
             throwHttpErrors: true,
@@ -334,8 +355,9 @@ export class Fetcher {
         return norm;
     }
     normalizeOptions(url, opt) {
-        const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry } = this.cfg;
-        const req = Object.assign(Object.assign({ url,
+        const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode } = this.cfg;
+        const req = Object.assign(Object.assign({ mode,
+            url,
             timeoutSeconds,
             throwHttpErrors,
             retryPost,

package/package.json

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

package/src/error/error.util.ts

@@ -19,13 +19,15 @@ import { AppError, _jsonParseIfPossible, _stringifyAny } from '..'
 export function _anyToError<ERROR_TYPE extends Error = Error>(
   o: any,
   errorClass: Class<ERROR_TYPE> = Error as any,
+  errorData?: ErrorData,
   opt?: StringifyAnyOptions,
 ): ERROR_TYPE {
   if (o instanceof errorClass) return o
 
   // If it's an instance of Error, but ErrorClass is something else (e.g AppError) - it'll be "repacked" into AppError
 
-  const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, opt)
+  const errorObject = _isErrorObject(o) ? o : _anyToErrorObject(o, {}, opt)
+  Object.assign(errorObject.data, errorData)
   return _errorObjectToError(errorObject, errorClass)
 }
 
@@ -37,37 +39,40 @@ export function _anyToError<ERROR_TYPE extends Error = Error>(
  */
 export function _anyToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   o: any,
+  errorData?: Partial<DATA_TYPE>,
   opt?: StringifyAnyOptions,
 ): ErrorObject<DATA_TYPE> {
-  if (o instanceof Error) {
-    return _errorToErrorObject<DATA_TYPE>(o, opt?.includeErrorStack ?? true)
-  }
-
-  o = _jsonParseIfPossible(o)
-
-  if (_isHttpErrorResponse(o)) {
-    return o.error as any
-  }
+  let eo: ErrorObject<DATA_TYPE>
 
-  if (_isErrorObject(o)) {
-    return o as ErrorObject<DATA_TYPE>
+  if (o instanceof Error) {
+    eo = _errorToErrorObject<DATA_TYPE>(o, opt?.includeErrorStack ?? true)
+  } else {
+    o = _jsonParseIfPossible(o)
+
+    if (_isHttpErrorResponse(o)) {
+      eo = o.error as any
+    } else if (_isErrorObject(o)) {
+      eo = o as ErrorObject<DATA_TYPE>
+    } else {
+      // Here we are sure it has no `data` property,
+      // so, fair to return `data: {}` in the end
+      // Also we're sure it includes no "error name", e.g no `Error: ...`,
+      // so, fair to include `name: 'Error'`
+      const message = _stringifyAny(o, {
+        includeErrorData: true, // cause we're returning an ErrorObject, not a stringified error (yet)
+        ...opt,
+      })
+
+      eo = {
+        name: 'Error',
+        message,
+        data: {} as DATA_TYPE, // empty
+      }
+    }
   }
 
-  // Here we are sure it has no `data` property,
-  // so, fair to return `data: {}` in the end
-  // Also we're sure it includes no "error name", e.g no `Error: ...`,
-  // so, fair to include `name: 'Error'`
-
-  const message = _stringifyAny(o, {
-    includeErrorData: true, // cause we're returning an ErrorObject, not a stringified error (yet)
-    ...opt,
-  })
-
-  return {
-    name: 'Error',
-    message,
-    data: {} as DATA_TYPE, // empty
-  }
+  Object.assign(eo.data, errorData)
+  return eo
 }
 
 export function _errorToErrorObject<DATA_TYPE extends ErrorData = ErrorData>(

package/src/http/fetcher.ts

@@ -1,7 +1,7 @@
 /// <reference lib="dom"/>
 
 import { ErrorObject } from '../error/error.model'
-import { _anyToErrorObject, _errorToErrorObject } from '../error/error.util'
+import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util'
 import { HttpError } from '../error/http.error'
 import { CommonLogger } from '../log/commonLogger'
 import { _clamp } from '../number/number.util'
@@ -16,6 +16,7 @@ import { pDelay } from '../promise/pDelay'
 import { _jsonParseIfPossible } from '../string/json.util'
 import { _since } from '../time/time.util'
 import type { Promisable } from '../typeFest'
+import { Reviver } from '../types'
 import { HTTP_METHODS } from './http.model'
 import type { HttpMethod, HttpStatusFamily } from './http.model'
 
@@ -86,6 +87,7 @@ export interface FetcherRetryOptions {
 export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers'> {
   url: string
   init: RequestInitNormalized
+  mode: FetcherMode
   throwHttpErrors: boolean
   timeoutSeconds: number
   retry: FetcherRetryOptions
@@ -121,7 +123,7 @@ export interface FetcherOptions {
   // init?: Partial<RequestInitNormalized>
 
   headers?: Record<string, any>
-  mode?: FetcherMode // default to undefined (void response)
+  mode?: FetcherMode // default to 'void'
 
   searchParams?: Record<string, any>
 
@@ -144,6 +146,8 @@ export interface FetcherOptions {
    * Defaults to true.
    */
   retry5xx?: boolean
+
+  jsonReviver?: Reviver
 }
 
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
@@ -170,7 +174,7 @@ export interface FetcherResponse<BODY = unknown> {
   retryStatus: FetcherRetryStatus
 }
 
-export type FetcherMode = 'json' | 'text'
+export type FetcherMode = 'json' | 'text' | 'void'
 
 const defRetryOptions: FetcherRetryOptions = {
   count: 2,
@@ -196,14 +200,15 @@ export class Fetcher {
     // Dynamically create all helper methods
     HTTP_METHODS.forEach(method => {
       // mode=void
-      this[method] = async (url: string, opt?: FetcherOptions): Promise<void> => {
+      this[`${method}Void`] = async (url: string, opt?: FetcherOptions): Promise<void> => {
         return await this.fetch<void>(url, {
           ...opt,
           method,
+          mode: 'void',
         })
       }
 
-      // mode=text
+      if (method === 'head') return // mode=text
       ;(this as any)[`${method}Text`] = async (
         url: string,
         opt?: FetcherOptions,
@@ -216,10 +221,7 @@ export class Fetcher {
       }
 
       // mode=json
-      ;(this as any)[`${method}Json`] = async <T = unknown>(
-        url: string,
-        opt?: FetcherOptions,
-      ): Promise<T> => {
+      this[method] = async <T = unknown>(url: string, opt?: FetcherOptions): Promise<T> => {
         return await this.fetch<T>(url, {
           ...opt,
           method,
@@ -254,25 +256,27 @@ export class Fetcher {
   }
 
   // These methods are generated dynamically in the constructor
-  get!: (url: string, opt?: FetcherOptions) => Promise<void>
-  post!: (url: string, opt?: FetcherOptions) => Promise<void>
-  put!: (url: string, opt?: FetcherOptions) => Promise<void>
-  patch!: (url: string, opt?: FetcherOptions) => Promise<void>
-  delete!: (url: string, opt?: FetcherOptions) => Promise<void>
-  head!: (url: string, opt?: FetcherOptions) => Promise<void>
-
+  // These default methods use mode=json
+  get!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  post!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  put!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  patch!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  delete!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+
+  // mode=text
   getText!: (url: string, opt?: FetcherOptions) => Promise<string>
   postText!: (url: string, opt?: FetcherOptions) => Promise<string>
   putText!: (url: string, opt?: FetcherOptions) => Promise<string>
   patchText!: (url: string, opt?: FetcherOptions) => Promise<string>
   deleteText!: (url: string, opt?: FetcherOptions) => Promise<string>
 
-  getJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  postJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  putJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  patchJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  deleteJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
-  // headJson!: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>
+  // mode=void (no body fetching/parsing)
+  getVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
+  postVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
+  putVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
+  patchVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
+  deleteVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
+  headVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
 
   async fetch<T = unknown>(url: string, opt?: FetcherOptions): Promise<T> {
     const res = await this.rawFetch<T>(url, opt)
@@ -329,7 +333,7 @@ export class Fetcher {
       if (this.cfg.logRequest) {
         const { retryAttempt } = res.retryStatus
         logger.log(
-          [' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`]
+          [' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
             .filter(Boolean)
             .join(' '),
         )
@@ -348,9 +352,27 @@ export class Fetcher {
 
       if (res.fetchResponse?.ok) {
         if (mode === 'json') {
-          // if no body: set responseBody as {}
-          // do not throw a "cannot parse null as Json" error
-          res.body = res.fetchResponse.body ? await res.fetchResponse.json() : {}
+          if (res.fetchResponse.body) {
+            const text = await res.fetchResponse.text()
+            res.body = text
+
+            try {
+              res.body = JSON.parse(text, req.jsonReviver)
+            } catch (err) {
+              res.err = _anyToError(
+                err,
+                HttpError,
+                _filterNullishValues({
+                  httpStatusCode: 0,
+                  url: req.url,
+                }),
+              )
+            }
+          } else {
+            // if no body: set responseBody as {}
+            // do not throw a "cannot parse null as Json" error
+            res.body = {}
+          }
         } else if (mode === 'text') {
           res.body = res.fetchResponse.body ? await res.fetchResponse.text() : ''
         }
@@ -358,14 +380,15 @@ export class Fetcher {
         clearTimeout(timeout)
         res.retryStatus.retryStopped = true
 
-        if (this.cfg.logResponse) {
+        // res.err can happen on JSON.parse error
+        if (!res.err && this.cfg.logResponse) {
           const { retryAttempt } = res.retryStatus
           logger.log(
             [
               ' <<',
               res.fetchResponse.status,
               signature,
-              retryAttempt && `try#${retryAttempt + 1}/${req.retry.count}`,
+              retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
               _since(started),
             ]
               .filter(Boolean)
@@ -377,6 +400,7 @@ export class Fetcher {
           }
         }
       } else {
+        // !res.ok
         clearTimeout(timeout)
 
         let errObj: ErrorObject
@@ -500,6 +524,7 @@ export class Fetcher {
       {
         baseUrl: '',
         url: '',
+        mode: 'void',
         searchParams: {},
         timeoutSeconds: 30,
         throwHttpErrors: true,
@@ -529,10 +554,11 @@ export class Fetcher {
   }
 
   private normalizeOptions(url: string, opt: FetcherOptions): FetcherRequest {
-    const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry } =
+    const { baseUrl, timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode } =
       this.cfg
 
     const req: FetcherRequest = {
+      mode,
       url,
       timeoutSeconds,
       throwHttpErrors,