universe-code 0.0.60 → 0.0.62

package/dist/angular/index.d.ts

@@ -0,0 +1,7 @@
+export declare class IdbService {
+    fetchWithCache(
+        key: string,
+        ttl: number,
+        apiFn: () => Promise<any>
+    ): Promise<any>;
+}

package/dist/angular/index.js

@@ -0,0 +1 @@
+export { IdbService } from './services/idbService.ts';

package/dist/angular/services/idbService.ts

@@ -1,92 +1,66 @@
 import { Injectable } from '@angular/core';
 import { DBManager, DB } from 'universe-code/indexdb';
 
-@Injectable({
-  providedIn: 'root'
-})
-export class idbService {
-  private manager = new DBManager('exchange', 1);
-  private db!: IDBDatabase;
-  private store: {
-    get: (key: string) => Promise<any>;
-    getWithExpiry: (
-      key: string,
-      ttl: number,
-      api: () => Promise<any>
-    ) => Promise<any>;
-    put: (data: any) => Promise<any>;
-    remove: (key: string) => Promise<any>;
-    clear: () => Promise<any>;
-  } | null = null;
+@Injectable({ providedIn: 'root' })
+export class IdbService {
 
+  private manager = new DBManager('exchange', 1);
+  private db: IDBDatabase | null = null;
+  private store: any = null;
   private readonly storeName = 'exchangeStore';
 
-  /**
-   * Initialize DB + Store only once (Singleton)
-   */
   private async getStore() {
     if (!this.store) {
       if (!this.db) {
-        this.db = await this.manager.connect([
-          { name: this.storeName }
-        ]);
+        this.db = await this.manager.connect([{ name: this.storeName }]);
       }
 
       this.store = {
         get: (key: string) =>
-          DB.get(this.db, this.storeName, key),
+          DB.get(this.db!, this.storeName, key),
 
         getWithExpiry: (
           key: string,
           ttl: number,
           api: () => Promise<any>
         ) =>
-          DB.getWithExpiry(this.db, this.storeName, key, ttl, api),
+          DB.getWithExpiry(this.db!, this.storeName, key, ttl, api),
 
         put: (data: any) =>
-          DB.put(this.db, this.storeName, data),
+          DB.put(this.db!, this.storeName, data),
 
         remove: (key: string) =>
-          DB.remove(this.db, this.storeName, key),
+          DB.remove(this.db!, this.storeName, key),
 
         clear: () =>
-          DB.clear(this.db, this.storeName)
+          DB.clear(this.db!, this.storeName)
       };
     }
 
     return this.store;
   }
 
-  /* =======================
-     PUBLIC METHODS
-     ======================= */
-
   async fetchWithCache(
     key: string,
     ttl: number,
     apiFn: () => Promise<any>
   ) {
-    const store = await this.getStore();
-    return store.getWithExpiry(key, ttl, apiFn);
+    return (await this.getStore()).getWithExpiry(key, ttl, apiFn);
   }
 
   async get(key: string) {
-    const store = await this.getStore();
-    return store.get(key);
+    return (await this.getStore()).get(key);
   }
 
   async set(data: any) {
-    const store = await this.getStore();
-    return store.put(data);
+    return (await this.getStore()).put(data);
   }
 
   async remove(key: string) {
-    const store = await this.getStore();
-    return store.remove(key);
+    return (await this.getStore()).remove(key);
   }
 
   async clear() {
-    const store = await this.getStore();
-    return store.clear();
+    return (await this.getStore()).clear();
   }
 }

package/dist/core/index.js

@@ -0,0 +1 @@
+export * from './time.js';

package/dist/core/{time.ts → time.js}

@@ -3,11 +3,11 @@
  * @param {number} minutes 
  * @returns {number} milliseconds
  */
-export const minutesToMs = (minutes: any) => minutes * 60 * 1000;
+export const minutesToMs = (minutes) => minutes * 60 * 1000;
 
 /**
  * Converts hours to milliseconds
  * @param {number} hours 
  * @returns {number} milliseconds
  */
-export const hoursToMs = (hours: any) => hours * 60 * 60 * 1000;
+export const hoursToMs = (hours) => hours * 60 * 60 * 1000;

package/dist/index.js

@@ -0,0 +1,10 @@
+// IndexedDB exports
+const indexdb = require("./indexdb");
+
+// (Socket will be added later)
+// const socket = require("./socket");
+
+module.exports = {
+  ...indexdb
+  // ...socket
+};

package/dist/indexdb/{db.ts → db.js}

@@ -1,28 +1,19 @@
 export class DBManager {
-  dbName: any;
-  version: any;
-  db: any;
-
-  constructor(dbName: any, version: any = 1) {
+  constructor(dbName, version = 1) {
     this.dbName = dbName;
     this.version = version;
     this.db = null;
   }
 
-  async connect(stores: any[] = []): Promise<any> {
+  async connect(stores = []) {
     if (this.db) return this.db;
 
     return new Promise((resolve, reject) => {
-      const request: any = indexedDB.open(this.dbName, this.version);
+      const request = indexedDB.open(this.dbName, this.version);
 
-      request.onupgradeneeded = (e: any) => {
+      request.onupgradeneeded = (e) => {
         const db = e.target.result;
-
-        stores.forEach((store: any) => {
-          const name = store.name;
-          const keyPath = store.keyPath || "id";
-          const autoIncrement = store.autoIncrement || false;
-
+        stores.forEach(({ name, keyPath = "id", autoIncrement = false }) => {
           if (!db.objectStoreNames.contains(name)) {
             db.createObjectStore(name, { keyPath, autoIncrement });
           }
@@ -33,8 +24,7 @@ export class DBManager {
         this.db = request.result;
         resolve(this.db);
       };
-
       request.onerror = () => reject(request.error);
     });
   }
-}
+}

package/dist/indexdb/{index.ts → index.js}

@@ -1,5 +1,5 @@
-import { DBManager } from './db.ts';
-import { DB } from './store.ts';
+import { DBManager } from './db.js';
+import { DB } from './store.js';
 
 // Export everything as a unified object or individual pieces
 export { DBManager, DB };

package/dist/indexdb/store.js

@@ -0,0 +1,55 @@
+/**
+ * Generic Transaction Wrapper
+ */
+const perform = (db, storeName, mode, action) => {
+  return 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 const DB = {
+  get: (db, store, key) => perform(db, store, "readonly", s => s.get(key)),
+
+  put: (db, store, data) => perform(db, store, "readwrite", s => s.put(data)),
+
+  remove: (db, store, key) => perform(db, store, "readwrite", s => s.delete(key)),
+
+  clear: (db, store) => perform(db, store, "readwrite", s => s.clear()),
+
+  /**
+   * PRO FEATURE: getWithExpiry
+   * Automatically refreshes data from an API if the local version is too old.
+   */
+  async getWithExpiry(db, storeName, key, ttl, apiCall) {
+    try {
+      const cached = await this.get(db, storeName, key);
+      const now = Date.now();
+
+      // If valid data exists and is NOT expired, return it
+      if (cached && cached.timestamp && (now - cached.timestamp < ttl)) {
+        return cached.data;
+      }
+
+      // Otherwise, call API
+      const freshData = await apiCall();
+
+      // Save to IndexedDB with new timestamp
+      await this.put(db, storeName, {
+        id: key,
+        data: freshData,
+        timestamp: now
+      });
+
+      return freshData;
+    } catch (error) {
+      console.warn("API/DB Error, returning fallback if available:", error);
+      const fallback = await this.get(db, storeName, key);
+      return fallback ? fallback.data : null;
+    }
+  }
+};

package/dist/react/{index.ts → index.js}

@@ -1,6 +1,6 @@
-import { getIdbStore } from './indexdb/store/idbStore.ts';
-import { useIdbStore } from './indexdb/hooks/idbHook.ts';
-import { configureIdb } from "./indexdb/store/config.ts";
+import { getIdbStore } from './indexdb/store/idbStore.js';
+import { useIdbStore } from './indexdb/hooks/idbHook.js';
+import { configureIdb } from "./indexdb/store/config.js";
 
 // Export everything as a unified object or individual pieces
 export { configureIdb, getIdbStore, useIdbStore };

package/dist/react/indexdb/hooks/{idbHook.ts → idbHook.js}

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { getIdbStore } from "../store/idbStore.ts";
+import { getIdbStore } from "./../store/idbStore.js";
 
 export const useIdbStore = () => {
     const [store, setStore] = useState(null);

package/dist/react/indexdb/store/{config.ts → config.js}

@@ -1,14 +1,9 @@
-let config: any = null;
+let config = null;
 
-export const configureIdb = (options: any) => {
+export const configureIdb = (options) => {
     if (config) {
         return;
     }
-
-    if (!options) {
-        throw new Error("configureIdb requires options");
-    }
-
     config = options;
 };
 
@@ -18,6 +13,5 @@ export const getConfig = () => {
             "IndexedDB not configured. Call configureIdb() before using the store."
         );
     }
-
     return config;
 };

package/dist/react/indexdb/store/idbStore.js

@@ -0,0 +1,39 @@
+import { DBManager, DB } from "universe-code";
+import { getConfig } from "./config.js";
+
+let db = null;
+let store = null;
+let manager = null;
+
+// ✅ index db connection
+const connectDB = async () => {
+  const { dbName, dbVersion, storeName } = getConfig(); // ✅ FIXED
+
+  if (!manager) {
+    manager = new DBManager(dbName, dbVersion);
+  }
+
+  if (!db) {
+    db = await manager.connect([{ name: storeName }]); // ✅ FIXED
+  }
+
+  return db;
+};
+
+export const getIdbStore = async () => {
+  if (!store) {
+    const { storeName } = getConfig(); // ✅ FIXED
+    const database = await connectDB();
+
+    store = {
+      get: (key) => DB.get(database, storeName, key),
+      getWithExpiry: (key, ttl, api) =>
+        DB.getWithExpiry(database, storeName, key, ttl, api),
+      put: (data) => DB.put(database, storeName, data),
+      remove: (key) => DB.remove(database, storeName, key),
+      clear: () => DB.clear(database, storeName),
+    };
+  }
+
+  return store;
+};

package/package.json

@@ -1,35 +1,35 @@
 {
   "name": "universe-code",
-  "version": "0.0.60",
+  "version": "0.0.62",
   "description": "Universal utility functions for all JS frameworks",
   "license": "ISC",
   "type": "module",
-  "main": "./dist/index.ts",
-  "module": "./dist/index.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/indexdb/index.ts",
+      "import": "./dist/indexdb/index.js",
       "types": "./dist/index.d.ts"
     },
     "./react": {
-      "import": "./dist/react/index.ts",
+      "import": "./dist/react/index.js",
       "types": "./dist/index.d.ts"
     },
     "./angular": {
-      "import": "./dist/angular/index.ts",
+      "import": "./dist/angular/index.js",
       "types": "./dist/index.d.ts"
     },
     "./indexdb": {
-      "import": "./dist/indexdb/index.ts",
+      "import": "./dist/indexdb/index.js",
       "types": "./dist/index.d.ts"
     },
     "./socket": {
-      "import": "./dist/socket/index.ts",
+      "import": "./dist/socket/index.js",
       "types": "./dist/index.d.ts"
     },
     "./core": {
-      "import": "./dist/core/index.ts",
+      "import": "./dist/core/index.js",
       "types": "./dist/index.d.ts"
     }
   },
@@ -50,8 +50,5 @@
   "dependencies": {
     "@angular/core": "^21.0.6",
     "react": "^19.2.3"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.7"
   }
 }

package/dist/angular/index.ts

@@ -1,9 +0,0 @@
-import { idbService } from './services/idbService';
-
-// Export everything as a unified object or individual pieces
-export { idbService };
-
-// Default export for easy usage
-export default {
-    idbService,
-};

package/dist/core/index.ts

@@ -1 +0,0 @@
-export * from './time.ts';

package/dist/index.ts

@@ -1,6 +0,0 @@
-// index.ts
-import * as indexdb from "./indexdb/index.ts";
-
-export default {
-  ...indexdb,
-};

package/dist/indexdb/store.ts

@@ -1,78 +0,0 @@
-/**
- * Generic Transaction Wrapper
- */
-const perform = (
-  db: any,
-  storeName: any,
-  mode: any,
-  action: any
-): Promise<any> => {
-  return new Promise((resolve, reject) => {
-    const tx: any = db.transaction(storeName, mode);
-    const store: any = tx.objectStore(storeName);
-    const request: any = action(store);
-
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-};
-
-export const DB: any = {
-  get: (db: any, store: any, key: any) =>
-    perform(db, store, "readonly", (s: any) => s.get(key)),
-
-  put: (db: any, store: any, data: any) =>
-    perform(db, store, "readwrite", (s: any) => s.put(data)),
-
-  remove: (db: any, store: any, key: any) =>
-    perform(db, store, "readwrite", (s: any) => s.delete(key)),
-
-  clear: (db: any, store: any) =>
-    perform(db, store, "readwrite", (s: any) => s.clear()),
-
-  /**
-   * PRO FEATURE: getWithExpiry
-   * Automatically refreshes data from an API if the local version is too old.
-   */
-  async getWithExpiry(
-    db: any,
-    storeName: any,
-    key: any,
-    ttl: any,
-    apiCall: any
-  ): Promise<any> {
-    try {
-      const cached: any = await this.get(db, storeName, key);
-      const now: any = Date.now();
-
-      // If valid data exists and is NOT expired, return it
-      if (
-        cached &&
-        cached.timestamp &&
-        now - cached.timestamp < ttl
-      ) {
-        return cached.data;
-      }
-
-      // Otherwise, call API
-      const freshData: any = await apiCall();
-
-      // Save to IndexedDB with new timestamp
-      await this.put(db, storeName, {
-        id: key,
-        data: freshData,
-        timestamp: now,
-      });
-
-      return freshData;
-    } catch (error: any) {
-      console.warn(
-        "API/DB Error, returning fallback if available:",
-        error
-      );
-
-      const fallback: any = await this.get(db, storeName, key);
-      return fallback ? fallback.data : null;
-    }
-  },
-};

package/dist/react/indexdb/store/idbStore.ts

@@ -1,39 +0,0 @@
-import { DBManager, DB } from "universe-code";
-import { getConfig } from "./config.ts";
-
-let db: any = null;
-let store: any = null;
-let manager: any = null;
-
-// ✅ index db connection
-const connectDB = async (): Promise<any> => {
-  const { dbName, dbVersion, storeName }: any = getConfig();
-
-  if (!manager) {
-    manager = new DBManager(dbName, dbVersion);
-  }
-
-  if (!db) {
-    db = await manager.connect([{ name: storeName }]);
-  }
-
-  return db;
-};
-
-export const getIdbStore = async (): Promise<any> => {
-  if (!store) {
-    const { storeName }: any = getConfig();
-    const database: any = await connectDB();
-
-    store = {
-      get: (key: any) => DB.get(database, storeName, key),
-      getWithExpiry: (key: any, ttl: any, api: any) =>
-        DB.getWithExpiry(database, storeName, key, ttl, api),
-      put: (data: any) => DB.put(database, storeName, data),
-      remove: (key: any) => DB.remove(database, storeName, key),
-      clear: () => DB.clear(database, storeName),
-    };
-  }
-
-  return store;
-};