universe-code 0.0.13 → 0.0.15

package/dist/indexdb/db.js

@@ -11,8 +11,9 @@ export class DBManager {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(this.dbName, this.version);
 
-      request.onupgradeneeded = (e) => {
-        const db = e.target.result;
+      request.onupgradeneeded = ({ target }) => {
+        const db = target.result;
+
         stores.forEach(({ name, keyPath = "id", autoIncrement = false }) => {
           if (!db.objectStoreNames.contains(name)) {
             db.createObjectStore(name, { keyPath, autoIncrement });
@@ -24,6 +25,7 @@ export class DBManager {
         this.db = request.result;
         resolve(this.db);
       };
+
       request.onerror = () => reject(request.error);
     });
   }

package/dist/indexdb/index.js

@@ -1,11 +1,2 @@
-import { DBManager } from './db.js';
-import { DB } from './store.js';
-
-// Export everything as a unified object or individual pieces
-export { DBManager, DB };
-
-// Default export for easy usage
-export default {
-  DBManager,
-  ...DB
-};
+export { DBManager } from "./db.js";
+export { Store } from "./store.js";

package/dist/indexdb/store.js

@@ -1,13 +1,13 @@
-// Internal helper for transactions
-const perform = (db, storeName, mode, action) => {
-  return new Promise((resolve, reject) => {
+// Single internal helper (never repeated)
+const perform = (db, storeName, mode, action) =>
+  new Promise((resolve, reject) => {
     const tx = db.transaction(storeName, mode);
     const store = tx.objectStore(storeName);
     const request = action(store);
+
     request.onsuccess = () => resolve(request.result);
     request.onerror = () => reject(request.error);
   });
-};
 
 export class Store {
   constructor(db, storeName) {
@@ -15,48 +15,48 @@ export class Store {
     this.storeName = storeName;
   }
 
-  // Now these methods don't need db or storeName passed in!
-  async get(key) {
-    return await perform(this.db, this.storeName, "readonly", s => s.get(key));
+  get(key) {
+    return perform(this.db, this.storeName, "readonly", s => s.get(key));
   }
 
-  async put(data) {
-    return await perform(this.db, this.storeName, "readwrite", s => s.put(data));
+  put(data) {
+    return perform(this.db, this.storeName, "readwrite", s => s.put(data));
   }
 
-  async remove(key) {
-    return await perform(this.db, this.storeName, "readwrite", s => s.delete(key));
+  remove(key) {
+    return perform(this.db, this.storeName, "readwrite", s => s.delete(key));
   }
 
-  async clear() {
-    return await perform(this.db, this.storeName, "readwrite", s => s.clear());
+  clear() {
+    return perform(this.db, this.storeName, "readwrite", s => s.clear());
   }
 
   /**
-   * Smart Fetch with TTL
+   * Smart Fetch with TTL caching
    */
   async fetch(key, ttl, apiCall) {
+    const now = Date.now();
+
     try {
       const cached = await this.get(key);
-      const now = Date.now();
 
-      if (cached?.timestamp && (now - cached.timestamp < ttl)) {
+      if (cached?.timestamp && now - cached.timestamp < ttl) {
         return cached.data;
       }
 
-      const freshData = await apiCall();
+      const data = await apiCall();
 
       await this.put({
         id: key,
-        data: freshData,
+        data,
         timestamp: now
       });
 
-      return freshData;
-    } catch (error) {
-      console.warn("Returning fallback data due to error:", error);
+      return data;
+    } catch (err) {
+      console.warn("IndexedDB fallback used:", err);
       const fallback = await this.get(key);
-      return fallback ? fallback.data : null;
+      return fallback?.data ?? null;
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universe-code",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Universal utility functions for all JS frameworks",
   "license": "ISC",
   "type": "module",