@naturalcycles/js-lib 14.122.0 → 14.123.0

package/dist/datetime/localDate.d.ts

@@ -91,7 +91,7 @@ export declare class LocalDate {
     unix(): UnixTimestampNumber;
     unixMillis(): UnixTimestampMillisNumber;
     toJSON(): IsoDateString;
-    format(fmt: LocalDateFormatter): string;
+    format(fmt: Intl.DateTimeFormat | LocalDateFormatter): string;
 }
 /**
  * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`

package/dist/datetime/localDate.js

@@ -404,6 +404,9 @@ class LocalDate {
         return this.toString();
     }
     format(fmt) {
+        if (fmt instanceof Intl.DateTimeFormat) {
+            return fmt.format(this.toDate());
+        }
         return fmt(this);
     }
 }

package/dist/datetime/localTime.d.ts

@@ -120,7 +120,7 @@ export declare class LocalTime {
     toStringCompact(seconds?: boolean): string;
     toString(): string;
     toJSON(): UnixTimestampNumber;
-    format(fmt: LocalTimeFormatter): string;
+    format(fmt: Intl.DateTimeFormat | LocalTimeFormatter): string;
 }
 /**
  * Shortcut wrapper around `LocalDate.parse` / `LocalDate.today`

package/dist/datetime/localTime.js

@@ -479,6 +479,9 @@ class LocalTime {
         return this.unix();
     }
     format(fmt) {
+        if (fmt instanceof Intl.DateTimeFormat) {
+            return fmt.format(this.$date);
+        }
         return fmt(this);
     }
 }

package/dist/http/fetcher.js

@@ -119,9 +119,15 @@ class Fetcher {
                     logger.log(req.init.body); // todo: check if we can _inspect it
                 }
             }
-            res.fetchResponse = await globalThis.fetch(req.url, req.init);
+            try {
+                res.fetchResponse = await globalThis.fetch(req.url, req.init);
+            }
+            catch (err) {
+                // For example, CORS error would result in "TypeError: failed to fetch" here
+                res.err = err;
+            }
             res.statusFamily = this.getStatusFamily(res);
-            if (res.fetchResponse.ok) {
+            if (res.fetchResponse?.ok) {
                 if (mode === 'json') {
                     // if no body: set responseBody as {}
                     // do not throw a "cannot parse null as Json" error
@@ -150,14 +156,28 @@ class Fetcher {
             }
             else {
                 clearTimeout(timeout);
-                const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
-                const errObj = (0, error_util_1._anyToErrorObject)(body);
+                let errObj;
+                if (res.fetchResponse) {
+                    const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
+                    errObj = (0, error_util_1._anyToErrorObject)(body);
+                }
+                else if (res.err) {
+                    errObj = (0, error_util_1._errorToErrorObject)(res.err);
+                }
+                else {
+                    errObj = {};
+                }
                 const originalMessage = errObj.message;
-                errObj.message = [[res.fetchResponse.status, signature].join(' '), originalMessage].join('\n');
+                errObj.message = [
+                    [res.fetchResponse?.status, signature].filter(Boolean).join(' '),
+                    originalMessage,
+                ]
+                    .filter(Boolean)
+                    .join('\n');
                 res.err = new http_error_1.HttpError(errObj.message, (0, object_util_1._filterNullishValues)({
                     ...errObj.data,
                     originalMessage,
-                    httpStatusCode: res.fetchResponse.status,
+                    httpStatusCode: res.fetchResponse?.status || 0,
                     // These properties are provided to be used in e.g custom Sentry error grouping
                     // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
                     // Enabled, cause `data` is not printed by default when error is HttpError
@@ -201,8 +221,13 @@ class Fetcher {
         if (method === 'post' && !retryPost)
             return false;
         const { statusFamily } = res;
+        const statusCode = res.fetchResponse?.status || 0;
         if (statusFamily === 5 && !retry5xx)
             return false;
+        if ([408, 429].includes(statusCode)) {
+            // these codes are always retried
+            return true;
+        }
         if (statusFamily === 4 && !retry4xx)
             return false;
         return true; // default is true
@@ -254,11 +279,12 @@ class Fetcher {
             logResponseBody: debug,
             retry: { ...defRetryOptions },
             init: {
-                method: 'get',
-                headers: {},
+                method: cfg.method || 'get',
+                headers: cfg.headers || {},
+                credentials: cfg.credentials,
             },
             hooks: {},
-        }, cfg);
+        }, (0, object_util_1._omit)(cfg, ['method', 'credentials', 'headers']));
         norm.init.headers = (0, object_util_1._mapKeys)(norm.init.headers, k => k.toLowerCase());
         return norm;
     }
@@ -271,18 +297,18 @@ class Fetcher {
             retryPost,
             retry4xx,
             retry5xx,
-            ...(0, object_util_1._omit)(opt, ['method', 'headers']),
+            ...(0, object_util_1._omit)(opt, ['method', 'headers', 'credentials']),
             retry: {
                 ...retry,
                 ...(0, object_util_1._filterUndefinedValues)(opt.retry || {}),
             },
-            init: (0, object_util_1._merge)({ ...this.cfg.init }, 
-            // opt.init,
-            (0, object_util_1._filterUndefinedValues)({
-                method: opt.method,
-                credentials: opt.credentials,
+            init: (0, object_util_1._merge)({
+                ...this.cfg.init,
+                method: opt.method || this.cfg.init.method,
+                credentials: opt.credentials || this.cfg.init.credentials,
+            }, {
                 headers: (0, object_util_1._mapKeys)(opt.headers || {}, k => k.toLowerCase()),
-            })),
+            }),
         };
         // setup url
         if (baseUrl) {

package/dist-esm/datetime/localDate.js

@@ -401,6 +401,9 @@ export class LocalDate {
         return this.toString();
     }
     format(fmt) {
+        if (fmt instanceof Intl.DateTimeFormat) {
+            return fmt.format(this.toDate());
+        }
         return fmt(this);
     }
 }

package/dist-esm/datetime/localTime.js

@@ -477,6 +477,9 @@ export class LocalTime {
         return this.unix();
     }
     format(fmt) {
+        if (fmt instanceof Intl.DateTimeFormat) {
+            return fmt.format(this.$date);
+        }
         return fmt(this);
     }
 }

package/dist-esm/http/fetcher.js

@@ -1,6 +1,6 @@
 /// <reference lib="dom"/>
 import { __asyncValues } from "tslib";
-import { _anyToErrorObject } from '../error/error.util';
+import { _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';
@@ -73,6 +73,7 @@ export class Fetcher {
     }
     async rawFetch(url, rawOpt = {}) {
         var _a, e_1, _b, _c, _d, e_2, _e, _f;
+        var _g, _h, _j;
         const { logger } = this.cfg;
         const req = this.normalizeOptions(url, rawOpt);
         const { timeoutSeconds, mode, init: { method }, } = req;
@@ -86,22 +87,22 @@ export class Fetcher {
             }, timeoutSeconds * 1000);
         }
         try {
-            for (var _g = true, _h = __asyncValues(this.cfg.hooks.beforeRequest || []), _j; _j = await _h.next(), _a = _j.done, !_a;) {
-                _c = _j.value;
-                _g = false;
+            for (var _k = true, _l = __asyncValues(this.cfg.hooks.beforeRequest || []), _m; _m = await _l.next(), _a = _m.done, !_a;) {
+                _c = _m.value;
+                _k = false;
                 try {
                     const hook = _c;
                     await hook(req);
                 }
                 finally {
-                    _g = true;
+                    _k = true;
                 }
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (!_g && !_a && (_b = _h.return)) await _b.call(_h);
+                if (!_k && !_a && (_b = _l.return)) await _b.call(_l);
             }
             finally { if (e_1) throw e_1.error; }
         }
@@ -127,9 +128,15 @@ export class Fetcher {
                     logger.log(req.init.body); // todo: check if we can _inspect it
                 }
             }
-            res.fetchResponse = await globalThis.fetch(req.url, req.init);
+            try {
+                res.fetchResponse = await globalThis.fetch(req.url, req.init);
+            }
+            catch (err) {
+                // For example, CORS error would result in "TypeError: failed to fetch" here
+                res.err = err;
+            }
             res.statusFamily = this.getStatusFamily(res);
-            if (res.fetchResponse.ok) {
+            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
@@ -158,11 +165,25 @@ export class Fetcher {
             }
             else {
                 clearTimeout(timeout);
-                const body = _jsonParseIfPossible(await res.fetchResponse.text());
-                const errObj = _anyToErrorObject(body);
+                let errObj;
+                if (res.fetchResponse) {
+                    const body = _jsonParseIfPossible(await res.fetchResponse.text());
+                    errObj = _anyToErrorObject(body);
+                }
+                else if (res.err) {
+                    errObj = _errorToErrorObject(res.err);
+                }
+                else {
+                    errObj = {};
+                }
                 const originalMessage = errObj.message;
-                errObj.message = [[res.fetchResponse.status, signature].join(' '), originalMessage].join('\n');
-                res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: res.fetchResponse.status, 
+                errObj.message = [
+                    [(_h = res.fetchResponse) === null || _h === void 0 ? void 0 : _h.status, signature].filter(Boolean).join(' '),
+                    originalMessage,
+                ]
+                    .filter(Boolean)
+                    .join('\n');
+                res.err = new HttpError(errObj.message, _filterNullishValues(Object.assign(Object.assign({}, errObj.data), { originalMessage, httpStatusCode: ((_j = res.fetchResponse) === null || _j === void 0 ? void 0 : _j.status) || 0, 
                     // These properties are provided to be used in e.g custom Sentry error grouping
                     // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
                     // Enabled, cause `data` is not printed by default when error is HttpError
@@ -172,22 +193,22 @@ export class Fetcher {
             }
         }
         try {
-            for (var _k = true, _l = __asyncValues(this.cfg.hooks.afterResponse || []), _m; _m = await _l.next(), _d = _m.done, !_d;) {
-                _f = _m.value;
-                _k = false;
+            for (var _o = true, _p = __asyncValues(this.cfg.hooks.afterResponse || []), _q; _q = await _p.next(), _d = _q.done, !_d;) {
+                _f = _q.value;
+                _o = false;
                 try {
                     const hook = _f;
                     await hook(res);
                 }
                 finally {
-                    _k = true;
+                    _o = true;
                 }
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
         finally {
             try {
-                if (!_k && !_d && (_e = _l.return)) await _e.call(_l);
+                if (!_o && !_d && (_e = _p.return)) await _e.call(_p);
             }
             finally { if (e_2) throw e_2.error; }
         }
@@ -234,13 +255,19 @@ export class Fetcher {
      * unless there's reason not to (e.g method is POST).
      */
     shouldRetry(res) {
+        var _a;
         const { retryPost, retry4xx, retry5xx } = res.req;
         const { method } = res.req.init;
         if (method === 'post' && !retryPost)
             return false;
         const { statusFamily } = res;
+        const statusCode = ((_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status) || 0;
         if (statusFamily === 5 && !retry5xx)
             return false;
+        if ([408, 429].includes(statusCode)) {
+            // these codes are always retried
+            return true;
+        }
         if (statusFamily === 4 && !retry4xx)
             return false;
         return true; // default is true
@@ -294,11 +321,12 @@ export class Fetcher {
             logResponseBody: debug,
             retry: Object.assign({}, defRetryOptions),
             init: {
-                method: 'get',
-                headers: {},
+                method: cfg.method || 'get',
+                headers: cfg.headers || {},
+                credentials: cfg.credentials,
             },
             hooks: {},
-        }, cfg);
+        }, _omit(cfg, ['method', 'credentials', 'headers']));
         norm.init.headers = _mapKeys(norm.init.headers, k => k.toLowerCase());
         return norm;
     }
@@ -309,13 +337,9 @@ export class Fetcher {
             throwHttpErrors,
             retryPost,
             retry4xx,
-            retry5xx }, _omit(opt, ['method', 'headers'])), { retry: Object.assign(Object.assign({}, retry), _filterUndefinedValues(opt.retry || {})), init: _merge(Object.assign({}, this.cfg.init), 
-            // opt.init,
-            _filterUndefinedValues({
-                method: opt.method,
-                credentials: opt.credentials,
+            retry5xx }, _omit(opt, ['method', 'headers', 'credentials'])), { retry: Object.assign(Object.assign({}, 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 }), {
                 headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
-            })) });
+            }) });
         // setup url
         if (baseUrl) {
             if (url.startsWith('/')) {

package/package.json

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

package/src/datetime/localDate.ts

@@ -492,7 +492,11 @@ export class LocalDate {
     return this.toString()
   }
 
-  format(fmt: LocalDateFormatter): string {
+  format(fmt: Intl.DateTimeFormat | LocalDateFormatter): string {
+    if (fmt instanceof Intl.DateTimeFormat) {
+      return fmt.format(this.toDate())
+    }
+
     return fmt(this)
   }
 }

package/src/datetime/localTime.ts

@@ -590,7 +590,11 @@ export class LocalTime {
     return this.unix()
   }
 
-  format(fmt: LocalTimeFormatter): string {
+  format(fmt: Intl.DateTimeFormat | LocalTimeFormatter): string {
+    if (fmt instanceof Intl.DateTimeFormat) {
+      return fmt.format(this.$date)
+    }
+
     return fmt(this)
   }
 }

package/src/http/fetcher.ts

@@ -1,6 +1,7 @@
 /// <reference lib="dom"/>
 
-import { _anyToErrorObject } from '../error/error.util'
+import { ErrorObject } from '../error/error.model'
+import { _anyToErrorObject, _errorToErrorObject } from '../error/error.util'
 import { HttpError } from '../error/http.error'
 import { CommonLogger } from '../log/commonLogger'
 import { _clamp } from '../number/number.util'
@@ -333,10 +334,15 @@ export class Fetcher {
         }
       }
 
-      res.fetchResponse = await globalThis.fetch(req.url, req.init)
+      try {
+        res.fetchResponse = await globalThis.fetch(req.url, req.init)
+      } catch (err) {
+        // For example, CORS error would result in "TypeError: failed to fetch" here
+        res.err = err as Error
+      }
       res.statusFamily = this.getStatusFamily(res)
 
-      if (res.fetchResponse.ok) {
+      if (res.fetchResponse?.ok) {
         if (mode === 'json') {
           // if no body: set responseBody as {}
           // do not throw a "cannot parse null as Json" error
@@ -369,12 +375,24 @@ export class Fetcher {
       } else {
         clearTimeout(timeout)
 
-        const body = _jsonParseIfPossible(await res.fetchResponse.text())
-        const errObj = _anyToErrorObject(body)
+        let errObj: ErrorObject
+
+        if (res.fetchResponse) {
+          const body = _jsonParseIfPossible(await res.fetchResponse.text())
+          errObj = _anyToErrorObject(body)
+        } else if (res.err) {
+          errObj = _errorToErrorObject(res.err)
+        } else {
+          errObj = {} as ErrorObject
+        }
+
         const originalMessage = errObj.message
-        errObj.message = [[res.fetchResponse.status, signature].join(' '), originalMessage].join(
-          '\n',
-        )
+        errObj.message = [
+          [res.fetchResponse?.status, signature].filter(Boolean).join(' '),
+          originalMessage,
+        ]
+          .filter(Boolean)
+          .join('\n')
 
         res.err = new HttpError(
           errObj.message,
@@ -382,7 +400,7 @@ export class Fetcher {
           _filterNullishValues({
             ...errObj.data,
             originalMessage,
-            httpStatusCode: res.fetchResponse.status,
+            httpStatusCode: res.fetchResponse?.status || 0,
             // These properties are provided to be used in e.g custom Sentry error grouping
             // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
             // Enabled, cause `data` is not printed by default when error is HttpError
@@ -437,7 +455,12 @@ export class Fetcher {
     const { method } = res.req.init
     if (method === 'post' && !retryPost) return false
     const { statusFamily } = res
+    const statusCode = res.fetchResponse?.status || 0
     if (statusFamily === 5 && !retry5xx) return false
+    if ([408, 429].includes(statusCode)) {
+      // these codes are always retried
+      return true
+    }
     if (statusFamily === 4 && !retry4xx) return false
     return true // default is true
   }
@@ -487,12 +510,13 @@ export class Fetcher {
         logResponseBody: debug,
         retry: { ...defRetryOptions },
         init: {
-          method: 'get',
-          headers: {},
+          method: cfg.method || 'get',
+          headers: cfg.headers || {},
+          credentials: cfg.credentials,
         },
         hooks: {},
       },
-      cfg,
+      _omit(cfg, ['method', 'credentials', 'headers']),
     )
 
     norm.init.headers = _mapKeys(norm.init.headers, k => k.toLowerCase())
@@ -511,19 +535,20 @@ export class Fetcher {
       retryPost,
       retry4xx,
       retry5xx,
-      ..._omit(opt, ['method', 'headers']),
+      ..._omit(opt, ['method', 'headers', 'credentials']),
       retry: {
         ...retry,
         ..._filterUndefinedValues(opt.retry || {}),
       },
       init: _merge(
-        { ...this.cfg.init },
-        // opt.init,
-        _filterUndefinedValues({
-          method: opt.method,
-          credentials: opt.credentials,
+        {
+          ...this.cfg.init,
+          method: opt.method || this.cfg.init.method,
+          credentials: opt.credentials || this.cfg.init.credentials,
+        },
+        {
           headers: _mapKeys(opt.headers || {}, k => k.toLowerCase()),
-        } as RequestInit),
+        } as RequestInit,
       ),
     }