@naturalcycles/js-lib 14.276.0 → 15.0.0

package/dist/datetime/localTime.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.localTime = exports.LocalTime = exports.VALID_DAYS_OF_WEEK = exports.ISODayOfWeek = void 0;
-const assert_1 = require("../error/assert");
-const time_util_1 = require("../time/time.util");
-const localDate_1 = require("./localDate");
-const wallTime_1 = require("./wallTime");
-var ISODayOfWeek;
+import { _assert } from '../error/assert.js';
+import { _ms } from '../time/time.util.js';
+import { localDate } from './localDate.js';
+import { WallTime } from './wallTime.js';
+export var ISODayOfWeek;
 (function (ISODayOfWeek) {
     ISODayOfWeek[ISODayOfWeek["MONDAY"] = 1] = "MONDAY";
     ISODayOfWeek[ISODayOfWeek["TUESDAY"] = 2] = "TUESDAY";
@@ -14,13 +11,13 @@ var ISODayOfWeek;
     ISODayOfWeek[ISODayOfWeek["FRIDAY"] = 5] = "FRIDAY";
     ISODayOfWeek[ISODayOfWeek["SATURDAY"] = 6] = "SATURDAY";
     ISODayOfWeek[ISODayOfWeek["SUNDAY"] = 7] = "SUNDAY";
-})(ISODayOfWeek || (exports.ISODayOfWeek = ISODayOfWeek = {}));
+})(ISODayOfWeek || (ISODayOfWeek = {}));
 const weekStartsOn = 1; // mon, as per ISO
 const MILLISECONDS_IN_WEEK = 604800000;
 const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
-exports.VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
+export const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
 /**
  * It supports 2 forms:
  * 1. 2023-03-03
@@ -36,7 +33,7 @@ const DATE_TIME_REGEX_LOOSE = /^(\d{4})-(\d{2})-(\d{2})([Tt\s](\d{2}):?(\d{2})?:
  */
 const DATE_TIME_REGEX_STRICT = /^(\d{4})-(\d{2})-(\d{2})[Tt\s](\d{2}):(\d{2}):(\d{2})/;
 const DATE_REGEX_STRICT = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-class LocalTime {
+export class LocalTime {
     $date;
     constructor($date) {
         this.$date = $date;
@@ -71,7 +68,7 @@ class LocalTime {
      */
     inTimezone(tz) {
         const d = new Date(this.$date.toLocaleString('en-US', { timeZone: tz }));
-        return new wallTime_1.WallTime({
+        return new WallTime({
             year: d.getFullYear(),
             month: d.getMonth() + 1,
             day: d.getDate(),
@@ -228,7 +225,7 @@ class LocalTime {
      * relation to `this`.
      */
     setDayOfWeek(dow) {
-        (0, assert_1._assert)(exports.VALID_DAYS_OF_WEEK.has(dow), `Invalid dayOfWeek: ${dow}`);
+        _assert(VALID_DAYS_OF_WEEK.has(dow), `Invalid dayOfWeek: ${dow}`);
         const delta = dow - this.dayOfWeek;
         return this.plus(delta, 'day');
     }
@@ -238,7 +235,7 @@ class LocalTime {
      * If this LocalTime is Monday, and desired DoW is also Monday - `this` is returned.
      */
     setNextDayOfWeek(dow) {
-        (0, assert_1._assert)(exports.VALID_DAYS_OF_WEEK.has(dow), `Invalid dayOfWeek: ${dow}`);
+        _assert(VALID_DAYS_OF_WEEK.has(dow), `Invalid dayOfWeek: ${dow}`);
         let delta = dow - this.dayOfWeek;
         if (delta < 0)
             delta += 7;
@@ -310,7 +307,7 @@ class LocalTime {
         }
         if (unit === 'year' || unit === 'month') {
             const d = addMonths(this.$date, unit === 'month' ? num : num * 12, mutate);
-            return mutate ? this : exports.localTime.fromInput(d);
+            return mutate ? this : localTime.fromInput(d);
         }
         return this.set(unit, this.get(unit) + num, mutate);
     }
@@ -321,7 +318,7 @@ class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = exports.localTime.fromInput(other).$date;
+        const date2 = localTime.fromInput(other).$date;
         const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
         if (!secDiff)
             return 0;
@@ -397,7 +394,7 @@ class LocalTime {
                     }
                     else {
                         // year or month
-                        const lastDay = localDate_1.localDate.getMonthLength(d.getFullYear(), d.getMonth() + 1);
+                        const lastDay = localDate.getMonthLength(d.getFullYear(), d.getMonth() + 1);
                         d.setDate(lastDay);
                     }
                 }
@@ -410,7 +407,7 @@ class LocalTime {
      * E.g 31 for January.
      */
     get daysInMonth() {
-        return localDate_1.localDate.getMonthLength(this.$date.getFullYear(), this.$date.getMonth() + 1);
+        return localDate.getMonthLength(this.$date.getFullYear(), this.$date.getMonth() + 1);
     }
     isSame(d) {
         return this.compare(d) === 0;
@@ -449,13 +446,13 @@ class LocalTime {
      * Third argument allows to override "now".
      */
     isOlderThan(n, unit, now) {
-        return this.isBefore(exports.localTime.fromInput(now ?? new Date()).plus(-n, unit));
+        return this.isBefore(localTime.fromInput(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is same or older (<=) than "now" by X units.
      */
     isSameOrOlderThan(n, unit, now) {
-        return this.isSameOrBefore(exports.localTime.fromInput(now ?? new Date()).plus(-n, unit));
+        return this.isSameOrBefore(localTime.fromInput(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is younger (>) than "now" by X units.
@@ -467,13 +464,13 @@ class LocalTime {
      * Third argument allows to override "now".
      */
     isYoungerThan(n, unit, now) {
-        return this.isAfter(exports.localTime.fromInput(now ?? new Date()).plus(-n, unit));
+        return this.isAfter(localTime.fromInput(now ?? new Date()).plus(-n, unit));
     }
     /**
      * Checks if this localTime is same or younger (>=) than "now" by X units.
      */
     isSameOrYoungerThan(n, unit, now) {
-        return this.isSameOrAfter(exports.localTime.fromInput(now ?? new Date()).plus(-n, unit));
+        return this.isSameOrAfter(localTime.fromInput(now ?? new Date()).plus(-n, unit));
     }
     getAgeInYears(now) {
         return this.getAgeIn('year', now);
@@ -494,7 +491,7 @@ class LocalTime {
         return this.getAgeIn('second', now);
     }
     getAgeIn(unit, now) {
-        return exports.localTime.fromInput(now ?? new Date()).diff(this, unit);
+        return localTime.fromInput(now ?? new Date()).diff(this, unit);
     }
     isAfterNow() {
         return this.$date.valueOf() > Date.now();
@@ -509,7 +506,7 @@ class LocalTime {
      */
     compare(d) {
         const t1 = this.$date.valueOf();
-        const t2 = exports.localTime.fromInput(d).$date.valueOf();
+        const t2 = localTime.fromInput(d).$date.valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
@@ -535,13 +532,13 @@ class LocalTime {
         };
     }
     toFromNowString(now = new Date()) {
-        const msDiff = exports.localTime.fromInput(now).$date.valueOf() - this.$date.valueOf();
+        const msDiff = localTime.fromInput(now).$date.valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
-            return `${(0, time_util_1._ms)(msDiff)} ago`;
+            return `${_ms(msDiff)} ago`;
         }
-        return `in ${(0, time_util_1._ms)(msDiff * -1)}`;
+        return `in ${_ms(msDiff * -1)}`;
     }
     toDate() {
         return this.$date;
@@ -559,7 +556,7 @@ class LocalTime {
         return Math.floor(this.$date.valueOf() / 1000);
     }
     toLocalDate() {
-        return localDate_1.localDate.fromDate(this.$date);
+        return localDate.fromDate(this.$date);
     }
     /**
      * Returns e.g: `1984-06-21 17:56:21`
@@ -609,7 +606,7 @@ class LocalTime {
         // return this.$date.toISOString().slice(11, seconds ? 19 : 16)
     }
     toWallTime() {
-        return new wallTime_1.WallTime(this.toDateTimeObject());
+        return new WallTime(this.toDateTimeObject());
     }
     /**
      * Returns e.g: `19840621_1705`
@@ -642,7 +639,6 @@ class LocalTime {
         return fmt(this);
     }
 }
-exports.LocalTime = LocalTime;
 class LocalTimeFactory {
     /**
      * Creates a LocalTime from the input, unless it's falsy - then returns undefined.
@@ -742,7 +738,7 @@ class LocalTimeFactory {
      */
     fromIsoDateTimeString(s) {
         const d = this.parseStrictlyOrUndefined(s);
-        (0, assert_1._assert)(d, `Cannot parse "${s}" into LocalTime`);
+        _assert(d, `Cannot parse "${s}" into LocalTime`);
         return new LocalTime(d);
     }
     /**
@@ -753,7 +749,7 @@ class LocalTimeFactory {
      */
     parse(s) {
         const d = this.parseLooselyOrUndefined(String(s));
-        (0, assert_1._assert)(d, `Cannot parse "${s}" into LocalTime`);
+        _assert(d, `Cannot parse "${s}" into LocalTime`);
         return new LocalTime(d);
     }
     parseStrictlyOrUndefined(s) {
@@ -806,16 +802,16 @@ class LocalTimeFactory {
      * Throws on invalid value.
      */
     validateDateTimeObject(o) {
-        (0, assert_1._assert)(this.isDateTimeObjectValid(o), `Cannot construct LocalTime from: ${o.year}-${o.month}-${o.day} ${o.hour}:${o.minute}:${o.second}`);
+        _assert(this.isDateTimeObjectValid(o), `Cannot construct LocalTime from: ${o.year}-${o.month}-${o.day} ${o.hour}:${o.minute}:${o.second}`);
     }
     isDateTimeObjectValid(o) {
-        return localDate_1.localDate.isDateObjectValid(o) && this.isTimeObjectValid(o);
+        return localDate.isDateObjectValid(o) && this.isTimeObjectValid(o);
     }
     isTimeObjectValid({ hour, minute, second }) {
         return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
     }
     fromDate(date) {
-        (0, assert_1._assert)(!Number.isNaN(date.getDate()), 'localTime.fromDate is called on Date object that is invalid');
+        _assert(!Number.isNaN(date.getDate()), 'localTime.fromDate is called on Date object that is invalid');
         return new LocalTime(date);
     }
     fromUnix(ts) {
@@ -885,7 +881,7 @@ class LocalTimeFactory {
     }
     min(items) {
         const min = this.minOrUndefined(items);
-        (0, assert_1._assert)(min, 'localTime.min called on empty array');
+        _assert(min, 'localTime.min called on empty array');
         return min;
     }
     maxOrUndefined(items) {
@@ -902,7 +898,7 @@ class LocalTimeFactory {
     }
     max(items) {
         const max = this.maxOrUndefined(items);
-        (0, assert_1._assert)(max, 'localTime.max called on empty array');
+        _assert(max, 'localTime.max called on empty array');
         return max;
     }
 }
@@ -979,7 +975,7 @@ function addMonths(d, num, mutate = false) {
         year--;
         month += 12;
     }
-    const monthLen = localDate_1.localDate.getMonthLength(year, month);
+    const monthLen = localDate.getMonthLength(year, month);
     if (day > monthLen)
         day = monthLen;
     d.setFullYear(year, month - 1, day);
@@ -995,7 +991,7 @@ function differenceInMonths(a, b) {
     return -(wholeMonthDiff + ((b.getTime() - anchor) / (anchor2 - anchor)) * sign);
 }
 const localTimeFactory = new LocalTimeFactory();
-exports.localTime = localTimeFactory.fromInput.bind(localTimeFactory);
+export const localTime = localTimeFactory.fromInput.bind(localTimeFactory);
 // The line below is the blackest of black magic I have ever written in 2024.
 // And probably 2023 as well.
-Object.setPrototypeOf(exports.localTime, localTimeFactory);
+Object.setPrototypeOf(localTime, localTimeFactory);

package/dist/datetime/timeInterval.d.ts

@@ -1,5 +1,5 @@
-import type { Inclusiveness, UnixTimestamp } from '../types';
-import type { LocalTime, LocalTimeInput } from './localTime';
+import type { Inclusiveness, UnixTimestamp } from '../types.js';
+import type { LocalTime, LocalTimeInput } from './localTime.js';
 export type TimeIntervalConfig = TimeInterval | TimeIntervalString;
 export type TimeIntervalString = string;
 /**

package/dist/datetime/timeInterval.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeInterval = void 0;
-const localTime_1 = require("./localTime");
+import { localTime } from './localTime.js';
 /**
  * Class that supports an "interval of time" between 2 timestamps - start and end.
  * Example: `1649267185/1649267187`.
  *
  * @experimental
  */
-class TimeInterval {
+export class TimeInterval {
     $start;
     $end;
     constructor($start, $end) {
@@ -16,7 +13,7 @@ class TimeInterval {
         this.$end = $end;
     }
     static of(start, end) {
-        return new TimeInterval(localTime_1.localTime.fromInput(start).unix, localTime_1.localTime.fromInput(end).unix);
+        return new TimeInterval(localTime.fromInput(start).unix, localTime.fromInput(end).unix);
     }
     get start() {
         return this.$start;
@@ -25,10 +22,10 @@ class TimeInterval {
         return this.$end;
     }
     get startTime() {
-        return (0, localTime_1.localTime)(this.$start);
+        return localTime(this.$start);
     }
     get endTime() {
-        return (0, localTime_1.localTime)(this.$end);
+        return localTime(this.$end);
     }
     /**
      * Parses string like `1649267185/1649267187` into a TimeInterval.
@@ -60,7 +57,7 @@ class TimeInterval {
         return this.cmp(d) >= 0;
     }
     includes(d, incl = '[)') {
-        d = localTime_1.localTime.fromInput(d).unix;
+        d = localTime.fromInput(d).unix;
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (d < this.$start || (d === this.$start && incl[0] === '('))
             return false;
@@ -91,4 +88,3 @@ class TimeInterval {
         return this.toString();
     }
 }
-exports.TimeInterval = TimeInterval;

package/dist/datetime/wallTime.d.ts

@@ -1,6 +1,6 @@
-import type { IsoDate, IsoDateTime } from '../types';
-import { LocalDate } from './localDate';
-import type { DateTimeObject, LocalTime } from './localTime';
+import type { IsoDate, IsoDateTime } from '../types.js';
+import { LocalDate } from './localDate.js';
+import type { DateTimeObject, LocalTime } from './localTime.js';
 /**
  * Representation of a "time on the wall clock",
  * which means "local time, regardless of timezone".

package/dist/datetime/wallTime.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WallTime = void 0;
-const localDate_1 = require("./localDate");
-const localTime_1 = require("./localTime");
+import { LocalDate } from './localDate.js';
+import { localTime } from './localTime.js';
 /**
  * Representation of a "time on the wall clock",
  * which means "local time, regardless of timezone".
@@ -12,7 +9,7 @@ const localTime_1 = require("./localTime");
  * No math or manipulation is possible here.
  * Can be pretty-printed as Date, Time or DateAndTime.
  */
-class WallTime {
+export class WallTime {
     year;
     month;
     day;
@@ -23,7 +20,7 @@ class WallTime {
         Object.assign(this, obj);
     }
     toLocalDate() {
-        return new localDate_1.LocalDate(this.year, this.month, this.day);
+        return new LocalDate(this.year, this.month, this.day);
     }
     /**
      * Example:
@@ -32,7 +29,7 @@ class WallTime {
      * holding that time in the local timezone.
      */
     toLocalTime() {
-        return localTime_1.localTime.fromDateTimeObject(this);
+        return localTime.fromDateTimeObject(this);
     }
     toJSON() {
         return this.toISODateTime();
@@ -77,4 +74,3 @@ class WallTime {
             .join(':');
     }
 }
-exports.WallTime = WallTime;

package/dist/decorators/asyncMemo.decorator.d.ts

@@ -1,6 +1,6 @@
-import type { CommonLogger } from '../log/commonLogger';
-import type { AnyAsyncFunction, AnyFunction, AnyObject, MaybeParameters } from '../types';
-import type { AsyncMemoCache, MethodDecorator } from './memo.util';
+import type { CommonLogger } from '../log/commonLogger.js';
+import type { AnyAsyncFunction, AnyFunction, AnyObject, MaybeParameters } from '../types.js';
+import type { AsyncMemoCache, MethodDecorator } from './memo.util.js';
 export interface AsyncMemoOptions<FN> {
     /**
      * Provide a custom implementation of AsyncMemoCache.

package/dist/decorators/asyncMemo.decorator.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._AsyncMemo = void 0;
-exports._getAsyncMemo = _getAsyncMemo;
-const assert_1 = require("../error/assert");
-const types_1 = require("../types");
-const decorator_util_1 = require("./decorator.util");
-const memo_util_1 = require("./memo.util");
+import { _assert, _assertTypeOf } from '../error/assert.js';
+import { _objectAssign, MISS } from '../types.js';
+import { _getTargetMethodSignature } from './decorator.util.js';
+import { jsonMemoSerializer } from './memo.util.js';
 /**
  * Like @_Memo, but allowing async MemoCache implementation.
  *
@@ -15,8 +11,8 @@ const memo_util_1 = require("./memo.util");
  * @experimental consider normal @_Memo for most of the cases, it's stable and predictable
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const _AsyncMemo = (opt) => (target, key, descriptor) => {
-    (0, assert_1._assertTypeOf)(descriptor.value, 'function', 'Memoization can be applied only to methods');
+export const _AsyncMemo = (opt) => (target, key, descriptor) => {
+    _assertTypeOf(descriptor.value, 'function', 'Memoization can be applied only to methods');
     const originalFn = descriptor.value;
     // Map from "instance" of the Class where @_AsyncMemo is applied to AsyncMemoCache instance.
     const instanceCache = new Map();
@@ -25,9 +21,9 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
     // It only holds values that are "in-flight", until Promise is resolved
     // After it's resolved - it's evicted from the cache and moved to the "proper" `instanceCache`
     const instancePromiseCache = new Map();
-    const { logger = console, cacheFactory, cacheKeyFn = memo_util_1.jsonMemoSerializer } = opt;
+    const { logger = console, cacheFactory, cacheKeyFn = jsonMemoSerializer } = opt;
     const keyStr = String(key);
-    const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
+    const methodSignature = _getTargetMethodSignature(target, keyStr);
     // eslint-disable-next-line @typescript-eslint/promise-function-async
     descriptor.value = function (...args) {
         const ctx = this;
@@ -51,7 +47,7 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
             return promise;
         }
         promise = cache.get(cacheKey).then(async (value) => {
-            if (value !== types_1.MISS) {
+            if (value !== MISS) {
                 // console.log('hit', promiseCache.size)
                 promiseCache.delete(cacheKey);
                 return value;
@@ -94,7 +90,7 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
             }
         }
     };
-    (0, types_1._objectAssign)(descriptor.value, {
+    _objectAssign(descriptor.value, {
         clear: async () => {
             logger.log(`${methodSignature} @_AsyncMemo.clear()`);
             await Promise.all([...instanceCache.values()].map(c => c.clear()));
@@ -105,12 +101,11 @@ const _AsyncMemo = (opt) => (target, key, descriptor) => {
     });
     return descriptor;
 };
-exports._AsyncMemo = _AsyncMemo;
 /**
  Call it on a method that is decorated with `@_AsyncMemo` to get access to additional functions,
  e.g `clear` to clear the cache, or get its underlying data.
  */
-function _getAsyncMemo(method) {
-    (0, assert_1._assert)(typeof method?.getInstanceCache === 'function', 'method is not an AsyncMemo instance');
+export function _getAsyncMemo(method) {
+    _assert(typeof method?.getInstanceCache === 'function', 'method is not an AsyncMemo instance');
     return method;
 }

package/dist/decorators/createPromiseDecorator.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._createPromiseDecorator = _createPromiseDecorator;
-const decorator_util_1 = require("./decorator.util");
+import { _getTargetMethodSignature } from './decorator.util.js';
 /**
  * @example
  * // decorators.ts
@@ -13,13 +10,13 @@ const decorator_util_1 = require("./decorator.util");
  *
  * @experimental
  */
-function _createPromiseDecorator(cfg, decoratorParams = {}) {
+export function _createPromiseDecorator(cfg, decoratorParams = {}) {
     const { decoratorName } = cfg;
     return function decoratorFunction(target, propertyKey, pd) {
         // console.log(`@Decorator.${cfg.decoratorName} called: ` + propertyKey, pd, target)
         const originalMethod = pd.value;
         const key = String(propertyKey);
-        const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, key);
+        const methodSignature = _getTargetMethodSignature(target, key);
         pd.value = async function (...args) {
             // console.log(`@${cfg.decoratorName} called inside function`)
             const started = Date.now();

package/dist/decorators/debounce.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunction } from '../types';
+import type { AnyFunction } from '../types.js';
 export interface Cancelable {
     cancel: () => void;
     flush: () => void;

package/dist/decorators/debounce.decorator.d.ts

@@ -1,3 +1,3 @@
-import type { DebounceOptions, ThrottleOptions } from './debounce';
+import type { DebounceOptions, ThrottleOptions } from './debounce.js';
 export declare function _Debounce(wait: number, opt?: DebounceOptions): MethodDecorator;
 export declare function _Throttle(wait: number, opt?: ThrottleOptions): MethodDecorator;

package/dist/decorators/debounce.decorator.js

@@ -1,21 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._Debounce = _Debounce;
-exports._Throttle = _Throttle;
-const debounce_1 = require("./debounce");
+import { _debounce, _throttle } from './debounce.js';
 // eslint-disable-next-line @typescript-eslint/naming-convention
-function _Debounce(wait, opt = {}) {
+export function _Debounce(wait, opt = {}) {
     return (_target, _key, descriptor) => {
         const originalFn = descriptor.value;
-        descriptor.value = (0, debounce_1._debounce)(originalFn, wait, opt);
+        descriptor.value = _debounce(originalFn, wait, opt);
         return descriptor;
     };
 }
 // eslint-disable-next-line @typescript-eslint/naming-convention
-function _Throttle(wait, opt = {}) {
+export function _Throttle(wait, opt = {}) {
     return (_target, _key, descriptor) => {
         const originalFn = descriptor.value;
-        descriptor.value = (0, debounce_1._throttle)(originalFn, wait, opt);
+        descriptor.value = _throttle(originalFn, wait, opt);
         return descriptor;
     };
 }

package/dist/decorators/debounce.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._debounce = _debounce;
-exports._throttle = _throttle;
-function _debounce(func, wait, opt = {}) {
+export function _debounce(func, wait, opt = {}) {
     let lastArgs;
     let lastThis;
     let result;
@@ -108,7 +104,7 @@ function _debounce(func, wait, opt = {}) {
     debounced.pending = pending;
     return debounced;
 }
-function _throttle(func, wait, opt = {}) {
+export function _throttle(func, wait, opt = {}) {
     return _debounce(func, wait, {
         leading: true,
         trailing: true,

package/dist/decorators/decorator.util.d.ts

@@ -1,4 +1,4 @@
-import type { AnyObject } from '../index';
+import type { AnyObject } from '../index.js';
 /**
  * @returns
  * e.g `NameOfYourClass.methodName`

package/dist/decorators/decorator.util.js

@@ -1,21 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._getMethodSignature = _getMethodSignature;
-exports._getTargetMethodSignature = _getTargetMethodSignature;
-exports._getArgsSignature = _getArgsSignature;
 /**
  * @returns
  * e.g `NameOfYourClass.methodName`
  * or `NameOfYourClass(instanceId).methodName`
  */
-function _getMethodSignature(ctx, keyStr) {
+export function _getMethodSignature(ctx, keyStr) {
     const { instanceId } = ctx;
     return `${ctx.constructor.name}${instanceId ? `#${instanceId}` : ''}.${keyStr}`;
 }
 /**
  * @returns `NameOfYourClass.methodName`
  */
-function _getTargetMethodSignature(target, keyStr) {
+export function _getTargetMethodSignature(target, keyStr) {
     return `${target.constructor.name}.${keyStr}`;
 }
 /**
@@ -24,7 +19,7 @@ function _getTargetMethodSignature(target, keyStr) {
  * returns:
  * a, b, c
  */
-function _getArgsSignature(args = [], logArgs = true) {
+export function _getArgsSignature(args = [], logArgs = true) {
     if (!logArgs)
         return '';
     return args

package/dist/decorators/logMethod.decorator.d.ts

@@ -1,4 +1,4 @@
-import type { CommonLogger } from '..';
+import type { CommonLogger } from '../index.js';
 /**
  * $r - result
  *

package/dist/decorators/logMethod.decorator.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._LogMethod = _LogMethod;
-const __1 = require("..");
-const time_util_1 = require("../time/time.util");
-const decorator_util_1 = require("./decorator.util");
+import { _assert, _stringify, SimpleMovingAverage } from '../index.js';
+import { _ms } from '../time/time.util.js';
+import { _getArgsSignature, _getMethodSignature } from './decorator.util.js';
 /**
  * Console-logs when method had started, when it finished, time taken and if error happened.
  * Supports both sync and async methods.
@@ -18,30 +15,30 @@ const decorator_util_1 = require("./decorator.util");
  * << asyncMethodThrow() took 10 ms ERROR: MyError
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-function _LogMethod(opt = {}) {
+export function _LogMethod(opt = {}) {
     return (target, key, descriptor) => {
-        (0, __1._assert)(typeof descriptor.value === 'function', '@_LogMethod can be applied only to methods');
+        _assert(typeof descriptor.value === 'function', '@_LogMethod can be applied only to methods');
         const originalFn = descriptor.value;
         const keyStr = String(key);
         const { avg, logArgs = true, logStart, logResult, logResultLength = true, logger = console, } = opt;
         let { logResultFn } = opt;
         if (!logResultFn) {
             if (logResult) {
-                logResultFn = r => ['result:', (0, __1._stringify)(r)];
+                logResultFn = r => ['result:', _stringify(r)];
             }
             else if (logResultLength) {
                 logResultFn = r => (Array.isArray(r) ? [`result: ${r.length} items`] : []);
             }
         }
-        const sma = avg ? new __1.SimpleMovingAverage(avg) : undefined;
+        const sma = avg ? new SimpleMovingAverage(avg) : undefined;
         let count = 0;
         descriptor.value = function (...args) {
             const started = Date.now();
             const ctx = this;
             // e.g `NameOfYourClass.methodName`
             // or `NameOfYourClass(instanceId).methodName`
-            const methodSignature = (0, decorator_util_1._getMethodSignature)(ctx, keyStr);
-            const argsStr = (0, decorator_util_1._getArgsSignature)(args, logArgs);
+            const methodSignature = _getMethodSignature(ctx, keyStr);
+            const argsStr = _getArgsSignature(args, logArgs);
             const callSignature = `${methodSignature}(${argsStr}) #${++count}`;
             if (logStart)
                 logger.log(`>> ${callSignature}`);
@@ -74,9 +71,9 @@ function _LogMethod(opt = {}) {
 // eslint-disable-next-line max-params
 function logFinished(logger, callSignature, started, sma, logResultFn, res, err) {
     const millis = Date.now() - started;
-    const t = ['<<', callSignature, 'took', (0, time_util_1._ms)(millis)];
+    const t = ['<<', callSignature, 'took', _ms(millis)];
     if (sma) {
-        t.push(`(avg ${(0, time_util_1._ms)(sma.pushGetAvg(millis))})`);
+        t.push(`(avg ${_ms(sma.pushGetAvg(millis))})`);
     }
     if (err !== undefined) {
         t.push('ERROR:', err);