@naturalcycles/js-lib 14.144.1 → 14.146.0

package/dist/array/array.util.js

@@ -144,7 +144,7 @@ exports._groupBy = _groupBy;
 function _sortBy(items, mapper, mutate = false, descending = false) {
     const mod = descending ? -1 : 1;
     return (mutate ? items : [...items]).sort((_a, _b) => {
-        const [a, b] = [_a, _b].map(mapper); // eslint-disable-line unicorn/no-array-callback-reference
+        const [a, b] = [_a, _b].map(mapper);
         if (typeof a === 'number' && typeof b === 'number')
             return (a - b) * mod;
         return String(a).localeCompare(String(b)) * mod;
@@ -155,7 +155,7 @@ exports._sortBy = _sortBy;
  * Like items.find(), but it tries to find from the END of the array.
  */
 function _findLast(items, predicate) {
-    return [...items].reverse().find(predicate); // eslint-disable-line unicorn/no-array-callback-reference
+    return [...items].reverse().find(predicate);
 }
 exports._findLast = _findLast;
 function _takeWhile(items, predicate) {

package/dist/datetime/localDate.js

@@ -5,7 +5,6 @@ const assert_1 = require("../error/assert");
 const localTime_1 = require("./localTime");
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-/* eslint-disable no-dupe-class-members */
 /**
  * @experimental
  */

package/dist/datetime/localTime.js

@@ -20,7 +20,6 @@ const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
-/* eslint-disable no-dupe-class-members */
 /**
  * @experimental
  */

package/dist/decorators/createPromiseDecorator.js

@@ -13,7 +13,6 @@ const decorator_util_1 = require("./decorator.util");
  *
  * @experimental
  */
-// eslint-disable-next-line @typescript-eslint/naming-convention
 function _createPromiseDecorator(cfg, decoratorParams = {}) {
     const { decoratorName } = cfg;
     return function decoratorFunction(target, propertyKey, pd) {

package/dist/http/fetcher.d.ts

@@ -1,5 +1,5 @@
 /// <reference lib="dom" />
-import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherResponse } from './fetcher.model';
+import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherRequest, FetcherResponse } from './fetcher.model';
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -14,29 +14,37 @@ export declare class Fetcher {
     onBeforeRetry(hook: FetcherBeforeRetryHook): this;
     cfg: FetcherNormalizedCfg;
     static create(cfg?: FetcherCfg & FetcherOptions): Fetcher;
-    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>;
-    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>;
+    get: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    post: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    put: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    patch: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    delete: <T = unknown>(url: string, opt?: FetcherOptions<T>) => Promise<T>;
+    getText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    postText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    putText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    patchText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    deleteText: (url: string, opt?: FetcherOptions<string>) => Promise<string>;
+    getVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    postVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    putVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    patchVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    deleteVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    headVoid: (url: string, opt?: FetcherOptions<void>) => Promise<void>;
+    /**
+     * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
+     *
+     * More on streams and Node interop:
+     * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
+     */
+    getReadableStream(url: string, opt?: FetcherOptions<ReadableStream<Uint8Array>>): Promise<ReadableStream<Uint8Array>>;
+    fetch<T = unknown>(url: string, opt?: FetcherOptions<T>): Promise<T>;
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      */
-    doFetch<T = unknown>(url: string, rawOpt?: FetcherOptions): Promise<FetcherResponse<T>>;
+    doFetch<T = unknown>(url: string, opt?: FetcherOptions<T>): Promise<FetcherResponse<T>>;
+    doFetchRequest<T = unknown>(req: FetcherRequest<T>): Promise<FetcherResponse<T>>;
     private onOkResponse;
     /**
      * This method exists to be able to easily mock it.

package/dist/http/fetcher.js

@@ -77,6 +77,19 @@ class Fetcher {
     static create(cfg = {}) {
         return new Fetcher(cfg);
     }
+    // mode=readableStream
+    /**
+     * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
+     *
+     * More on streams and Node interop:
+     * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
+     */
+    async getReadableStream(url, opt) {
+        return await this.fetch(url, {
+            mode: 'readableStream',
+            ...opt,
+        });
+    }
     async fetch(url, opt) {
         const res = await this.doFetch(url, opt);
         if (res.err) {
@@ -91,9 +104,12 @@ class Fetcher {
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      */
-    async doFetch(url, rawOpt = {}) {
+    async doFetch(url, opt = {}) {
+        const req = this.normalizeOptions(url, opt);
+        return await this.doFetchRequest(req);
+    }
+    async doFetchRequest(req) {
         const { logger } = this.cfg;
-        const req = this.normalizeOptions(url, rawOpt);
         const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
@@ -104,7 +120,7 @@ class Fetcher {
                 abortController.abort(`timeout of ${timeoutSeconds} sec`);
             }, timeoutSeconds * 1000);
         }
-        for await (const hook of this.cfg.hooks.beforeRequest || []) {
+        for (const hook of this.cfg.hooks.beforeRequest || []) {
             await hook(req);
         }
         const isFullUrl = req.url.includes('://');
@@ -121,7 +137,7 @@ class Fetcher {
             signature,
         };
         while (!res.retryStatus.retryStopped) {
-            const started = Date.now();
+            req.started = Date.now();
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -144,19 +160,25 @@ class Fetcher {
             }
             res.statusFamily = this.getStatusFamily(res);
             if (res.fetchResponse?.ok) {
-                await this.onOkResponse(res, started, timeout);
+                await this.onOkResponse(res, timeout);
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, started, timeout);
+                await this.onNotOkResponse(res, timeout);
             }
         }
-        for await (const hook of this.cfg.hooks.afterResponse || []) {
+        for (const hook of this.cfg.hooks.afterResponse || []) {
             await hook(res);
         }
+        if (req.paginate && res.ok) {
+            const proceed = await req.paginate(req, res);
+            if (proceed) {
+                return await this.doFetchRequest(req);
+            }
+        }
         return res;
     }
-    async onOkResponse(res, started, timeout) {
+    async onOkResponse(res, timeout) {
         const { req } = res;
         const { mode } = res.req;
         if (mode === 'json') {
@@ -179,7 +201,7 @@ class Fetcher {
                         // } satisfies HttpRequestErrorData)
                         res.err = (0, error_util_1._anyToError)(err);
                         res.ok = false;
-                        return await this.onNotOkResponse(res, started, timeout);
+                        return await this.onNotOkResponse(res, timeout);
                     }
                 }
                 else {
@@ -202,6 +224,14 @@ class Fetcher {
         else if (mode === 'blob') {
             res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
         }
+        else if (mode === 'readableStream') {
+            res.body = res.fetchResponse.body;
+            if (res.body === null) {
+                res.err = new Error(`fetchResponse.body is null`);
+                res.ok = false;
+                return await this.onNotOkResponse(res, timeout);
+            }
+        }
         clearTimeout(timeout);
         res.retryStatus.retryStopped = true;
         // res.err can happen on JSON.parse error
@@ -213,7 +243,7 @@ class Fetcher {
                 res.fetchResponse.status,
                 res.signature,
                 retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                (0, time_util_1._since)(started),
+                (0, time_util_1._since)(res.req.started),
             ]
                 .filter(Boolean)
                 .join(' '));
@@ -228,7 +258,7 @@ class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, started, timeout) {
+    async onNotOkResponse(res, timeout) {
         clearTimeout(timeout);
         let cause;
         if (res.err) {
@@ -254,7 +284,7 @@ class Fetcher {
             requestBaseUrl: this.cfg.baseUrl || null,
             requestMethod: res.req.init.method,
             requestSignature: res.signature,
-            requestDuration: Date.now() - started,
+            requestDuration: Date.now() - res.req.started,
         }), cause);
         await this.processRetry(res);
     }
@@ -263,7 +293,7 @@ class Fetcher {
         if (!this.shouldRetry(res)) {
             retryStatus.retryStopped = true;
         }
-        for await (const hook of this.cfg.hooks.beforeRetry || []) {
+        for (const hook of this.cfg.hooks.beforeRetry || []) {
             await hook(res);
         }
         const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
@@ -272,6 +302,22 @@ class Fetcher {
         }
         if (retryStatus.retryStopped)
             return;
+        // Here we know that more retries will be attempted
+        // We don't log "last error", because it will be thrown and logged by consumer,
+        // but we should log all previous errors, otherwise they are lost.
+        // Here is the right place where we know it's not the "last error"
+        if (res.err) {
+            const { retryAttempt } = retryStatus;
+            this.cfg.logger.error([
+                ' <<',
+                res.fetchResponse?.status || 0,
+                res.signature,
+                `try#${retryAttempt + 1}/${count + 1}`,
+                (0, time_util_1._since)(res.req.started),
+            ]
+                .filter(Boolean)
+                .join(' '), res.err.cause || res.err);
+        }
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
         const noise = Math.random() * 500;
@@ -372,6 +418,7 @@ class Fetcher {
     normalizeOptions(url, opt) {
         const { timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode, jsonReviver, } = this.cfg;
         const req = {
+            started: Date.now(),
             mode,
             url,
             timeoutSeconds,

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

@@ -1,14 +1,14 @@
 import type { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
-import type { Reviver } from '../types';
+import type { Reviver, UnixTimestampMillisNumber } from '../types';
 import type { HttpMethod, HttpStatusFamily } from './http.model';
-export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
+export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<FetcherRequest, 'started'> {
     logger: CommonLogger;
     searchParams: Record<string, any>;
 }
-export type FetcherBeforeRequestHook = (req: FetcherRequest) => Promisable<void>;
-export type FetcherAfterResponseHook = (res: FetcherResponse) => Promisable<void>;
-export type FetcherBeforeRetryHook = (res: FetcherResponse) => Promisable<void>;
+export type FetcherBeforeRequestHook = <BODY = unknown>(req: FetcherRequest<BODY>) => Promisable<void>;
+export type FetcherAfterResponseHook = <BODY = unknown>(res: FetcherResponse<BODY>) => Promisable<void>;
+export type FetcherBeforeRetryHook = <BODY = unknown>(res: FetcherResponse<BODY>) => Promisable<void>;
 export interface FetcherCfg {
     /**
      * Should **not** contain trailing slash.
@@ -77,7 +77,7 @@ export interface FetcherRetryOptions {
     timeoutMax: number;
     timeoutMultiplier: number;
 }
-export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl'> {
+export interface FetcherRequest<BODY = unknown> extends Omit<FetcherOptions<BODY>, 'method' | 'headers' | 'baseUrl'> {
     url: string;
     init: RequestInitNormalized;
     mode: FetcherMode;
@@ -87,8 +87,9 @@ export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers
     retryPost: boolean;
     retry4xx: boolean;
     retry5xx: boolean;
+    started: UnixTimestampMillisNumber;
 }
-export interface FetcherOptions {
+export interface FetcherOptions<BODY = unknown> {
     method?: HttpMethod;
     baseUrl?: string;
     throwHttpErrors?: boolean;
@@ -134,6 +135,18 @@ export interface FetcherOptions {
      */
     retry5xx?: boolean;
     jsonReviver?: Reviver;
+    /**
+     * Allows to walk over multiple pages of results.
+     * Paginate take a function.
+     * Function has access to FetcherRequest and FetcherResponse
+     * and has to make a decision to continue pagination or not.
+     * Return true to continue, false otherwise.
+     * If continue - it is expected to modify/mutate the FetcherRequest, as it will be used
+     * to request the next page.
+     *
+     * @experimental
+     */
+    paginate?: (req: FetcherRequest<BODY>, res: FetcherSuccessResponse<BODY>) => Promisable<boolean>;
 }
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
     method: HttpMethod;
@@ -160,4 +173,4 @@ export interface FetcherErrorResponse<BODY = unknown> {
     signature: string;
 }
 export type FetcherResponse<BODY = unknown> = FetcherSuccessResponse<BODY> | FetcherErrorResponse<BODY>;
-export type FetcherMode = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob';
+export type FetcherMode = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob' | 'readableStream';

package/dist/object/object.util.js

@@ -114,7 +114,6 @@ exports._mapValues = _mapValues;
  * Does not support `mutate` flag.
  */
 function _mapKeys(obj, mapper) {
-    // eslint-disable-next-line unicorn/prefer-object-from-entries
     return Object.entries(obj).reduce((map, [k, v]) => {
         map[mapper(k, v, obj)] = v;
         return map;

package/dist/object/sortObjectDeep.js

@@ -8,7 +8,6 @@ const __1 = require("..");
 function _sortObjectDeep(o) {
     // array
     if (Array.isArray(o)) {
-        // eslint-disable-next-line unicorn/no-array-callback-reference
         return o.map(_sortObjectDeep);
     }
     if ((0, __1._isObject)(o)) {

package/dist/promise/abortable.d.ts

@@ -11,8 +11,8 @@ import { AnyFunction } from '../types';
  * @experimental
  */
 export declare class Abortable {
-    onAbort?: AnyFunction<any> | undefined;
-    constructor(onAbort?: AnyFunction<any> | undefined);
+    onAbort?: AnyFunction | undefined;
+    constructor(onAbort?: AnyFunction | undefined);
     aborted: boolean;
     abort(): void;
     clear(): void;

package/dist/promise/pMap.js

@@ -51,7 +51,7 @@ async function pMap(iterable, mapper, opt = {}) {
     // Special cases that are able to preserve async stack traces
     if (concurrency === 1) {
         // Special case for concurrency == 1
-        for await (const item of items) {
+        for (const item of items) {
             try {
                 const r = await mapper(item, currentIndex++);
                 if (r === __1.END)

package/dist/string/leven.js

@@ -59,7 +59,6 @@ function _leven(first, second) {
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];
-            // eslint-disable-next-line no-multi-assign
             result = array[index] =
                 temporary > result
                     ? temporary2 > result

package/dist/string/string.util.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable unicorn/prefer-string-slice */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._nl2br = exports._replaceAll = exports._substringBetweenLast = exports._substringAfterLast = exports._substringAfter = exports._substringBeforeLast = exports._substringBefore = exports._truncateMiddle = exports._truncate = exports._removeWhitespace = exports._split = exports._lowerFirst = exports._upperFirst = exports._capitalize = void 0;
 /**

package/dist/vendor/is.d.ts

@@ -17,7 +17,7 @@ export declare namespace is {
     var bigint: (value: unknown) => value is bigint;
     var function_: (value: unknown) => value is Function;
     var null_: (value: unknown) => value is null;
-    var class_: (value: unknown) => value is Class<any>;
+    var class_: (value: unknown) => value is Class;
     var boolean: (value: unknown) => value is boolean;
     var symbol: (value: unknown) => value is symbol;
     var numericString: (value: unknown) => value is string;

package/dist/vendor/is.js

@@ -63,7 +63,6 @@ const primitiveTypeNames = [
 function isPrimitiveTypeName(name) {
     return primitiveTypeNames.includes(name);
 }
-// eslint-disable-next-line @typescript-eslint/ban-types
 function isOfType(type) {
     return (value) => typeof value === type;
 }
@@ -126,7 +125,6 @@ is.string = isOfType('string');
 const isNumberType = isOfType('number');
 is.number = (value) => isNumberType(value) && !is.nan(value);
 is.bigint = isOfType('bigint');
-// eslint-disable-next-line @typescript-eslint/ban-types
 is.function_ = isOfType('function');
 is.null_ = (value) => value === null;
 is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
@@ -155,7 +153,6 @@ is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
 is.generatorFunction = isObjectOfType('GeneratorFunction');
 is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
 is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
-// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
 is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
 is.regExp = isObjectOfType('RegExp');
 is.date = isObjectOfType('Date');
@@ -185,7 +182,7 @@ is.urlString = (value) => {
         return false;
     }
     try {
-        new URL(value); // eslint-disable-line no-new
+        new URL(value);
         return true;
     }
     catch {
@@ -344,7 +341,6 @@ exports.assert = {
     string: (value) => assertType(is.string(value), 'string', value),
     number: (value) => assertType(is.number(value), 'number', value),
     bigint: (value) => assertType(is.bigint(value), 'bigint', value),
-    // eslint-disable-next-line @typescript-eslint/ban-types
     function_: (value) => assertType(is.function_(value), 'Function', value),
     null_: (value) => assertType(is.null_(value), 'null', value),
     class_: (value) => assertType(is.class_(value), AssertionTypeDescription.class_, value),
@@ -369,9 +365,7 @@ exports.assert = {
     promise: (value) => assertType(is.promise(value), 'Promise', value),
     generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
     asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
-    // eslint-disable-next-line @typescript-eslint/ban-types
     asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
-    // eslint-disable-next-line @typescript-eslint/ban-types
     boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
     regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
     date: (value) => assertType(is.date(value), 'Date', value),

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

@@ -134,7 +134,7 @@ export function _groupBy(items, mapper) {
 export function _sortBy(items, mapper, mutate = false, descending = false) {
     const mod = descending ? -1 : 1;
     return (mutate ? items : [...items]).sort((_a, _b) => {
-        const [a, b] = [_a, _b].map(mapper); // eslint-disable-line unicorn/no-array-callback-reference
+        const [a, b] = [_a, _b].map(mapper);
         if (typeof a === 'number' && typeof b === 'number')
             return (a - b) * mod;
         return String(a).localeCompare(String(b)) * mod;
@@ -144,7 +144,7 @@ export function _sortBy(items, mapper, mutate = false, descending = false) {
  * Like items.find(), but it tries to find from the END of the array.
  */
 export function _findLast(items, predicate) {
-    return [...items].reverse().find(predicate); // eslint-disable-line unicorn/no-array-callback-reference
+    return [...items].reverse().find(predicate);
 }
 export function _takeWhile(items, predicate) {
     let proceed = true;

package/dist-esm/datetime/localDate.js

@@ -2,7 +2,6 @@ import { _assert } from '../error/assert';
 import { LocalTime } from './localTime';
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-/* eslint-disable no-dupe-class-members */
 /**
  * @experimental
  */

package/dist-esm/datetime/localTime.js

@@ -17,7 +17,6 @@ const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
-/* eslint-disable no-dupe-class-members */
 /**
  * @experimental
  */

package/dist-esm/decorators/createPromiseDecorator.js

@@ -10,7 +10,6 @@ import { _getTargetMethodSignature } from './decorator.util';
  *
  * @experimental
  */
-// eslint-disable-next-line @typescript-eslint/naming-convention
 export function _createPromiseDecorator(cfg, decoratorParams = {}) {
     const { decoratorName } = cfg;
     return function decoratorFunction(target, propertyKey, pd) {