@naturalcycles/js-lib 14.83.0 → 14.83.1

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

@@ -1,3 +1,4 @@
+import { Promisable } from '../typeFest';
 export declare type MemoSerializer = (args: any[]) => any;
 export declare const jsonMemoSerializer: MemoSerializer;
 export interface MemoCache<KEY = any, VALUE = any> {
@@ -16,24 +17,18 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
      * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
      * You CAN store `null` value instead, it will be treated as a HIT.
      */
-    get(k: KEY): Promise<VALUE | undefined>;
-    set(k: KEY, v: VALUE): Promise<void>;
+    get(k: KEY): Promisable<VALUE | undefined>;
+    set(k: KEY, v: VALUE): Promisable<void>;
     /**
      * Clear is only called when `.dropCache()` is called.
      * Otherwise the Cache is "persistent" (never cleared).
      */
-    clear(): Promise<void>;
+    clear(): Promisable<void>;
 }
-export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {
+export declare class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE> {
     private m;
     has(k: KEY): boolean;
     get(k: KEY): VALUE | undefined;
     set(k: KEY, v: VALUE): void;
     clear(): void;
 }
-export declare class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
-    private m;
-    get(k: KEY): Promise<VALUE | undefined>;
-    set(k: KEY, v: VALUE): Promise<void>;
-    clear(): Promise<void>;
-}

package/dist/decorators/memo.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapAsyncMemoCache = exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
+exports.MapMemoCache = exports.jsonMemoSerializer = void 0;
 const object_util_1 = require("../object/object.util");
 const jsonMemoSerializer = args => {
     if (args.length === 0)
@@ -73,18 +73,3 @@ class MapMemoCache {
     }
 }
 exports.MapMemoCache = MapMemoCache;
-class MapAsyncMemoCache {
-    constructor() {
-        this.m = new Map();
-    }
-    async get(k) {
-        return this.m.get(k);
-    }
-    async set(k, v) {
-        this.m.set(k, v);
-    }
-    async clear() {
-        this.m.clear();
-    }
-}
-exports.MapAsyncMemoCache = MapAsyncMemoCache;

package/dist-esm/decorators/memo.util.js

@@ -68,17 +68,3 @@ export class MapMemoCache {
         this.m.clear();
     }
 }
-export class MapAsyncMemoCache {
-    constructor() {
-        this.m = new Map();
-    }
-    async get(k) {
-        return this.m.get(k);
-    }
-    async set(k, v) {
-        this.m.set(k, v);
-    }
-    async clear() {
-        this.m.clear();
-    }
-}

package/package.json

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

package/src/decorators/memo.util.ts

@@ -1,4 +1,5 @@
 import { _isPrimitive } from '../object/object.util'
+import { Promisable } from '../typeFest'
 
 export type MemoSerializer = (args: any[]) => any
 
@@ -28,14 +29,14 @@ export interface AsyncMemoCache<KEY = any, VALUE = any> {
    * This also means that you CANNOT store `undefined` value in the Cache, as it'll be treated as a MISS.
    * You CAN store `null` value instead, it will be treated as a HIT.
    */
-  get(k: KEY): Promise<VALUE | undefined>
-  set(k: KEY, v: VALUE): Promise<void>
+  get(k: KEY): Promisable<VALUE | undefined>
+  set(k: KEY, v: VALUE): Promisable<void>
 
   /**
    * Clear is only called when `.dropCache()` is called.
    * Otherwise the Cache is "persistent" (never cleared).
    */
-  clear(): Promise<void>
+  clear(): Promisable<void>
 }
 
 // SingleValueMemoCache and ObjectMemoCache are example-only, not used in production code
@@ -84,7 +85,9 @@ export class ObjectMemoCache implements MemoCache {
 }
  */
 
-export class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALUE> {
+export class MapMemoCache<KEY = any, VALUE = any>
+  implements MemoCache<KEY, VALUE>, AsyncMemoCache<KEY, VALUE>
+{
   private m = new Map<KEY, VALUE>()
 
   has(k: KEY): boolean {
@@ -103,19 +106,3 @@ export class MapMemoCache<KEY = any, VALUE = any> implements MemoCache<KEY, VALU
     this.m.clear()
   }
 }
-
-export class MapAsyncMemoCache<KEY = any, VALUE = any> implements AsyncMemoCache<KEY, VALUE> {
-  private m = new Map<KEY, VALUE>()
-
-  async get(k: KEY): Promise<VALUE | undefined> {
-    return this.m.get(k)
-  }
-
-  async set(k: KEY, v: VALUE): Promise<void> {
-    this.m.set(k, v)
-  }
-
-  async clear(): Promise<void> {
-    this.m.clear()
-  }
-}