@naturalcycles/js-lib 14.117.0 → 14.118.0

package/dist/object/object.util.js

@@ -15,14 +15,12 @@ function _pick(obj, props, mutate = false) {
             return r;
         }, obj);
     }
-    else {
-        // Start as empty object, pick/add needed properties
-        return props.reduce((r, prop) => {
-            if (prop in obj)
-                r[prop] = obj[prop];
-            return r;
-        }, {});
-    }
+    // Start as empty object, pick/add needed properties
+    return props.reduce((r, prop) => {
+        if (prop in obj)
+            r[prop] = obj[prop];
+        return r;
+    }, {});
 }
 exports._pick = _pick;
 /**
@@ -259,7 +257,7 @@ function _unset(obj, prop) {
     }
     const segs = prop.split('.');
     let last = segs.pop();
-    while (segs.length && segs[segs.length - 1].slice(-1) === '\\') {
+    while (segs.length && segs[segs.length - 1].endsWith('\\')) {
         last = segs.pop().slice(0, -1) + '.' + last;
     }
     while (segs.length && (0, is_util_1._isObject)(obj)) {
@@ -329,7 +327,7 @@ function _set(obj, path, value) {
             a[c]
         : // No: create the key. Is the next key a potential array-index?
             (a[c] =
-                // @ts-ignore
+                // @ts-expect-error
                 // eslint-disable-next-line
                 Math.abs(path[i + 1]) >> 0 === +path[i + 1]
                     ? [] // Yes: assign a new array object

package/dist/promise/pRetry.d.ts

@@ -35,7 +35,7 @@ export interface PRetryOptions {
      *
      * @default () => true
      */
-    predicate?: (err: Error, attempt: number, maxAttempts: number) => boolean;
+    predicate?(err: Error, attempt: number, maxAttempts: number): boolean;
     /**
      * Log the first attempt (which is not a "retry" yet).
      *

package/dist/promise/pTimeout.d.ts

@@ -20,7 +20,7 @@ export interface PTimeoutOptions {
      * err (which is TimeoutError) is passed as an argument for convenience, so it can
      * be logged or such. You don't have to consume it in any way though.
      */
-    onTimeout?: (err: TimeoutError) => any;
+    onTimeout?(err: TimeoutError): any;
     /**
      * Defaults to true.
      * If true - preserves the stack trace in case of a Timeout (usually - very useful!).

package/dist/string/pupa.d.ts

@@ -11,10 +11,10 @@ export interface PupaOptions {
     /**
      * Performs arbitrary operation for each interpolation. If the returned value was `undefined`, it behaves differently depending on the `ignoreMissing` option. Otherwise, the returned value will be interpolated into a string (and escaped when double-braced) and embedded into the template.
      */
-    transform?: (data: {
+    transform?(data: {
         value: any;
         key: string;
-    }) => unknown;
+    }): unknown;
 }
 /**
  * API: https://github.com/sindresorhus/pupa

package/dist/string/readingTime.d.ts

@@ -4,7 +4,7 @@ export interface ReadingTimeOptions {
      * A function that returns a boolean value depending on if a character is considered as a word bound.
      * Default: spaces, new lines and tabs
      */
-    wordBound?: (char: string) => boolean;
+    wordBound?(char: string): boolean;
     /**
      * Default 200
      */

package/dist/string/safeJsonStringify.js

@@ -21,13 +21,11 @@ exports._safeJsonStringify = _safeJsonStringify;
 function serializer(replacer, cycleReplacer) {
     const stack = [];
     const keys = [];
-    if (cycleReplacer == null) {
-        cycleReplacer = function (key, value) {
-            if (stack[0] === value)
-                return '[Circular ~]';
-            return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
-        };
-    }
+    cycleReplacer ??= function (key, value) {
+        if (stack[0] === value)
+            return '[Circular ~]';
+        return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
+    };
     return function (key, value) {
         if (stack.length > 0) {
             const thisPos = stack.indexOf(this);

package/dist/string/stringifyAny.js

@@ -56,7 +56,8 @@ function _stringifyAny(obj, opt = {}) {
             // This is to fix the rare error (happened with Got) where `err.message` was changed,
             // but err.stack had "old" err.message
             // This should "fix" that
-            s = [s, ...obj.stack.split('\n').slice(1)].join('\n');
+            const sLines = s.split('\n').length;
+            s = [s, ...obj.stack.split('\n').slice(sLines)].join('\n');
         }
         if ((0, error_util_1._isErrorObject)(obj)) {
             if ((0, error_util_1._isHttpErrorObject)(obj)) {

package/dist/string/url.util.js

@@ -17,7 +17,7 @@ exports._parseQueryString = void 0;
 function _parseQueryString(search) {
     const qs = {};
     search
-        .slice(search[0] === '?' ? 1 : 0)
+        .slice(search.startsWith('?') ? 1 : 0)
         .split('&')
         .forEach(p => {
         const [k, v] = p.split('=');

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

@@ -148,21 +148,21 @@ export function _findLast(items, predicate) {
 }
 export function _takeWhile(items, predicate) {
     let proceed = true;
-    return items.filter((v, index) => (proceed = proceed && predicate(v, index)));
+    return items.filter((v, index) => (proceed && (proceed = predicate(v, index))));
 }
 export function _takeRightWhile(items, predicate) {
     let proceed = true;
-    return [...items].reverse().filter((v, index) => (proceed = proceed && predicate(v, index)));
+    return [...items].reverse().filter((v, index) => (proceed && (proceed = predicate(v, index))));
 }
 export function _dropWhile(items, predicate) {
     let proceed = false;
-    return items.filter((v, index) => (proceed = proceed || !predicate(v, index)));
+    return items.filter((v, index) => (proceed || (proceed = !predicate(v, index))));
 }
 export function _dropRightWhile(items, predicate) {
     let proceed = false;
     return [...items]
         .reverse()
-        .filter((v, index) => (proceed = proceed || !predicate(v, index)))
+        .filter((v, index) => (proceed || (proceed = !predicate(v, index))))
         .reverse();
 }
 export function _countBy(items, mapper) {

package/dist-esm/datetime/dateInterval.js

@@ -46,6 +46,7 @@ export class DateInterval {
      */
     includes(d, incl = '[]') {
         d = LocalDate.of(d);
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         return d.isAfter(this.start, incl[0] === '[') && d.isBefore(this.end, incl[1] === ']');
     }
     intersects(int, inclusive = true) {

package/dist-esm/datetime/localDate.js

@@ -109,6 +109,7 @@ export class LocalDate {
         const $min = LocalDate.of(min);
         const $max = LocalDate.of(max).startOf(stepUnit);
         let current = $min.startOf(stepUnit);
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (current.isAfter($min, incl[0] === '[')) {
             // ok
         }
@@ -167,6 +168,7 @@ export class LocalDate {
     }
     isBetween(min, max, incl = '[)') {
         let r = this.cmp(min);
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (r < 0 || (r === 0 && incl[0] === '('))
             return false;
         r = this.cmp(max);

package/dist-esm/datetime/localTime.js

@@ -345,6 +345,7 @@ export class LocalTime {
     }
     isBetween(min, max, incl = '[)') {
         let r = this.cmp(min);
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (r < 0 || (r === 0 && incl[0] === '('))
             return false;
         r = this.cmp(max);
@@ -521,9 +522,7 @@ function getWeekYear(date) {
     else if (date.getTime() >= startOfThisYear.getTime()) {
         return year;
     }
-    else {
-        return year - 1;
-    }
+    return year - 1;
 }
 // based on: https://github.com/date-fns/date-fns/blob/fd6bb1a0bab143f2da068c05a9c562b9bee1357d/src/startOfWeek/index.ts
 function startOfWeek(date, mutate = false) {

package/dist-esm/datetime/timeInterval.js

@@ -56,6 +56,7 @@ export class TimeInterval {
     }
     includes(d, incl = '[)') {
         d = LocalTime.parseToUnixTimestamp(d);
+        // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (d < this.$start || (d === this.$start && incl[0] === '('))
             return false;
         if (d > this.$end || (d === this.$end && incl[1] === ')'))

package/dist-esm/decorators/logMethod.decorator.js

@@ -56,11 +56,9 @@ export function _LogMethod(opt = {}) {
                         throw err;
                     });
                 }
-                else {
-                    // not a Promise
-                    logFinished(logger, callSignature, started, sma, logResultFn, res);
-                    return res;
-                }
+                // not a Promise
+                logFinished(logger, callSignature, started, sma, logResultFn, res);
+                return res;
             }
             catch (err) {
                 logFinished(logger, callSignature, started, sma, logResultFn, undefined, err);
@@ -70,6 +68,7 @@ export function _LogMethod(opt = {}) {
         return descriptor;
     };
 }
+// eslint-disable-next-line max-params
 function logFinished(logger, callSignature, started, sma, logResultFn, res, err) {
     const millis = Date.now() - started;
     const t = ['<<', callSignature, 'took', _ms(millis)];

package/dist-esm/http/fetcher.js

@@ -0,0 +1,251 @@
+/// <reference lib="dom"/>
+import { _anyToErrorObject } from '../error/error.util';
+import { HttpError } from '../error/http.error';
+import { _clamp } from '../number/number.util';
+import { _filterNullishValues, _filterUndefinedValues } from '../object/object.util';
+import { pDelay } from '../promise/pDelay';
+import { _jsonParseIfPossible } from '../string/json.util';
+import { _stringifyAny } from '../string/stringifyAny';
+import { _since } from '../time/time.util';
+import { _objectAssign } from '../types';
+const defRetryOptions = {
+    count: 2,
+    timeout: 500,
+    timeoutMax: 30000,
+    timeoutMultiplier: 2,
+};
+/**
+ * Experimental wrapper around Fetch.
+ * Works in both Browser and Node, using `globalThis.fetch`.
+ *
+ * @experimental
+ */
+export class Fetcher {
+    constructor(cfg = {}) {
+        this.cfg = this.normalizeCfg(cfg);
+    }
+    static create(cfg = {}) {
+        return new Fetcher(cfg);
+    }
+    async getJson(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { mode: 'json' }));
+    }
+    async postJson(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'post', mode: 'json' }));
+    }
+    async getText(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { mode: 'text' }));
+    }
+    async postText(url, opt = {}) {
+        return await this.fetch(url, Object.assign(Object.assign({}, opt), { method: 'post', mode: 'text' }));
+    }
+    async fetch(url, opt = {}) {
+        const res = await this.rawFetch(url, opt);
+        if (res.err) {
+            if (res.req.opt.throwHttpErrors)
+                throw res.err;
+            return res;
+        }
+        return res.body;
+    }
+    async rawFetch(url, rawOpt = {}) {
+        var _a, _b, _c, _d;
+        const { baseUrl, logger } = this.cfg;
+        const opt = this.normalizeOptions(rawOpt);
+        const { method, timeoutSeconds, mode } = opt;
+        const req = {
+            url,
+            init: Object.assign(Object.assign({}, this.cfg.requestInit), { method }),
+            opt,
+        };
+        // setup url
+        if (baseUrl) {
+            if (url.startsWith('/')) {
+                console.warn(`Fetcher: url should not start with / when baseUrl is specified`);
+                url = url.slice(1);
+            }
+            req.url = `${baseUrl}/${url}`;
+        }
+        // setup request body
+        if (opt.json !== undefined) {
+            req.init.body = JSON.stringify(opt.json);
+        }
+        else if (opt.text !== undefined) {
+            req.init.body = opt.text;
+        }
+        // setup timeout
+        let timeout;
+        if (timeoutSeconds) {
+            const abortController = new AbortController();
+            req.init.signal = abortController.signal;
+            timeout = setTimeout(() => {
+                abortController.abort(`timeout of ${timeoutSeconds} sec`);
+            }, timeoutSeconds * 1000);
+        }
+        if (opt.requestInit) {
+            _objectAssign(req.init, opt.requestInit);
+        }
+        await ((_b = (_a = this.cfg.hooks) === null || _a === void 0 ? void 0 : _a.beforeRequest) === null || _b === void 0 ? void 0 : _b.call(_a, req));
+        const res = {
+            req,
+            retryStatus: {
+                retryAttempt: 0,
+                retryStopped: false,
+                retryTimeout: opt.retry.timeout,
+            },
+        };
+        const shortUrl = this.getShortUrl(req.url);
+        const signature = [method.toUpperCase(), shortUrl].join(' ');
+        /* eslint-disable no-await-in-loop */
+        while (!res.retryStatus.retryStopped) {
+            const started = Date.now();
+            if (this.cfg.logRequest) {
+                const { retryAttempt } = res.retryStatus;
+                logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${opt.retry.count}`]
+                    .filter(Boolean)
+                    .join(' '));
+                if (this.cfg.logRequestBody && req.init.body) {
+                    logger.log(req.init.body); // todo: check if we can _inspect it
+                }
+            }
+            res.fetchResponse = await globalThis.fetch(req.url, req.init);
+            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() : {};
+                }
+                else if (mode === 'text') {
+                    res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
+                }
+                clearTimeout(timeout);
+                res.retryStatus.retryStopped = true;
+                if (this.cfg.logResponse) {
+                    const { retryAttempt } = res.retryStatus;
+                    logger.log([
+                        ' <<',
+                        res.fetchResponse.status,
+                        signature,
+                        retryAttempt && `try#${retryAttempt + 1}/${opt.retry.count}`,
+                        _since(started),
+                    ]
+                        .filter(Boolean)
+                        .join(' '));
+                    if (this.cfg.logResponseBody) {
+                        logger.log(res.body);
+                    }
+                }
+            }
+            else {
+                clearTimeout(timeout);
+                const body = _jsonParseIfPossible(await res.fetchResponse.text());
+                const errObj = _anyToErrorObject(body);
+                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, 
+                    // 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
+                    // method: req.method,
+                    url: req.url })));
+                if (this.cfg.logResponse) {
+                    const { retryAttempt } = res.retryStatus;
+                    logger.error([
+                        [
+                            ' <<',
+                            res.fetchResponse.status,
+                            signature,
+                            retryAttempt && `try#${retryAttempt + 1}/${opt.retry.count}`,
+                            _since(started),
+                        ]
+                            .filter(Boolean)
+                            .join(' '),
+                        _stringifyAny(body),
+                    ].join('\n'));
+                }
+                await this.processRetry(res);
+            }
+        }
+        await ((_d = (_c = this.cfg.hooks) === null || _c === void 0 ? void 0 : _c.beforeResponse) === null || _d === void 0 ? void 0 : _d.call(_c, res));
+        return res;
+    }
+    async processRetry(res) {
+        var _a, _b;
+        const { retryStatus } = res;
+        if (!this.shouldRetry(res)) {
+            retryStatus.retryStopped = true;
+        }
+        await ((_b = (_a = this.cfg.hooks) === null || _a === void 0 ? void 0 : _a.beforeRetry) === null || _b === void 0 ? void 0 : _b.call(_a, res));
+        const { count, timeoutMultiplier, timeoutMax } = res.req.opt.retry;
+        if (retryStatus.retryAttempt >= count) {
+            retryStatus.retryStopped = true;
+        }
+        if (retryStatus.retryStopped)
+            return;
+        retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
+        await pDelay(retryStatus.retryTimeout);
+    }
+    /**
+     * Default is yes,
+     * unless there's reason not to (e.g method is POST).
+     */
+    shouldRetry(res) {
+        const { retryPost, retry4xx, retry5xx } = res.req.opt;
+        const { method } = res.req.init;
+        if (method === 'post' && !retryPost)
+            return false;
+        const { statusFamily } = res;
+        if (statusFamily === '5xx' && !retry5xx)
+            return false;
+        if (statusFamily === '4xx' && !retry4xx)
+            return false;
+        return true; // default is true
+    }
+    getStatusFamily(res) {
+        var _a;
+        const status = (_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status;
+        if (!status)
+            return;
+        if (status >= 500)
+            return '5xx';
+        if (status >= 400)
+            return '4xx';
+        if (status >= 300)
+            return '3xx';
+        if (status >= 200)
+            return '2xx';
+        if (status >= 100)
+            return '1xx';
+    }
+    /**
+     * Returns url without baseUrl and before ?queryString
+     */
+    getShortUrl(url) {
+        const { baseUrl } = this.cfg;
+        if (!baseUrl)
+            return url;
+        return url.split('?')[0].slice(baseUrl.length);
+    }
+    normalizeCfg(cfg) {
+        var _a;
+        if ((_a = cfg.baseUrl) === null || _a === void 0 ? void 0 : _a.endsWith('/')) {
+            console.warn(`Fetcher: baseUrl should not end with /`);
+            cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
+        }
+        const { debug } = cfg;
+        return Object.assign(Object.assign({ timeoutSeconds: 30, method: 'get', throwHttpErrors: true, retryPost: false, retry4xx: false, retry5xx: true, logger: console, logRequest: debug, logRequestBody: debug, logResponse: debug, logResponseBody: debug }, cfg), { retry: Object.assign(Object.assign({}, defRetryOptions), cfg.retry) });
+    }
+    normalizeOptions(opt) {
+        const { timeoutSeconds, throwHttpErrors, method, retryPost, retry4xx, retry5xx, retry } = this.cfg;
+        return Object.assign(Object.assign({ timeoutSeconds,
+            throwHttpErrors,
+            method,
+            retryPost,
+            retry4xx,
+            retry5xx }, opt), { retry: Object.assign(Object.assign({}, retry), _filterUndefinedValues(opt.retry || {})) });
+    }
+}
+export function getFetcher(cfg = {}) {
+    return Fetcher.create(cfg);
+}

package/dist-esm/http/http.model.js

@@ -0,0 +1 @@
+export {};

package/dist-esm/index.js

@@ -74,4 +74,6 @@ export * from './datetime/localDate';
 export * from './datetime/localTime';
 export * from './datetime/dateInterval';
 export * from './datetime/timeInterval';
+export * from './http/http.model';
+export * from './http/fetcher';
 export { is };

package/dist-esm/object/deepEquals.js

@@ -51,5 +51,6 @@ export function _deepEquals(a, b) {
         }
         return true;
     }
+    // eslint-disable-next-line no-self-compare
     return a !== a && b !== b;
 }

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

@@ -12,14 +12,12 @@ export function _pick(obj, props, mutate = false) {
             return r;
         }, obj);
     }
-    else {
-        // Start as empty object, pick/add needed properties
-        return props.reduce((r, prop) => {
-            if (prop in obj)
-                r[prop] = obj[prop];
-            return r;
-        }, {});
-    }
+    // Start as empty object, pick/add needed properties
+    return props.reduce((r, prop) => {
+        if (prop in obj)
+            r[prop] = obj[prop];
+        return r;
+    }, {});
 }
 /**
  * Returns clone of `obj` with `props` omitted.
@@ -239,7 +237,7 @@ export function _unset(obj, prop) {
     }
     const segs = prop.split('.');
     let last = segs.pop();
-    while (segs.length && segs[segs.length - 1].slice(-1) === '\\') {
+    while (segs.length && segs[segs.length - 1].endsWith('\\')) {
         last = segs.pop().slice(0, -1) + '.' + last;
     }
     while (segs.length && _isObject(obj)) {
@@ -305,7 +303,7 @@ export function _set(obj, path, value) {
             a[c]
         : // No: create the key. Is the next key a potential array-index?
             (a[c] =
-                // @ts-ignore
+                // @ts-expect-error
                 // eslint-disable-next-line
                 Math.abs(path[i + 1]) >> 0 === +path[i + 1]
                     ? [] // Yes: assign a new array object

package/dist-esm/string/safeJsonStringify.js

@@ -17,13 +17,11 @@ export function _safeJsonStringify(obj, replacer, spaces, cycleReplacer) {
 function serializer(replacer, cycleReplacer) {
     const stack = [];
     const keys = [];
-    if (cycleReplacer == null) {
-        cycleReplacer = function (key, value) {
-            if (stack[0] === value)
-                return '[Circular ~]';
-            return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
-        };
-    }
+    cycleReplacer !== null && cycleReplacer !== void 0 ? cycleReplacer : (cycleReplacer = function (key, value) {
+        if (stack[0] === value)
+            return '[Circular ~]';
+        return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
+    });
     return function (key, value) {
         if (stack.length > 0) {
             const thisPos = stack.indexOf(this);

package/dist-esm/string/stringifyAny.js

@@ -53,7 +53,8 @@ export function _stringifyAny(obj, opt = {}) {
             // This is to fix the rare error (happened with Got) where `err.message` was changed,
             // but err.stack had "old" err.message
             // This should "fix" that
-            s = [s, ...obj.stack.split('\n').slice(1)].join('\n');
+            const sLines = s.split('\n').length;
+            s = [s, ...obj.stack.split('\n').slice(sLines)].join('\n');
         }
         if (_isErrorObject(obj)) {
             if (_isHttpErrorObject(obj)) {

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

@@ -14,7 +14,7 @@
 export function _parseQueryString(search) {
     const qs = {};
     search
-        .slice(search[0] === '?' ? 1 : 0)
+        .slice(search.startsWith('?') ? 1 : 0)
         .split('&')
         .forEach(p => {
         const [k, v] = p.split('=');

package/package.json

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

package/src/array/array.util.ts

@@ -164,24 +164,24 @@ export function _findLast<T>(items: T[], predicate: Predicate<T>): T | undefined
 
 export function _takeWhile<T>(items: T[], predicate: Predicate<T>): T[] {
   let proceed = true
-  return items.filter((v, index) => (proceed = proceed && predicate(v, index)))
+  return items.filter((v, index) => (proceed &&= predicate(v, index)))
 }
 
 export function _takeRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
   let proceed = true
-  return [...items].reverse().filter((v, index) => (proceed = proceed && predicate(v, index)))
+  return [...items].reverse().filter((v, index) => (proceed &&= predicate(v, index)))
 }
 
 export function _dropWhile<T>(items: T[], predicate: Predicate<T>): T[] {
   let proceed = false
-  return items.filter((v, index) => (proceed = proceed || !predicate(v, index)))
+  return items.filter((v, index) => (proceed ||= !predicate(v, index)))
 }
 
 export function _dropRightWhile<T>(items: T[], predicate: Predicate<T>): T[] {
   let proceed = false
   return [...items]
     .reverse()
-    .filter((v, index) => (proceed = proceed || !predicate(v, index)))
+    .filter((v, index) => (proceed ||= !predicate(v, index)))
     .reverse()
 }
 

package/src/datetime/dateInterval.ts

@@ -58,6 +58,7 @@ export class DateInterval {
    */
   includes(d: LocalDateConfig, incl: Inclusiveness = '[]'): boolean {
     d = LocalDate.of(d)
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
     return d.isAfter(this.start, incl[0] === '[') && d.isBefore(this.end, incl[1] === ']')
   }
 

package/src/datetime/localDate.ts

@@ -154,6 +154,7 @@ export class LocalDate {
     const $max = LocalDate.of(max).startOf(stepUnit)
 
     let current = $min.startOf(stepUnit)
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
     if (current.isAfter($min, incl[0] === '[')) {
       // ok
     } else {
@@ -228,6 +229,7 @@ export class LocalDate {
 
   isBetween(min: LocalDateConfig, max: LocalDateConfig, incl: Inclusiveness = '[)'): boolean {
     let r = this.cmp(min)
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
     if (r < 0 || (r === 0 && incl[0] === '(')) return false
     r = this.cmp(max)
     if (r > 0 || (r === 0 && incl[1] === ')')) return false