@nice-code/util 0.2.11 → 0.2.12

package/build/index.js

@@ -5,87 +5,143 @@ var EStorageAdapterType;
   EStorageAdapterType2["json"] = "json";
 })(EStorageAdapterType ||= {});
 
+// src/storage_adapter/typed_storage/createTypedStorage.ts
+function createTypedStorage({
+  storageAdapter
+}) {
+  const getJson = async (key) => {
+    return storageAdapter.getJson(key);
+  };
+  const getJsonOrDef = async (key, defVal) => {
+    return await storageAdapter.getJson(key) ?? defVal;
+  };
+  const setJson = async (key, val) => {
+    return storageAdapter.setJson(key, val);
+  };
+  const removeItem = async (key) => {
+    await storageAdapter.removeItem(key);
+  };
+  const updateJson = async (key, updater) => {
+    await storageAdapter.updateJson(key, updater);
+  };
+  const updateJsonWithDef = async (key, defaultVal, updater) => {
+    await storageAdapter.updateJsonOrDef(key, defaultVal, updater);
+  };
+  return {
+    getJson,
+    getJsonOrDef,
+    setJson,
+    removeItem,
+    updateJson,
+    updateJsonWithDef,
+    clearAll: async () => {
+      await storageAdapter.clearAll();
+    }
+  };
+}
+
 // src/storage_adapter/StorageAdapter.ts
 class StorageAdapter {
   implementation;
   keyPrefix;
-  constructor({ methods, keyPrefix }) {
+  adapterStorage;
+  constructor({ methods, keyPrefix, trackKeysForClearing: trackKeys }) {
     this.implementation = methods;
     this.keyPrefix = keyPrefix ?? "";
+    const _trackKeys = trackKeys ?? true;
+    this.adapterStorage = _trackKeys ? createTypedStorage({
+      storageAdapter: new StorageAdapter({ methods, keyPrefix, trackKeysForClearing: false })
+    }) : undefined;
+  }
+  getPrefixedKey(rawKey) {
+    return `${this.keyPrefix}${rawKey}`;
   }
-  getPrefixedKey(key) {
-    return `${this.keyPrefix}${key}`;
+  async trackUsedKey(rawKey) {
+    if (!this.adapterStorage)
+      return;
+    await this.adapterStorage.updateJsonWithDef("__usedKeys__", [], (currentKeys) => {
+      if (!currentKeys.includes(rawKey)) {
+        return [...currentKeys, rawKey];
+      }
+      return currentKeys;
+    });
   }
-  async removeItem(key) {
-    await this.implementation.removeItem(this.getPrefixedKey(key));
+  async untrackUsedKey(rawKey) {
+    if (!this.adapterStorage)
+      return;
+    await this.adapterStorage.updateJsonWithDef("__usedKeys__", [], (currentKeys) => {
+      return currentKeys.filter((k) => k !== rawKey);
+    });
   }
-  async setJson(key, value) {
+  async clearAll() {
+    if (!this.adapterStorage)
+      return;
+    const allKeys = await this.adapterStorage.getJsonOrDef("__usedKeys__", []) ?? [];
+    await Promise.all(allKeys.map(async (key) => {
+      await this.removeItem(key);
+    }));
+    await this.adapterStorage.setJson("__usedKeys__", []);
+  }
+  async removeItem(rawKey) {
+    await this.implementation.removeItem(this.getPrefixedKey(rawKey));
+    await this.untrackUsedKey(rawKey);
+  }
+  async setJson(rawKey, value) {
+    const key = this.getPrefixedKey(rawKey);
     if (this.implementation.type === "string" /* string */) {
-      await this.implementation.setItem(this.getPrefixedKey(key), JSON.stringify(value));
+      await this.implementation.setItem(key, JSON.stringify(value));
     } else {
-      await this.implementation.setItem(this.getPrefixedKey(key), value);
+      await this.implementation.setItem(key, value);
     }
+    await this.trackUsedKey(rawKey);
   }
-  async getJson(key) {
+  async getJson(rawKey) {
+    const key = this.getPrefixedKey(rawKey);
     if (this.implementation.type === "string" /* string */) {
-      const val = await this.implementation.getItem(this.getPrefixedKey(key));
+      const val = await this.implementation.getItem(key);
       if (val == null || val === "undefined" || val === "null") {
         return;
       }
       return JSON.parse(val);
     } else {
-      const val = await this.implementation.getItem(this.getPrefixedKey(key));
+      const val = await this.implementation.getItem(key);
       if (val == null || val === "undefined" || val === "null") {
         return;
       }
       return val;
     }
   }
-  async getJsonOrDef(key, defVal) {
+  async getJsonOrDef(rawKey, defVal) {
     if (this.implementation.type === "string" /* string */) {
-      const val2 = await this.implementation.getItem(this.getPrefixedKey(key));
+      const val2 = await this.implementation.getItem(this.getPrefixedKey(rawKey));
       if (val2 == null || val2 === "undefined" || val2 === "null") {
         return defVal;
       }
       return JSON.parse(val2);
     }
-    const val = await this.implementation.getItem(this.getPrefixedKey(key));
+    const val = await this.implementation.getItem(this.getPrefixedKey(rawKey));
     if (val == null || val === "undefined" || val === "null") {
       return defVal;
     }
     return val;
   }
-  createJsonGetterSetter(key) {
+  async updateJson(rawKey, updater) {
+    const currentVal = await this.getJson(rawKey);
+    const newVal = updater(currentVal);
+    await this.setJson(rawKey, newVal);
+  }
+  async updateJsonOrDef(rawKey, defVal, updater) {
+    const currentVal = await this.getJsonOrDef(rawKey, defVal);
+    const newVal = updater(currentVal);
+    await this.setJson(rawKey, newVal);
+  }
+  createJsonGetterSetter(rawKey) {
     return {
-      get: () => this.getJson(key),
-      set: (value) => this.setJson(key, value)
+      get: () => this.getJson(rawKey),
+      set: (value) => this.setJson(rawKey, value)
     };
   }
 }
-// src/storage_adapter/typed_storage/createTypedStorage.ts
-function createTypedStorage({
-  storageAdapter
-}) {
-  const getJson = async (key) => {
-    return storageAdapter.getJson(key);
-  };
-  const getJsonOrDef = async (key, defVal) => {
-    return await storageAdapter.getJson(key) ?? defVal;
-  };
-  const setJson = async (key, val) => {
-    return storageAdapter.setJson(key, val);
-  };
-  const removeItem = async (key) => {
-    await storageAdapter.removeItem(key);
-  };
-  return {
-    getJson,
-    getJsonOrDef,
-    setJson,
-    removeItem
-  };
-}
-
 // src/storage_adapter/specific/browser/browser_storage.ts
 function createWebLocalStorageMethods(_localStorage) {
   return {

package/build/types/storage_adapter/StorageAdapter.d.ts

@@ -1,17 +1,24 @@
 import { type IStorageKeyGetterAndSetter, type TStorageAdapterMethods } from "./storage_adapter.types";
 interface IStorageAdapterConstructor {
     methods: TStorageAdapterMethods;
+    trackKeysForClearing?: boolean;
     keyPrefix?: string;
 }
 export declare class StorageAdapter {
     private implementation;
     readonly keyPrefix: string;
-    constructor({ methods, keyPrefix }: IStorageAdapterConstructor);
+    private readonly adapterStorage?;
+    constructor({ methods, keyPrefix, trackKeysForClearing: trackKeys }: IStorageAdapterConstructor);
     private getPrefixedKey;
-    removeItem(key: string): Promise<void>;
-    setJson(key: string, value: any): Promise<void>;
-    getJson<T>(key: string): Promise<T | undefined>;
-    getJsonOrDef<T>(key: string, defVal: T): Promise<T>;
-    createJsonGetterSetter<T>(key: string): IStorageKeyGetterAndSetter<T>;
+    private trackUsedKey;
+    private untrackUsedKey;
+    clearAll(): Promise<void>;
+    removeItem(rawKey: string): Promise<void>;
+    setJson(rawKey: string, value: any): Promise<void>;
+    getJson<T>(rawKey: string): Promise<T | undefined>;
+    getJsonOrDef<T>(rawKey: string, defVal: T): Promise<T>;
+    updateJson<T>(rawKey: string, updater: (currentVal: T | undefined) => T): Promise<void>;
+    updateJsonOrDef<T>(rawKey: string, defVal: T, updater: (currentVal: T) => T): Promise<void>;
+    createJsonGetterSetter<T>(rawKey: string): IStorageKeyGetterAndSetter<T>;
 }
 export {};

package/build/types/storage_adapter/typed_storage/createTypedStorage.d.ts

@@ -5,6 +5,9 @@ export interface ITypedStorage<T extends Record<string, any>> {
     getJsonOrDef<K extends StringKeys<T>>(key: K, defVal: T[K]): Promise<T[K]>;
     setJson<K extends StringKeys<T>>(key: K, val: T[K]): Promise<void>;
     removeItem<K extends StringKeys<T>>(key: K): Promise<void>;
+    updateJson<K extends StringKeys<T>>(key: K, updater: (currentVal: T[K] | undefined) => T[K]): Promise<void>;
+    updateJsonWithDef<K extends StringKeys<T>>(key: K, defaultVal: T[K], updater: (currentVal: T[K]) => T[K]): Promise<void>;
+    clearAll(): Promise<void>;
 }
 interface ITypedStorage_Create_Input {
     storageAdapter: StorageAdapter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/util",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "private": false,
   "type": "module",
   "exports": {