universe-code 0.0.57 → 0.0.59

package/dist/angular/services/idbService.ts

@@ -0,0 +1,92 @@
+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;
+
+  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.store = {
+        get: (key: string) =>
+          DB.get(this.db, this.storeName, key),
+
+        getWithExpiry: (
+          key: string,
+          ttl: number,
+          api: () => Promise<any>
+        ) =>
+          DB.getWithExpiry(this.db, this.storeName, key, ttl, api),
+
+        put: (data: any) =>
+          DB.put(this.db, this.storeName, data),
+
+        remove: (key: string) =>
+          DB.remove(this.db, this.storeName, key),
+
+        clear: () =>
+          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);
+  }
+
+  async get(key: string) {
+    const store = await this.getStore();
+    return store.get(key);
+  }
+
+  async set(data: any) {
+    const store = await this.getStore();
+    return store.put(data);
+  }
+
+  async remove(key: string) {
+    const store = await this.getStore();
+    return store.remove(key);
+  }
+
+  async clear() {
+    const store = await this.getStore();
+    return store.clear();
+  }
+}

package/dist/core/index.ts

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

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

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

package/dist/index.ts

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

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

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

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

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

package/dist/indexdb/store.ts

@@ -0,0 +1,78 @@
+/**
+ * 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/{index.js → index.ts}

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+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;
+};

package/package.json

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

package/dist/angular/services/idbService.js

@@ -1,49 +0,0 @@
-import { DBManager, DB } from 'universe-code/indexdb';
-
-export class idbService {
-  constructor() {
-    this.manager = new DBManager('exchange', 1);
-    this.db = null;
-    this.storeName = 'exchangeStore';
-    this.store = null;
-  }
-
-  async getStore() {
-    if (!this.store) {
-      if (!this.db) {
-        this.db = await this.manager.connect([{ name: this.storeName }]);
-      }
-
-      this.store = {
-        get: (key) => DB.get(this.db, this.storeName, key),
-        getWithExpiry: (key, ttl, api) =>
-          DB.getWithExpiry(this.db, this.storeName, key, ttl, api),
-        put: (data) => DB.put(this.db, this.storeName, data),
-        remove: (key) => DB.remove(this.db, this.storeName, key),
-        clear: () => DB.clear(this.db, this.storeName)
-      };
-    }
-    return this.store;
-  }
-
-  async fetchWithCache(key, ttl, apiFn) {
-    const store = await this.getStore();
-    return store.getWithExpiry(key, ttl, apiFn);
-  }
-
-  async get(key) {
-    return (await this.getStore()).get(key);
-  }
-
-  async set(data) {
-    return (await this.getStore()).put(data);
-  }
-
-  async remove(key) {
-    return (await this.getStore()).remove(key);
-  }
-
-  async clear() {
-    return (await this.getStore()).clear();
-  }
-}

package/dist/core/index.js

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

package/dist/index.js

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

package/dist/indexdb/store.js

@@ -1,55 +0,0 @@
-/**
- * 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/indexdb/store/idbStore.js

@@ -1,39 +0,0 @@
-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;
-};