@ztimson/utils 0.25.0 → 0.25.1

package/dist/cache.d.ts

@@ -1,8 +1,9 @@
+import { Collection } from './database.ts';
 export type CacheOptions = {
     /** Delete keys automatically after x amount of seconds */
     ttl?: number;
     /** Storage to persist cache */
-    storage?: Storage;
+    storage?: Storage | Collection<any, any>;
     /** Key cache will be stored under */
     storageKey?: string;
     /** Keep or delete cached items once expired, defaults to delete */

package/dist/database.d.ts

@@ -0,0 +1,17 @@
+export declare class Collection<K extends IDBValidKey, T> {
+    readonly db: string;
+    readonly collection: string;
+    readonly version?: number | undefined;
+    private setup?;
+    private database;
+    constructor(db: string, collection: string, version?: number | undefined, setup?: ((db: IDBDatabase, event: IDBVersionChangeEvent) => void) | undefined);
+    tx<T>(collection: string, fn: ((store: IDBObjectStore) => IDBRequest), readonly?: boolean): Promise<T>;
+    add(value: T, key?: K): Promise<void>;
+    count(): Promise<number>;
+    put(key: K, value: T): Promise<void>;
+    getAll(): Promise<T[]>;
+    getAllKeys(): Promise<K[]>;
+    get(key: K): Promise<T>;
+    delete(key: K): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/index.cjs

@@ -396,6 +396,60 @@ ${opts.message || this.desc}`;
   function makeArray(value) {
     return Array.isArray(value) ? value : [value];
   }
+  class Collection {
+    constructor(db, collection, version, setup) {
+      __publicField(this, "database");
+      this.db = db;
+      this.collection = collection;
+      this.version = version;
+      this.setup = setup;
+      this.database = new Promise((resolve, reject) => {
+        const req = indexedDB.open(this.db, this.version);
+        req.onerror = () => reject(req.error);
+        req.onsuccess = () => resolve(req.result);
+        req.onupgradeneeded = (event) => {
+          const db2 = req.result;
+          if (!db2.objectStoreNames.contains(collection)) db2.createObjectStore(collection, { keyPath: void 0 });
+          if (this.setup) this.setup(db2, event);
+        };
+      });
+    }
+    async tx(collection, fn2, readonly) {
+      const db = await this.database;
+      const tx = db.transaction(collection, readonly ? "readonly" : "readwrite");
+      const store = tx.objectStore(collection);
+      return new Promise((resolve, reject) => {
+        const request = fn2(store);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
+    }
+    add(value, key) {
+      return this.tx(this.collection, (store) => store.add(value, key));
+    }
+    count() {
+      return this.tx(this.collection, (store) => store.count(), true);
+    }
+    put(key, value) {
+      debugger;
+      return this.tx(this.collection, (store) => store.put(value, key));
+    }
+    getAll() {
+      return this.tx(this.collection, (store) => store.getAll(), true);
+    }
+    getAllKeys() {
+      return this.tx(this.collection, (store) => store.getAllKeys(), true);
+    }
+    get(key) {
+      return this.tx(this.collection, (store) => store.get(key), true);
+    }
+    delete(key) {
+      return this.tx(this.collection, (store) => store.delete(key));
+    }
+    clear() {
+      return this.tx(this.collection, (store) => store.clear());
+    }
+  }
   class Cache {
     /**
      * Create new cache
@@ -411,14 +465,19 @@ ${opts.message || this.desc}`;
        * @return {T[]} Array of items
        */
       __publicField(this, "values", this.all());
+      var _a;
       this.key = key;
       this.options = options;
-      if (options.storageKey && !options.storage && typeof Storage !== "undefined")
-        options.storage = localStorage;
-      if (options.storageKey && options.storage) {
-        const stored = options.storage.getItem(options.storageKey);
-        if (stored) {
-          try {
+      if (options.storageKey && !options.storage && typeof Storage !== "undefined") options.storage = localStorage;
+      if (options.storage) {
+        if (options.storage instanceof Collection) {
+          (async () => {
+            var _a2;
+            (await ((_a2 = options.storage) == null ? void 0 : _a2.getAll())).forEach((v) => this.add(v));
+          })();
+        } else if (options.storageKey) {
+          const stored = (_a = options.storage) == null ? void 0 : _a.getItem(options.storageKey);
+          if (stored != null) try {
             Object.assign(this.store, JSON.parse(stored));
           } catch {
           }
@@ -440,9 +499,14 @@ ${opts.message || this.desc}`;
       if (!this.key) throw new Error("No key defined");
       return value[this.key];
     }
-    save() {
-      if (this.options.storageKey && this.options.storage)
-        this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+    save(key) {
+      if (this.options.storage) {
+        if (this.options.storage instanceof Collection) {
+          this.options.storage.put(key, this.store[key]);
+        } else if (this.options.storageKey) {
+          this.options.storage.setItem(this.options.storageKey, JSONSanitize(this.store));
+        }
+      }
     }
     /**
      * Get all cached items
@@ -488,7 +552,7 @@ ${opts.message || this.desc}`;
      */
     delete(key) {
       delete this.store[key];
-      this.save();
+      this.save(key);
       return this;
     }
     /**
@@ -546,10 +610,10 @@ ${opts.message || this.desc}`;
     set(key, value, ttl = this.options.ttl) {
       if (this.options.expiryPolicy == "keep") delete value._expired;
       this.store[key] = value;
-      this.save();
+      this.save(key);
       if (ttl) setTimeout(() => {
         this.expire(key);
-        this.save();
+        this.save(key);
       }, (ttl || 0) * 1e3);
       return this;
     }
@@ -1938,6 +2002,7 @@ ${opts.message || this.desc}`;
   exports2.CliBackground = CliBackground;
   exports2.CliEffects = CliEffects;
   exports2.CliForeground = CliForeground;
+  exports2.Collection = Collection;
   exports2.CustomError = CustomError;
   exports2.ForbiddenError = ForbiddenError;
   exports2.GatewayTimeoutError = GatewayTimeoutError;