@naturalcycles/js-lib 14.276.0 → 15.0.0

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

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

package/dist/decorators/memo.decorator.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._Memo = void 0;
-exports._getMemo = _getMemo;
-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 } from '../types.js';
+import { _getTargetMethodSignature } from './decorator.util.js';
+import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
  * of the cache is the same. Key, by defaul, is calculated as `JSON.stringify(...args)`.
@@ -27,8 +23,8 @@ const memo_util_1 = require("./memo.util");
  * https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const _Memo = (opt = {}) => (target, key, descriptor) => {
-    (0, assert_1._assertTypeOf)(descriptor.value, 'function', 'Memoization can be applied only to methods');
+export const _Memo = (opt = {}) => (target, key, descriptor) => {
+    _assertTypeOf(descriptor.value, 'function', 'Memoization can be applied only to methods');
     const originalFn = descriptor.value;
     // Map<ctx => MemoCache<cacheKey, result>>
     //
@@ -38,9 +34,9 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     // UPD: tests show that normal Map also doesn't leak (to be tested further)
     // Normal Map is needed to allow .clear()
     const instanceCache = new Map();
-    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+    const { logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const keyStr = String(key);
-    const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
+    const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
         const cacheKey = cacheKeyFn(args);
@@ -63,7 +59,7 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
         }
         return value;
     };
-    (0, types_1._objectAssign)(descriptor.value, {
+    _objectAssign(descriptor.value, {
         clear: () => {
             logger.log(`${methodSignature} @_Memo.clear()`);
             instanceCache.forEach(memoCache => memoCache.clear());
@@ -74,12 +70,11 @@ const _Memo = (opt = {}) => (target, key, descriptor) => {
     });
     return descriptor;
 };
-exports._Memo = _Memo;
 /**
  Call it on a method that is decorated with `@_Memo` to get access to additional functions,
  e.g `clear` to clear the cache, or get its underlying data.
  */
-function _getMemo(method) {
-    (0, assert_1._assert)(typeof method?.getInstanceCache === 'function', 'method is not a Memo instance');
+export function _getMemo(method) {
+    _assert(typeof method?.getInstanceCache === 'function', 'method is not a Memo instance');
     return method;
 }

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

@@ -1,5 +1,5 @@
-import type { AnyObject, UnixTimestamp } from '../types';
-import { MISS } from '../types';
+import type { AnyObject, UnixTimestamp } from '../types.js';
+import { MISS } from '../types.js';
 export type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
 export interface MemoCacheOptions {

package/dist/decorators/memo.util.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapAsyncMemoCache = exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
-const is_util_1 = require("../is.util");
-const pDelay_1 = require("../promise/pDelay");
-const types_1 = require("../types");
-const jsonMemoSerializer = args => {
+import { _isPrimitive } from '../is.util.js';
+import { pDelay } from '../promise/pDelay.js';
+import { MISS } from '../types.js';
+export const jsonMemoSerializer = args => {
     if (args.length === 0)
         return undefined;
-    if (args.length === 1 && (0, is_util_1._isPrimitive)(args[0]))
+    if (args.length === 1 && _isPrimitive(args[0]))
         return args[0];
     return JSON.stringify(args);
 };
-exports.jsonMemoSerializer = jsonMemoSerializer;
 // SingleValueMemoCache and ObjectMemoCache are example-only, not used in production code
 /*
 export class SingleValueMemoCache implements MemoCache {
@@ -57,7 +53,7 @@ export class ObjectMemoCache implements MemoCache {
   }
 }
  */
-class MapMemoCache {
+export class MapMemoCache {
     m = new Map();
     has(k) {
         return this.m.has(k);
@@ -72,31 +68,29 @@ class MapMemoCache {
         this.m.clear();
     }
 }
-exports.MapMemoCache = MapMemoCache;
 /**
  * Implementation of AsyncMemoCache backed by a synchronous Map.
  * Doesn't have a practical use except testing,
  * because the point of AsyncMemoCache is to have an **async** backed cache.
  */
-class MapAsyncMemoCache {
+export class MapAsyncMemoCache {
     delay;
     constructor(delay = 0) {
         this.delay = delay;
     }
     m = new Map();
     async get(k) {
-        await (0, pDelay_1.pDelay)(this.delay);
+        await pDelay(this.delay);
         if (!this.m.has(k))
-            return types_1.MISS;
+            return MISS;
         return this.m.get(k);
     }
     async set(k, v) {
-        await (0, pDelay_1.pDelay)(this.delay);
+        await pDelay(this.delay);
         this.m.set(k, v);
     }
     async clear() {
-        await (0, pDelay_1.pDelay)(this.delay);
+        await pDelay(this.delay);
         this.m.clear();
     }
 }
-exports.MapAsyncMemoCache = MapAsyncMemoCache;

package/dist/decorators/memoFn.d.ts

@@ -1,6 +1,6 @@
-import type { AnyFunction } from '../types';
-import type { MemoOptions } from './memo.decorator';
-import type { MemoCache } from './memo.util';
+import type { AnyFunction } from '../types.js';
+import type { MemoOptions } from './memo.decorator.js';
+import type { MemoCache } from './memo.util.js';
 export interface MemoizedFunction {
     cache: MemoCache;
 }

package/dist/decorators/memoFn.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._memoFn = _memoFn;
-const memo_util_1 = require("./memo.util");
+import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
 /**
  * Only supports Sync functions.
  * To support Async functions - use _memoFnAsync.
@@ -9,8 +6,8 @@ const memo_util_1 = require("./memo.util");
  *
  * @experimental
  */
-function _memoFn(fn, opt = {}) {
-    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+export function _memoFn(fn, opt = {}) {
+    const { logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const memoizedFn = function (...args) {
         const ctx = this;

package/dist/decorators/memoFnAsync.d.ts

@@ -1,6 +1,6 @@
-import type { AnyAsyncFunction } from '../types';
-import type { AsyncMemoOptions } from './asyncMemo.decorator';
-import type { AsyncMemoCache } from './memo.util';
+import type { AnyAsyncFunction } from '../types.js';
+import type { AsyncMemoOptions } from './asyncMemo.decorator.js';
+import type { AsyncMemoCache } from './memo.util.js';
 export interface MemoizedAsyncFunction {
     cache: AsyncMemoCache;
 }

package/dist/decorators/memoFnAsync.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._memoFnAsync = _memoFnAsync;
-const types_1 = require("../types");
-const memo_util_1 = require("./memo.util");
+import { MISS } from '../types.js';
+import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
 /**
  * @experimental
  */
-function _memoFnAsync(fn, opt) {
-    const { logger = console, cacheFactory = () => new memo_util_1.MapMemoCache(), cacheKeyFn = memo_util_1.jsonMemoSerializer, } = opt;
+export function _memoFnAsync(fn, opt) {
+    const { logger = console, cacheFactory = () => new MapMemoCache(), cacheKeyFn = jsonMemoSerializer, } = opt;
     const cache = cacheFactory();
     const memoizedFn = async function (...args) {
         const ctx = this;
@@ -19,7 +16,7 @@ function _memoFnAsync(fn, opt) {
         catch (err) {
             logger.error(err);
         }
-        if (value !== types_1.MISS) {
+        if (value !== MISS) {
             return value;
         }
         value = await fn.apply(ctx, args);

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

@@ -1,4 +1,4 @@
-import type { CommonLogger } from '../log/commonLogger';
+import type { CommonLogger } from '../log/commonLogger.js';
 export interface MemoOpts {
     logger?: CommonLogger;
 }

package/dist/decorators/memoSimple.decorator.js

@@ -1,13 +1,10 @@
-"use strict";
 // Based on:
 // https://github.com/mgechev/memo-decorator/blob/master/index.ts
 // http://decodize.com/blog/2012/08/27/javascript-memoization-caching-results-for-better-performance/
 // http://inlehmansterms.net/2015/03/01/javascript-memoization/
 // https://community.risingstack.com/the-worlds-fastest-javascript-memoization-library/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoSimple = void 0;
-const decorator_util_1 = require("./decorator.util");
-const memo_util_1 = require("./memo.util");
+import { _getTargetMethodSignature } from './decorator.util.js';
+import { jsonMemoSerializer, MapMemoCache } from './memo.util.js';
 // memoSimple decorator is NOT exported. Only used in benchmarks currently
 /**
  * Memoizes the method of the class, so it caches the output and returns the cached version if the "key"
@@ -17,7 +14,7 @@ const memo_util_1 = require("./memo.util");
  *
  * Supports dropping it's cache by calling .dropCache() method of decorated function (useful in unit testing).
  */
-const memoSimple = (opt = {}) => (target, key, descriptor) => {
+export const memoSimple = (opt = {}) => (target, key, descriptor) => {
     if (typeof descriptor.value !== 'function') {
         throw new TypeError('Memoization can be applied only to methods');
     }
@@ -36,13 +33,13 @@ const memoSimple = (opt = {}) => (target, key, descriptor) => {
     // cache = new ObjectMemoCache()
   }
    */
-    const cache = new memo_util_1.MapMemoCache();
+    const cache = new MapMemoCache();
     const { logger = console } = opt;
     const keyStr = String(key);
-    const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
+    const methodSignature = _getTargetMethodSignature(target, keyStr);
     descriptor.value = function (...args) {
         const ctx = this;
-        const cacheKey = (0, memo_util_1.jsonMemoSerializer)(args);
+        const cacheKey = jsonMemoSerializer(args);
         if (cache.has(cacheKey)) {
             return cache.get(cacheKey);
         }
@@ -56,4 +53,3 @@ const memoSimple = (opt = {}) => (target, key, descriptor) => {
     };
     return descriptor;
 };
-exports.memoSimple = memoSimple;

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

@@ -1,2 +1,2 @@
-import type { PRetryOptions } from '..';
+import type { PRetryOptions } from '../index.js';
 export declare function _Retry(opt?: PRetryOptions): MethodDecorator;

package/dist/decorators/retry.decorator.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._Retry = _Retry;
-const __1 = require("..");
+import { pRetryFn } from '../index.js';
 // eslint-disable-next-line @typescript-eslint/naming-convention
-function _Retry(opt = {}) {
+export function _Retry(opt = {}) {
     return (_target, _key, descriptor) => {
         const originalFn = descriptor.value;
-        descriptor.value = (0, __1.pRetryFn)(originalFn, opt);
+        descriptor.value = pRetryFn(originalFn, opt);
         return descriptor;
     };
 }

package/dist/decorators/swarmSafe.decorator.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._SwarmSafe = void 0;
-const decorator_util_1 = require("./decorator.util");
+import { _getTargetMethodSignature } from './decorator.util.js';
 /**
  * Prevents "swarm" of async calls to the same method.
  * Allows max 1 in-flight promise to exist.
@@ -11,13 +8,13 @@ const decorator_util_1 = require("./decorator.util");
  * So, the same Promise is returned, regardless of the arguments.
  */
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const _SwarmSafe = () => (target, key, descriptor) => {
+export const _SwarmSafe = () => (target, key, descriptor) => {
     if (typeof descriptor.value !== 'function') {
         throw new TypeError('@_SwarmSafe can be applied only to methods');
     }
     const originalFn = descriptor.value;
     const keyStr = String(key);
-    const methodSignature = (0, decorator_util_1._getTargetMethodSignature)(target, keyStr);
+    const methodSignature = _getTargetMethodSignature(target, keyStr);
     const instanceCache = new Map();
     console.log('SwarmSafe constructor called', { key, methodSignature });
     // eslint-disable-next-line @typescript-eslint/promise-function-async
@@ -39,4 +36,3 @@ const _SwarmSafe = () => (target, key, descriptor) => {
         return inFlightPromise;
     };
 };
-exports._SwarmSafe = _SwarmSafe;

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

@@ -1,2 +1,2 @@
-import type { PTimeoutOptions } from '../promise/pTimeout';
+import type { PTimeoutOptions } from '../promise/pTimeout.js';
 export declare function _Timeout(opt: PTimeoutOptions): MethodDecorator;

package/dist/decorators/timeout.decorator.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._Timeout = _Timeout;
-const assert_1 = require("../error/assert");
-const pTimeout_1 = require("../promise/pTimeout");
-const decorator_util_1 = require("./decorator.util");
+import { _assert } from '../error/assert.js';
+import { pTimeout } from '../promise/pTimeout.js';
+import { _getMethodSignature } from './decorator.util.js';
 // eslint-disable-next-line @typescript-eslint/naming-convention
-function _Timeout(opt) {
+export function _Timeout(opt) {
     return (target, key, descriptor) => {
-        (0, assert_1._assert)(typeof descriptor.value === 'function', '@_Timeout can be applied only to methods');
+        _assert(typeof descriptor.value === 'function', '@_Timeout can be applied only to methods');
         if (!opt.timeout)
             return descriptor;
         const originalFn = descriptor.value;
         const keyStr = String(key);
         descriptor.value = async function (...args) {
             const ctx = this;
-            opt.name ||= (0, decorator_util_1._getMethodSignature)(ctx, keyStr);
-            return await (0, pTimeout_1.pTimeout)(() => originalFn.apply(this, args), opt);
+            opt.name ||= _getMethodSignature(ctx, keyStr);
+            return await pTimeout(() => originalFn.apply(this, args), opt);
         };
         return descriptor;
     };

package/dist/define.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunction, AnyObject, Lazy } from './types';
+import type { AnyFunction, AnyObject, Lazy } from './types.js';
 /**
  * const value = lazyValue(() => expensiveComputation())
  *

package/dist/define.js

@@ -1,13 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._lazyValue = _lazyValue;
-exports._defineLazyProperty = _defineLazyProperty;
-exports._defineLazyProps = _defineLazyProps;
-exports._defineProperty = _defineProperty;
-exports._defineProps = _defineProps;
-exports._defineNonNullishProps = _defineNonNullishProps;
-const object_util_1 = require("./object/object.util");
-const types_1 = require("./types");
+import { _mapObject, _mapValues } from './object/object.util.js';
+import { SKIP } from './types.js';
 /**
  * const value = lazyValue(() => expensiveComputation())
  *
@@ -17,7 +9,7 @@ const types_1 = require("./types");
  *
  * Based on: https://github.com/sindresorhus/lazy-value
  */
-function _lazyValue(fn) {
+export function _lazyValue(fn) {
     let isCalled = false;
     let result;
     return (() => {
@@ -42,7 +34,7 @@ function _lazyValue(fn) {
  *
  * Based on: https://github.com/sindresorhus/define-lazy-prop
  */
-function _defineLazyProperty(obj, propertyName, fn) {
+export function _defineLazyProperty(obj, propertyName, fn) {
     const define = (value) => {
         Object.defineProperty(obj, propertyName, { value, enumerable: true, writable: true });
     };
@@ -63,7 +55,7 @@ function _defineLazyProperty(obj, propertyName, fn) {
 /**
  * Like _defineLazyProperty, but allows to define multiple props at once.
  */
-function _defineLazyProps(obj, props) {
+export function _defineLazyProps(obj, props) {
     Object.entries(props).forEach(([k, fn]) => _defineLazyProperty(obj, k, fn));
     return obj;
 }
@@ -83,7 +75,7 @@ function _defineLazyProps(obj, props) {
  * value: existing obj[prop] value
  *
  */
-function _defineProperty(obj, prop, pd) {
+export function _defineProperty(obj, prop, pd) {
     return Object.defineProperty(obj, prop, {
         writable: true,
         configurable: true,
@@ -96,8 +88,8 @@ function _defineProperty(obj, prop, pd) {
  * Object.defineProperties with better defaults.
  * See _defineProperty for exact defaults definition.
  */
-function _defineProps(obj, props) {
-    return Object.defineProperties(obj, (0, object_util_1._mapValues)(props, (_k, pd) => ({
+export function _defineProps(obj, props) {
+    return Object.defineProperties(obj, _mapValues(props, (_k, pd) => ({
         writable: true,
         configurable: true,
         enumerable: true,
@@ -108,10 +100,10 @@ function _defineProps(obj, props) {
 /**
  * Like _defineProps, but skips props with nullish values.
  */
-function _defineNonNullishProps(obj, props) {
-    return _defineProps(obj, (0, object_util_1._mapObject)(props, (k, pd) => {
+export function _defineNonNullishProps(obj, props) {
+    return _defineProps(obj, _mapObject(props, (k, pd) => {
         if (pd.value === null || pd.value === undefined)
-            return types_1.SKIP;
+            return SKIP;
         return [k, pd];
     }));
 }

package/dist/deviceIdService.js

@@ -1,10 +1,7 @@
-"use strict";
 /// <reference lib="dom" preserve="true" />
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceIdService = void 0;
-const env_1 = require("./env");
-const nanoid_1 = require("./nanoid");
-const hash_util_1 = require("./string/hash.util");
+import { isServerSide } from './env.js';
+import { nanoidBrowser } from './nanoid.js';
+import { hashCode } from './string/hash.util.js';
 // This is in sync with the default length in Nanoid.
 const deviceIdLength = 21;
 /**
@@ -24,7 +21,7 @@ const deviceIdLength = 21;
  *
  * @experimental
  */
-class DeviceIdService {
+export class DeviceIdService {
     constructor(cfg = {}) {
         this.cfg = {
             localStorageKey: 'deviceId',
@@ -61,7 +58,7 @@ class DeviceIdService {
         }
         const mod = Math.trunc(rate * 1000);
         // console.log('hash: ', hashCode(this.deviceId)) // todo
-        return (0, hash_util_1.hashCode)(this.deviceId) % 1000 < mod;
+        return hashCode(this.deviceId) % 1000 < mod;
     }
     /**
      * Deletes the persisted deviceId.
@@ -82,7 +79,7 @@ class DeviceIdService {
      */
     init() {
         this.deviceId = null;
-        if ((0, env_1.isServerSide)())
+        if (isServerSide())
             return;
         try {
             this.deviceId = globalThis.localStorage.getItem(this.cfg.localStorageKey);
@@ -99,7 +96,7 @@ class DeviceIdService {
         }
         if (!this.deviceId) {
             try {
-                this.deviceId = (0, nanoid_1.nanoidBrowser)(deviceIdLength);
+                this.deviceId = nanoidBrowser(deviceIdLength);
                 this.debug(`generated new deviceId: ${this.deviceId}`);
                 globalThis.localStorage.setItem(this.cfg.localStorageKey, this.deviceId);
             }
@@ -114,4 +111,3 @@ class DeviceIdService {
             console.log('[DeviceIdService]', ...args);
     }
 }
-exports.DeviceIdService = DeviceIdService;

package/dist/enum.util.d.ts

@@ -1,4 +1,4 @@
-import type { NumberEnum, StringEnum } from './types';
+import type { NumberEnum, StringEnum } from './types.js';
 /**
  * Returns all String keys of a number-enum.
  */