@ztimson/utils 0.25.7 → 0.25.9

package/dist/database.d.ts

@@ -1,27 +1,38 @@
 export type TableOptions = {
     name: string;
     key?: string;
+    autoIncrement?: boolean;
 };
 export declare class Database {
     readonly database: string;
     version?: number | undefined;
     connection: Promise<IDBDatabase>;
+    ready: boolean;
     tables: TableOptions[];
-    constructor(database: string, tables: (string | TableOptions)[], version?: number | undefined);
+    constructor(database: string, tables?: (string | TableOptions)[], version?: number | undefined);
+    createTable<K extends IDBValidKey = any, T = any>(table: string | TableOptions): Promise<Table<K, T>>;
+    deleteTable(table: string | TableOptions): Promise<void>;
     includes(name: any): boolean;
     table<K extends IDBValidKey = any, T = any>(name: any): Table<K, T>;
 }
 export declare class Table<K extends IDBValidKey = any, T = any> {
     private readonly database;
     readonly name: string;
-    constructor(database: Database, name: string);
+    readonly key: keyof T | string;
+    constructor(database: Database, name: string, key?: keyof T | string);
     tx<R>(table: string, fn: (store: IDBObjectStore) => IDBRequest, readonly?: boolean): Promise<R>;
     add(value: T, key?: K): Promise<void>;
+    all: () => Promise<T[]>;
+    clear(): Promise<void>;
     count(): Promise<number>;
-    put(key: K, value: T): Promise<void>;
+    create: (value: T, key?: K) => Promise<void>;
+    delete(key: K): Promise<void>;
+    get(key: K): Promise<T>;
     getAll(): Promise<T[]>;
     getAllKeys(): Promise<K[]>;
-    get(key: K): Promise<T>;
-    delete(key: K): Promise<void>;
-    clear(): Promise<void>;
+    put(key: K, value: T): Promise<void>;
+    read(): Promise<T[]>;
+    read(key: K): Promise<T>;
+    set(value: T, key?: K): Promise<void>;
+    update: (value: T, key?: K) => Promise<void>;
 }

package/dist/index.cjs

@@ -399,46 +399,88 @@ ${opts.message || this.desc}`;
   class Database {
     constructor(database, tables, version) {
       __publicField(this, "connection");
+      __publicField(this, "ready", false);
       __publicField(this, "tables");
       this.database = database;
       this.version = version;
       this.connection = new Promise((resolve, reject) => {
         const req = indexedDB.open(this.database, this.version);
-        this.tables = tables.map((t) => {
+        this.tables = !tables ? [] : tables.map((t) => {
           t = typeof t == "object" ? t : { name: t };
           return { ...t, name: t.name.toString() };
         });
-        const tableNames = new ASet(this.tables.map((t) => t.name));
         req.onerror = () => reject(req.error);
         req.onsuccess = () => {
           const db = req.result;
-          if (tableNames.symmetricDifference(new ASet(Array.from(db.objectStoreNames))).length) {
+          const existing = Array.from(db.objectStoreNames);
+          if (!tables) this.tables = existing.map((t) => {
+            const tx = db.transaction(t, "readonly");
+            const store = tx.objectStore(t);
+            return { name: t, key: store.keyPath };
+          });
+          const desired = new ASet((tables || []).map((t) => typeof t == "string" ? t : t.name));
+          if (tables && desired.symmetricDifference(new ASet(existing)).length) {
             db.close();
             Object.assign(this, new Database(this.database, this.tables, db.version + 1));
+            this.connection.then(resolve);
           } else {
             this.version = db.version;
             resolve(db);
           }
+          this.ready = true;
         };
         req.onupgradeneeded = () => {
           const db = req.result;
           const existingTables = new ASet(Array.from(db.objectStoreNames));
-          existingTables.difference(tableNames).forEach((name) => db.deleteObjectStore(name));
-          tableNames.difference(existingTables).forEach((name) => db.createObjectStore(name));
+          if (tables) {
+            const desired = new ASet((tables || []).map((t) => typeof t == "string" ? t : t.name));
+            existingTables.difference(desired).forEach((name) => db.deleteObjectStore(name));
+            desired.difference(existingTables).forEach((name) => {
+              const t = this.tables.find(findByProp("name", name));
+              db.createObjectStore(name, {
+                keyPath: t == null ? void 0 : t.key,
+                autoIncrement: (t == null ? void 0 : t.autoIncrement) || !(t == null ? void 0 : t.key)
+              });
+            });
+          }
         };
       });
     }
+    async createTable(table) {
+      if (typeof table == "string") table = { name: table };
+      const conn = await this.connection;
+      if (!this.includes(table.name)) {
+        conn.close();
+        Object.assign(this, new Database(this.database, [...this.tables, table], (this.version ?? 0) + 1));
+      }
+      return this.table(table.name);
+    }
+    async deleteTable(table) {
+      if (typeof table == "string") table = { name: table };
+      if (!this.includes(table.name)) return;
+      const conn = await this.connection;
+      conn.close();
+      Object.assign(this, new Database(this.database, this.tables.filter((t) => t.name != table.name), (this.version ?? 0) + 1));
+    }
     includes(name) {
-      return !!this.tables.find((t) => t.name == name.toString());
+      return !!this.tables.find((t) => t.name == (typeof name == "object" ? name.name : name.toString()));
     }
     table(name) {
       return new Table(this, name.toString());
     }
   }
   class Table {
-    constructor(database, name) {
+    constructor(database, name, key = "id") {
+      __publicField(this, "all", this.getAll);
+      __publicField(this, "create", this.add);
+      __publicField(this, "update", this.set);
       this.database = database;
       this.name = name;
+      this.key = key;
+      this.database.connection.then(() => {
+        const exists = !!this.database.tables.find(findByProp("name", this.name));
+        if (!exists) this.database.createTable(this.name);
+      });
     }
     async tx(table, fn2, readonly = false) {
       const db = await this.database.connection;
@@ -453,11 +495,17 @@ ${opts.message || this.desc}`;
     add(value, key) {
       return this.tx(this.name, (store) => store.add(value, key));
     }
+    clear() {
+      return this.tx(this.name, (store) => store.clear());
+    }
     count() {
       return this.tx(this.name, (store) => store.count(), true);
     }
-    put(key, value) {
-      return this.tx(this.name, (store) => store.put(value, key));
+    delete(key) {
+      return this.tx(this.name, (store) => store.delete(key));
+    }
+    get(key) {
+      return this.tx(this.name, (store) => store.get(key), true);
     }
     getAll() {
       return this.tx(this.name, (store) => store.getAll(), true);
@@ -465,14 +513,15 @@ ${opts.message || this.desc}`;
     getAllKeys() {
       return this.tx(this.name, (store) => store.getAllKeys(), true);
     }
-    get(key) {
-      return this.tx(this.name, (store) => store.get(key), true);
+    put(key, value) {
+      return this.tx(this.name, (store) => store.put(value, key));
     }
-    delete(key) {
-      return this.tx(this.name, (store) => store.delete(key));
+    read(key) {
+      return key ? this.get(key) : this.getAll();
     }
-    clear() {
-      return this.tx(this.name, (store) => store.clear());
+    set(value, key) {
+      if (!key && !value[this.key]) return this.add(value);
+      return this.put(key || value[this.key], value);
     }
   }
   class Cache {
@@ -661,8 +710,9 @@ ${opts.message || this.desc}`;
   const SYMBOL_LIST = "~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/";
   const CHAR_LIST = LETTER_LIST + LETTER_LIST.toLowerCase() + NUMBER_LIST + SYMBOL_LIST;
   function camelCase(str) {
-    const text = pascalCase(str);
-    return !text ? "" : text[0].toLowerCase() + text.slice(1);
+    if (!str) return "";
+    const pascal = pascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
   }
   function formatBytes(bytes, decimals = 2) {
     if (bytes === 0) return "0 Bytes";
@@ -681,16 +731,15 @@ ${opts.message || this.desc}`;
   }
   function kebabCase(str) {
     if (!str) return "";
-    return str.replaceAll(/(^[^a-zA-Z]+|[^a-zA-Z0-9-_])/g, "").replaceAll(/([A-Z]|[0-9]+)/g, (...args) => `-${args[0].toLowerCase()}`).replaceAll(/([0-9])([a-z])/g, (...args) => `${args[1]}-${args[2]}`).replaceAll(/[^a-z0-9]+(\w?)/g, (...args) => `-${args[1] ?? ""}`).toLowerCase();
+    return wordSegments(str).map((w) => w.toLowerCase()).join("-");
   }
   function pad(text, length, char = " ", start = true) {
     if (start) return text.toString().padStart(length, char);
     return text.toString().padEnd(length, char);
   }
   function pascalCase(str) {
-    var _a;
     if (!str) return "";
-    return ((_a = str.match(/[a-zA-Z0-9]+/g)) == null ? void 0 : _a.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("")) ?? "";
+    return wordSegments(str).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
   }
   function randomHex(length) {
     return Array(length).fill(null).map(() => Math.round(Math.random() * 15).toString(16)).join("");
@@ -720,7 +769,7 @@ ${opts.message || this.desc}`;
   }
   function snakeCase(str) {
     if (!str) return "";
-    return str.replaceAll(/(^[^a-zA-Z]+|[^a-zA-Z0-9-_])/g, "").replaceAll(/([A-Z]|[0-9]+)/g, (...args) => `_${args[0].toLowerCase()}`).replaceAll(/([0-9])([a-z])/g, (...args) => `${args[1]}_${args[2]}`).replaceAll(/[^a-z0-9]+(\w?)/g, (...args) => `_${args[1] ?? ""}`).toLowerCase();
+    return wordSegments(str).map((w) => w.toLowerCase()).join("_");
   }
   function strSplice(str, start, deleteCount, insert = "") {
     const before = str.slice(0, start);
@@ -810,6 +859,10 @@ ${opts.message || this.desc}`;
   function bit_rol(d, _) {
     return d << _ | d >>> 32 - _;
   }
+  function wordSegments(str) {
+    if (!str) return [];
+    return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([0-9]+)([a-zA-Z])/g, "$1 $2").replace(/([a-zA-Z])([0-9]+)/g, "$1 $2").replace(/[_\-\s]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  }
   function validateEmail(email) {
     return /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/.test(email);
   }
@@ -2121,6 +2174,7 @@ ${opts.message || this.desc}`;
   exports2.toCsv = toCsv;
   exports2.uploadWithProgress = uploadWithProgress;
   exports2.validateEmail = validateEmail;
+  exports2.wordSegments = wordSegments;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });
 //# sourceMappingURL=index.cjs.map