@nice-code/util 0.2.10 → 0.2.12

package/build/index.js

@@ -1,8 +1,260 @@
-// src/index.ts
-export * from "./storage_adapter/StorageAdapter";
-export * from "./storage_adapter/specific/browser/browser_storage";
-export * from "./storage_adapter/specific/durable_object/durable_object_storage";
-export * from "./storage_adapter/specific/memory/memory_storage";
-export * from "./storage_adapter/storage_adapter.types";
-export * from "./storage_adapter/typed_storage/createTypedStorage";
-export * from "./typescript/special_typescript_types";
+// src/storage_adapter/storage_adapter.types.ts
+var EStorageAdapterType;
+((EStorageAdapterType2) => {
+  EStorageAdapterType2["string"] = "string";
+  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;
+  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}`;
+  }
+  async trackUsedKey(rawKey) {
+    if (!this.adapterStorage)
+      return;
+    await this.adapterStorage.updateJsonWithDef("__usedKeys__", [], (currentKeys) => {
+      if (!currentKeys.includes(rawKey)) {
+        return [...currentKeys, rawKey];
+      }
+      return currentKeys;
+    });
+  }
+  async untrackUsedKey(rawKey) {
+    if (!this.adapterStorage)
+      return;
+    await this.adapterStorage.updateJsonWithDef("__usedKeys__", [], (currentKeys) => {
+      return currentKeys.filter((k) => k !== rawKey);
+    });
+  }
+  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(key, JSON.stringify(value));
+    } else {
+      await this.implementation.setItem(key, value);
+    }
+    await this.trackUsedKey(rawKey);
+  }
+  async getJson(rawKey) {
+    const key = this.getPrefixedKey(rawKey);
+    if (this.implementation.type === "string" /* string */) {
+      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(key);
+      if (val == null || val === "undefined" || val === "null") {
+        return;
+      }
+      return val;
+    }
+  }
+  async getJsonOrDef(rawKey, defVal) {
+    if (this.implementation.type === "string" /* string */) {
+      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(rawKey));
+    if (val == null || val === "undefined" || val === "null") {
+      return defVal;
+    }
+    return val;
+  }
+  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(rawKey),
+      set: (value) => this.setJson(rawKey, value)
+    };
+  }
+}
+// src/storage_adapter/specific/browser/browser_storage.ts
+function createWebLocalStorageMethods(_localStorage) {
+  return {
+    type: "string" /* string */,
+    getItem: async (key) => _localStorage.getItem(key),
+    setItem: async (key, value) => {
+      _localStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      _localStorage.removeItem(key);
+    }
+  };
+}
+function createTypedWebLocalStorage(_localStorage, keyPrefix) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter({
+      methods: createWebLocalStorageMethods(_localStorage),
+      keyPrefix
+    })
+  });
+}
+function createWebSessionStorageMethods(_sessionStorage) {
+  return {
+    type: "string" /* string */,
+    getItem: async (key) => _sessionStorage.getItem(key),
+    setItem: async (key, value) => {
+      _sessionStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      _sessionStorage.removeItem(key);
+    }
+  };
+}
+function createTypedWebSessionStorage(_sessionStorage, keyPrefix) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter({
+      methods: createWebSessionStorageMethods(_sessionStorage),
+      keyPrefix
+    })
+  });
+}
+// src/storage_adapter/specific/durable_object/durable_object_storage.ts
+function createDurableObjectStorageMethods(durableObjectStorage) {
+  return {
+    type: "json" /* json */,
+    getItem: (key) => durableObjectStorage.get(key),
+    setItem: (key, value) => durableObjectStorage.put(key, value),
+    removeItem: async (key) => {
+      await durableObjectStorage.delete(key);
+    }
+  };
+}
+function createDurableObjectTypedStorage(durableObjectStorage, keyPrefix) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter({
+      methods: createDurableObjectStorageMethods(durableObjectStorage),
+      keyPrefix
+    })
+  });
+}
+// src/storage_adapter/specific/memory/memory_storage.ts
+function createMemoryStorageMethods_string(memoryStorageMap = new Map) {
+  return {
+    type: "string" /* string */,
+    getItem: async (key) => memoryStorageMap.get(key) ?? null,
+    setItem: async (key, value) => {
+      memoryStorageMap.set(key, value);
+    },
+    removeItem: async (key) => {
+      memoryStorageMap.delete(key);
+    }
+  };
+}
+function createTypedMemoryStorage_string(memoryStorageMap = new Map, keyPrefix) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter({
+      methods: createMemoryStorageMethods_string(memoryStorageMap),
+      keyPrefix
+    })
+  });
+}
+function createMemoryStorageMethods_json(memoryStorageMap = new Map) {
+  return {
+    type: "json" /* json */,
+    getItem: async (key) => memoryStorageMap.get(key),
+    setItem: async (key, value) => {
+      memoryStorageMap.set(key, value);
+    },
+    removeItem: async (key) => {
+      memoryStorageMap.delete(key);
+    }
+  };
+}
+function createTypedMemoryStorage_json(memoryStorageMap = new Map, keyPrefix) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter({
+      methods: createMemoryStorageMethods_json(memoryStorageMap),
+      keyPrefix
+    })
+  });
+}
+export {
+  createWebSessionStorageMethods,
+  createWebLocalStorageMethods,
+  createTypedWebSessionStorage,
+  createTypedWebLocalStorage,
+  createTypedStorage,
+  createTypedMemoryStorage_string,
+  createTypedMemoryStorage_json,
+  createMemoryStorageMethods_string,
+  createMemoryStorageMethods_json,
+  createDurableObjectTypedStorage,
+  createDurableObjectStorageMethods,
+  StorageAdapter,
+  EStorageAdapterType
+};

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.10",
+  "version": "0.2.12",
   "private": false,
   "type": "module",
   "exports": {