@choksheak/ts-utils 0.3.3 → 0.3.5

package/kvStore.mjs

@@ -54,33 +54,20 @@ function withOnError(request, reject) {
   };
   return request;
 }
-var KvStore = class {
-  constructor(dbName, options) {
-    this.dbName = dbName;
-    this.dbVersion = options?.dbVersion ?? KvStoreConfig.dbVersion;
-    this.storeName = options?.storeName ?? KvStoreConfig.storeName;
-    this.defaultExpiryMs = options?.defaultExpiryMs ? durationOrMsToMs(options.defaultExpiryMs) : KvStoreConfig.expiryMs;
-    this.gcIntervalMs = options?.gcIntervalMs ? durationOrMsToMs(options.gcIntervalMs) : KvStoreConfig.gcIntervalMs;
-    this.gcMsStorageKey = `__kvStore:lastGcMs:${dbName}:v${this.dbVersion}:${this.storeName}`;
-  }
-  /** We'll init the DB only on first use. */
-  db;
-  /** Local storage key name for the last GC completed timestamp. */
-  gcMsStorageKey;
-  dbVersion;
-  storeName;
-  defaultExpiryMs;
-  gcIntervalMs;
-  async getOrCreateDb() {
-    if (!this.db) {
-      this.db = await new Promise((resolve, reject) => {
-        const request = withOnError(
-          globalThis.indexedDB.open(this.dbName, this.dbVersion),
-          reject
-        );
+function createKvStore(dbName, options) {
+  let db;
+  const dbVersion = options?.dbVersion ?? KvStoreConfig.dbVersion;
+  const storeName = options?.storeName ?? KvStoreConfig.storeName;
+  const defaultExpiryMs = options?.defaultExpiryMs ? durationOrMsToMs(options.defaultExpiryMs) : KvStoreConfig.expiryMs;
+  const gcIntervalMs = options?.gcIntervalMs ? durationOrMsToMs(options.gcIntervalMs) : KvStoreConfig.gcIntervalMs;
+  const gcMsStorageKey = `__kvStore:lastGcMs:${dbName}:v${dbVersion}:${storeName}`;
+  async function getOrCreateDb() {
+    if (!db) {
+      db = await new Promise((resolve, reject) => {
+        const request = withOnError(indexedDB.open(dbName, dbVersion), reject);
         request.onupgradeneeded = (event) => {
-          const db = event.target.result;
-          const objectStore = db.createObjectStore(this.storeName, {
+          const db2 = event.target.result;
+          const objectStore = db2.createObjectStore(storeName, {
             keyPath: "key"
           });
           objectStore.createIndex("key", "key", {
@@ -88,247 +75,252 @@ var KvStore = class {
           });
         };
         request.onsuccess = (event) => {
-          const db = event.target.result;
-          resolve(db);
+          const db2 = event.target.result;
+          resolve(db2);
         };
       });
     }
-    return this.db;
+    return db;
   }
-  async transact(mode, callback) {
-    const db = await this.getOrCreateDb();
+  async function transact(mode, callback) {
+    const db2 = await getOrCreateDb();
     return await new Promise((resolve, reject) => {
-      const transaction = withOnError(
-        db.transaction(this.storeName, mode),
-        reject
-      );
+      const transaction = withOnError(db2.transaction(storeName, mode), reject);
       transaction.onabort = (event) => {
         reject(event);
       };
-      const objectStore = transaction.objectStore(this.storeName);
+      const objectStore = transaction.objectStore(storeName);
       callback(objectStore, resolve, reject);
     });
   }
-  /** Set a value in the store. */
-  async set(key, value, expiryDeltaMs = this.defaultExpiryMs) {
-    const nowMs = Date.now();
-    const obj = {
-      key,
-      value,
-      storedMs: nowMs,
-      expiryMs: nowMs + durationOrMsToMs(expiryDeltaMs)
-    };
-    return await this.transact(
-      "readwrite",
-      (objectStore, resolve, reject) => {
-        const request = withOnError(objectStore.put(obj), reject);
+  const obj = {
+    /** Input name for the DB. */
+    dbName,
+    /** Input version for the DB. */
+    dbVersion,
+    /** Input name for the DB store. */
+    storeName,
+    /** Default expiry to use if not specified in set(). */
+    defaultExpiryMs,
+    /** Time interval for when GC's occur. */
+    gcIntervalMs,
+    /** Local storage key name for the last GC completed timestamp. */
+    gcMsStorageKey,
+    /** Set a value in the store. */
+    async set(key, value, expiryDeltaMs) {
+      const nowMs = Date.now();
+      const stored = {
+        key,
+        value,
+        storedMs: nowMs,
+        expiryMs: nowMs + durationOrMsToMs(expiryDeltaMs ?? defaultExpiryMs)
+      };
+      return await transact("readwrite", (objectStore, resolve, reject) => {
+        const request = withOnError(objectStore.put(stored), reject);
         request.onsuccess = () => {
           resolve(value);
-          this.gc();
-        };
-      }
-    );
-  }
-  /** Delete one or multiple keys. */
-  async delete(key) {
-    return await this.transact(
-      "readwrite",
-      (objectStore, resolve, reject) => {
-        objectStore.transaction.oncomplete = () => {
-          resolve();
+          obj.gc();
         };
-        if (typeof key === "string") {
-          withOnError(objectStore.delete(key), reject);
-        } else {
-          for (const k of key) {
-            withOnError(objectStore.delete(k), reject);
+      });
+    },
+    /** Delete one or multiple keys. */
+    async delete(key) {
+      return await transact(
+        "readwrite",
+        (objectStore, resolve, reject) => {
+          objectStore.transaction.oncomplete = () => {
+            resolve();
+          };
+          if (typeof key === "string") {
+            withOnError(objectStore.delete(key), reject);
+          } else {
+            for (const k of key) {
+              withOnError(objectStore.delete(k), reject);
+            }
           }
         }
+      );
+    },
+    /** Mainly used to get the expiration timestamp of an object. */
+    async getStoredObject(key) {
+      const stored = await transact(
+        "readonly",
+        (objectStore, resolve, reject) => {
+          const request = withOnError(objectStore.get(key), reject);
+          request.onsuccess = () => {
+            resolve(request.result);
+          };
+        }
+      );
+      if (!stored) {
+        return void 0;
       }
-    );
-  }
-  /** Mainly used to get the expiration timestamp of an object. */
-  async getStoredObject(key) {
-    const stored = await this.transact(
-      "readonly",
-      (objectStore, resolve, reject) => {
-        const request = withOnError(objectStore.get(key), reject);
-        request.onsuccess = () => {
-          resolve(request.result);
-        };
-      }
-    );
-    if (!stored) {
-      return void 0;
-    }
-    try {
-      const obj = validateStoredObject(stored);
-      if (!obj) {
-        await this.delete(key);
-        this.gc();
+      try {
+        const valid = validateStoredObject(stored);
+        if (!valid) {
+          await obj.delete(key);
+          obj.gc();
+          return void 0;
+        }
+        return valid;
+      } catch (e) {
+        console.error(`Invalid kv value: ${key}=${JSON.stringify(stored)}:`, e);
+        await obj.delete(key);
+        obj.gc();
         return void 0;
       }
-      return obj;
-    } catch (e) {
-      console.error(`Invalid kv value: ${key}=${JSON.stringify(stored)}:`, e);
-      await this.delete(key);
-      this.gc();
-      return void 0;
-    }
-  }
-  /** Get a value by key, or undefined if it does not exist. */
-  async get(key) {
-    const obj = await this.getStoredObject(key);
-    return obj?.value;
-  }
-  /** Generic way to iterate through all entries. */
-  async forEach(callback) {
-    await this.transact("readonly", (objectStore, resolve, reject) => {
-      const request = withOnError(objectStore.openCursor(), reject);
-      request.onsuccess = async (event) => {
-        const cursor = event.target.result;
-        if (cursor) {
-          if (cursor.key) {
-            const obj = validateStoredObject(cursor.value);
-            if (obj !== void 0) {
-              await callback(
-                String(cursor.key),
-                obj.value,
-                obj.expiryMs,
-                obj.storedMs
-              );
+    },
+    /** Get a value by key, or undefined if it does not exist. */
+    async get(key) {
+      const stored = await obj.getStoredObject(key);
+      return stored?.value;
+    },
+    /** Generic way to iterate through all entries. */
+    async forEach(callback) {
+      await transact("readonly", (objectStore, resolve, reject) => {
+        const request = withOnError(objectStore.openCursor(), reject);
+        request.onsuccess = async (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            if (cursor.key) {
+              const valid = validateStoredObject(cursor.value);
+              if (valid !== void 0) {
+                await callback(
+                  String(cursor.key),
+                  valid.value,
+                  valid.expiryMs,
+                  valid.storedMs
+                );
+              }
             }
+            cursor.continue();
+          } else {
+            resolve();
           }
-          cursor.continue();
-        } else {
+        };
+      });
+    },
+    /**
+     * Returns the number of items in the store. Note that getting the size
+     * requires iterating through the entire store because the items could expire
+     * at any time, and hence the size is a dynamic number.
+     */
+    async size() {
+      let count = 0;
+      await obj.forEach(() => {
+        count++;
+      });
+      return count;
+    },
+    /** Remove all items from the store. */
+    async clear() {
+      await transact("readwrite", (objectStore, resolve, reject) => {
+        const request = withOnError(objectStore.clear(), reject);
+        request.onsuccess = () => {
           resolve();
+        };
+      });
+    },
+    /**
+     * Returns all items as map of key to value, mainly used for debugging dumps.
+     * The type T is applied to all values, even though they might not be of type
+     * T (in the case when you store different data types in the same store).
+     */
+    async asMap() {
+      const map = /* @__PURE__ */ new Map();
+      await obj.forEach((key, value, expiryMs, storedMs) => {
+        map.set(key, { value, expiryMs, storedMs });
+      });
+      return map;
+    },
+    /** Returns the ms timestamp for the last GC (garbage collection). */
+    getLastGcMs() {
+      const lastGcMsStr = localStorage.getItem(gcMsStorageKey);
+      if (!lastGcMsStr) return 0;
+      const ms = Number(lastGcMsStr);
+      return isNaN(ms) ? 0 : ms;
+    },
+    /** Set the ms timestamp for the last GC (garbage collection). */
+    setLastGcMs(ms) {
+      localStorage.setItem(gcMsStorageKey, String(ms));
+    },
+    /** Perform garbage-collection if due, else do nothing. */
+    async gc() {
+      const lastGcMs = obj.getLastGcMs();
+      if (!lastGcMs) {
+        obj.setLastGcMs(Date.now());
+        return;
+      }
+      if (Date.now() < lastGcMs + gcIntervalMs) {
+        return;
+      }
+      await obj.gcNow();
+    },
+    /**
+     * Perform garbage collection immediately without checking whether we are
+     * due for the next GC or not.
+     */
+    async gcNow() {
+      console.log(`Starting kvStore GC on ${dbName} v${dbVersion}...`);
+      obj.setLastGcMs(Date.now());
+      const keysToDelete = [];
+      await obj.forEach(
+        async (key, value, expiryMs) => {
+          if (value === void 0 || Date.now() >= expiryMs) {
+            keysToDelete.push(key);
+          }
         }
-      };
-    });
-  }
-  /**
-   * Returns the number of items in the store. Note that getting the size
-   * requires iterating through the entire store because the items could expire
-   * at any time, and hence the size is a dynamic number.
-   */
-  async size() {
-    let count = 0;
-    await this.forEach(() => {
-      count++;
-    });
-    return count;
-  }
-  /** Remove all items from the store. */
-  async clear() {
-    await this.transact("readwrite", (objectStore, resolve, reject) => {
-      const request = withOnError(objectStore.clear(), reject);
-      request.onsuccess = () => {
-        resolve();
-      };
-    });
-  }
-  /**
-   * Returns all items as map of key to value, mainly used for debugging dumps.
-   * The type T is applied to all values, even though they might not be of type
-   * T (in the case when you store different data types in the same store).
-   */
-  async asMap() {
-    const map = /* @__PURE__ */ new Map();
-    await this.forEach((key, value, expiryMs, storedMs) => {
-      map.set(key, { value, expiryMs, storedMs });
-    });
-    return map;
-  }
-  /** Returns the ms timestamp for the last GC (garbage collection). */
-  get lastGcMs() {
-    const lastGcMsStr = globalThis.localStorage.getItem(this.gcMsStorageKey);
-    if (!lastGcMsStr) return 0;
-    const ms = Number(lastGcMsStr);
-    return isNaN(ms) ? 0 : ms;
-  }
-  /** Set the ms timestamp for the last GC (garbage collection). */
-  set lastGcMs(ms) {
-    globalThis.localStorage.setItem(this.gcMsStorageKey, String(ms));
-  }
-  /** Perform garbage-collection if due, else do nothing. */
-  async gc() {
-    const lastGcMs = this.lastGcMs;
-    if (!lastGcMs) {
-      this.lastGcMs = Date.now();
-      return;
-    }
-    if (Date.now() < lastGcMs + this.gcIntervalMs) {
-      return;
-    }
-    await this.gcNow();
-  }
-  /**
-   * Perform garbage collection immediately without checking whether we are
-   * due for the next GC or not.
-   */
-  async gcNow() {
-    console.log(`Starting kvStore GC on ${this.dbName} v${this.dbVersion}...`);
-    this.lastGcMs = Date.now();
-    const keysToDelete = [];
-    await this.forEach(
-      async (key, value, expiryMs) => {
-        if (value === void 0 || Date.now() >= expiryMs) {
-          keysToDelete.push(key);
-        }
+      );
+      if (keysToDelete.length) {
+        await obj.delete(keysToDelete);
       }
-    );
-    if (keysToDelete.length) {
-      await this.delete(keysToDelete);
+      console.log(
+        `Finished kvStore GC on ${dbName} v${dbVersion} - deleted ${keysToDelete.length} keys`
+      );
+      obj.setLastGcMs(Date.now());
+    },
+    /** Returns `this` casted into a StorageAdapter<T>. */
+    asStorageAdapter() {
+      return obj;
     }
-    console.log(
-      `Finished kvStore GC on ${this.dbName} v${this.dbVersion} - deleted ${keysToDelete.length} keys`
-    );
-    this.lastGcMs = Date.now();
-  }
-  /** Returns `this` casted into a StorageAdapter<T>. */
-  asStorageAdapter() {
-    return this;
-  }
-};
-var kvStore = new KvStore(KvStoreConfig.dbName);
-var KvStoreItem = class {
-  constructor(key, defaultExpiryMs = KvStoreConfig.expiryMs, store = kvStore) {
-    this.key = key;
-    this.store = store;
-    this.defaultExpiryMs = defaultExpiryMs && durationOrMsToMs(defaultExpiryMs);
-  }
-  defaultExpiryMs;
-  /** Set a value in the store. */
-  async set(value, expiryDeltaMs = this.defaultExpiryMs) {
-    await this.store.set(this.key, value, expiryDeltaMs);
-  }
-  /**
-   * Example usage:
-   *
-   *   const { value, storedMs, expiryMs, storedMs } =
-   *     await myKvItem.getStoredObject();
-   */
-  async getStoredObject() {
-    return await this.store.getStoredObject(this.key);
-  }
-  /** Get a value by key, or undefined if it does not exist. */
-  async get() {
-    return await this.store.get(this.key);
-  }
-  /** Delete this key from the store. */
-  async delete() {
-    await this.store.delete(this.key);
-  }
-};
+  };
+  return obj;
+}
+var kvStore = createKvStore(KvStoreConfig.dbName);
 function kvStoreItem(key, expiryMs, store = kvStore) {
-  expiryMs = expiryMs && durationOrMsToMs(expiryMs);
-  return new KvStoreItem(key, expiryMs, store);
+  const defaultExpiryMs = expiryMs && durationOrMsToMs(expiryMs);
+  const obj = {
+    key,
+    defaultExpiryMs,
+    store,
+    /** Set a value in the store. */
+    async set(value, expiryDeltaMs) {
+      await store.set(key, value, expiryDeltaMs ?? defaultExpiryMs);
+    },
+    /**
+     * Example usage:
+     *
+     *   const { value, storedMs, expiryMs, storedMs } =
+     *     await myKvItem.getStoredObject();
+     */
+    async getStoredObject() {
+      return await store.getStoredObject(key);
+    },
+    /** Get a value by key, or undefined if it does not exist. */
+    async get() {
+      return await store.get(key);
+    },
+    /** Delete this key from the store. */
+    async delete() {
+      await store.delete(key);
+    }
+  };
+  return obj;
 }
 export {
-  KvStore,
   KvStoreConfig,
-  KvStoreItem,
   configureKvStore,
+  createKvStore,
   kvStore,
   kvStoreItem
 };