universe-code 0.0.89 → 0.0.91

package/dist/angular/encryption/index.js

@@ -0,0 +1,148 @@
+class EncryptionService {
+    constructor() {
+        this.PASS =
+            "9f2d3b7c4a6e8f0b-1c2d3e4f5a6b7c8d-9e0f1a2b3c4d5e6f7-a8b9c0d1e2f3a4";
+    }
+
+    // --- Encoding helpers ---
+    enc(str) {
+        return new TextEncoder().encode(str);
+    }
+
+    dec(buf) {
+        return new TextDecoder().decode(buf);
+    }
+
+    // --- Base64 helpers (React + Angular safe) ---
+    b64(a) {
+        const bytes = new Uint8Array(a);
+        let binary = "";
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+
+    ub64(s) {
+        const binaryStr = atob(s);
+        const bytes = new Uint8Array(binaryStr.length);
+        for (let i = 0; i < binaryStr.length; i++) {
+            bytes[i] = binaryStr.charCodeAt(i);
+        }
+        return bytes;
+    }
+
+    // --- Key methods ---
+    async getKey() {
+        const km = await crypto.subtle.importKey(
+            "raw",
+            this.enc(this.PASS),
+            "PBKDF2",
+            false,
+            ["deriveKey"]
+        );
+
+        return crypto.subtle.deriveKey(
+            {
+                name: "PBKDF2",
+                salt: this.enc("fixed-salt"),
+                iterations: 100000,
+                hash: "SHA-256"
+            },
+            km,
+            { name: "AES-GCM", length: 256 },
+            false,
+            ["encrypt", "decrypt"]
+        );
+    }
+
+    async key1() {
+        const km = await crypto.subtle.importKey(
+            "raw",
+            this.enc(this.PASS),
+            "PBKDF2",
+            false,
+            ["deriveKey"]
+        );
+
+        return crypto.subtle.deriveKey(
+            {
+                name: "PBKDF2",
+                salt: this.enc("x"),
+                iterations: 50000,
+                hash: "SHA-256"
+            },
+            km,
+            { name: "AES-GCM", length: 256 },
+            false,
+            ["encrypt", "decrypt"]
+        );
+    }
+
+    // --- Encryption ---
+    async encryption(obj) {
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const key = await this.getKey();
+
+        const ct = await crypto.subtle.encrypt(
+            { name: "AES-GCM", iv },
+            key,
+            this.enc(JSON.stringify(obj))
+        );
+
+        return {
+            iv: this.b64(iv),
+            payload: this.b64(ct)
+        };
+    }
+
+    async encryption1(obj) {
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const key = await this.key1();
+
+        const ct = await crypto.subtle.encrypt(
+            { name: "AES-GCM", iv },
+            key,
+            this.enc(JSON.stringify(obj))
+        );
+
+        return {
+            iv: this.b64(iv),
+            payload: this.b64(ct)
+        };
+    }
+
+    // --- Decryption ---
+    async decryption(data) {
+        const key = await this.getKey();
+
+        const pt = await crypto.subtle.decrypt(
+            { name: "AES-GCM", iv: this.ub64(data.iv) },
+            key,
+            this.ub64(data.payload)
+        );
+
+        return JSON.parse(this.dec(pt));
+    }
+
+    async decryption1(o) {
+        const key = await this.key1();
+
+        const pt = await crypto.subtle.decrypt(
+            { name: "AES-GCM", iv: this.ub64(o.iv) },
+            key,
+            this.ub64(o.payload)
+        );
+
+        return JSON.parse(this.dec(pt));
+    }
+
+    async decrptApiResponse(data) {
+        if (!data.includes("###")) return null;
+        const [iv, payload] = data.split("###");
+        return this.decryption1({ iv, payload });
+    }
+}
+
+// Export / usage
+export const encryptionService = new EncryptionService();

package/dist/angular/index.js

@@ -1,2 +1,3 @@
 export { IdbService } from './indexdb/services/idbService.js';
-export { ColorSparkService, initSpark, singleSpark } from './spark/index.js';
+export { ColorSparkService, initSpark, singleSpark } from './spark/index.js';
+export { encryptionService } from './encryption/index.js';

package/dist/react/encryption/index.js

@@ -0,0 +1,184 @@
+/* ========= UNIVERSAL CRYPTO SERVICE ========= */
+/* Works in Angular, React, Next.js (SSR safe), Browser */
+
+const SECRET_PASS =
+    "9f2d3b7c4a6e8f0b-1c2d3e4f5a6b7c8d-9e0f1a2b3c4d5e6f7-a8b9c0d1e2f3a4";
+
+const PASS = SECRET_PASS;
+
+/* ---------- Helpers ---------- */
+
+const enc = (str) => new TextEncoder().encode(str);
+const dec = (buf) => new TextDecoder().decode(buf);
+
+const hasBuffer = typeof Buffer !== "undefined";
+
+/* Base64 encode (Node + Browser safe) */
+const b64 = (data) => {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+
+    if (hasBuffer) {
+        return Buffer.from(bytes).toString("base64");
+    }
+
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+};
+
+/* Base64 decode (Node + Browser safe) */
+const ub64 = (base64) => {
+    if (hasBuffer) {
+        return new Uint8Array(Buffer.from(base64, "base64"));
+    }
+
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+};
+
+/* WebCrypto subtle (Browser + Node/Next) */
+const subtle = () => {
+    if (typeof window !== "undefined" && window.crypto?.subtle) {
+        return window.crypto.subtle;
+    }
+
+    if (globalThis.crypto?.subtle) {
+        return globalThis.crypto.subtle;
+    }
+
+    throw new Error("WebCrypto API not supported in this environment");
+};
+
+/* Random values (Browser + Node) */
+const randomIV = () => {
+    if (typeof window !== "undefined" && window.crypto) {
+        return window.crypto.getRandomValues(new Uint8Array(12));
+    }
+
+    return globalThis.crypto.getRandomValues(new Uint8Array(12));
+};
+
+/* ---------- Key Derivation ---------- */
+
+async function getKey() {
+    const keyMaterial = await subtle().importKey(
+        "raw",
+        enc(SECRET_PASS),
+        "PBKDF2",
+        false,
+        ["deriveKey"]
+    );
+
+    return subtle().deriveKey(
+        {
+            name: "PBKDF2",
+            salt: enc("fixed-salt"),
+            iterations: 100000,
+            hash: "SHA-256",
+        },
+        keyMaterial,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt", "decrypt"]
+    );
+}
+
+async function key1() {
+    const keyMaterial = await subtle().importKey(
+        "raw",
+        enc(PASS),
+        "PBKDF2",
+        false,
+        ["deriveKey"]
+    );
+
+    return subtle().deriveKey(
+        {
+            name: "PBKDF2",
+            salt: enc("x"),
+            iterations: 50000,
+            hash: "SHA-256",
+        },
+        keyMaterial,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt", "decrypt"]
+    );
+}
+
+/* ---------- Crypto Service ---------- */
+
+export const encryptionService = {
+    /* Encrypt using main key */
+    async encryption(obj) {
+        const iv = randomIV();
+        const key = await getKey();
+
+        const encrypted = await subtle().encrypt(
+            { name: "AES-GCM", iv },
+            key,
+            enc(JSON.stringify(obj))
+        );
+
+        return {
+            iv: b64(iv),
+            payload: b64(encrypted),
+        };
+    },
+
+    /* Decrypt using main key */
+    async decryption(data) {
+        const key = await getKey();
+
+        const decrypted = await subtle().decrypt(
+            { name: "AES-GCM", iv: ub64(data.iv) },
+            key,
+            ub64(data.payload)
+        );
+
+        return JSON.parse(dec(decrypted));
+    },
+
+    /* Encrypt using secondary key */
+    async encryption1(obj) {
+        const iv = randomIV();
+        const key = await key1();
+
+        const encrypted = await subtle().encrypt(
+            { name: "AES-GCM", iv },
+            key,
+            enc(JSON.stringify(obj))
+        );
+
+        return {
+            iv: b64(iv),
+            payload: b64(encrypted),
+        };
+    },
+
+    /* Decrypt using secondary key */
+    async decryption1(data) {
+        const key = await key1();
+
+        const decrypted = await subtle().decrypt(
+            { name: "AES-GCM", iv: ub64(data.iv) },
+            key,
+            ub64(data.payload)
+        );
+
+        return JSON.parse(dec(decrypted));
+    },
+
+    /* API helper */
+    async decryptApiResponse(data) {
+        if (!data || !data.includes("###")) return null;
+        const [iv, payload] = data.split("###");
+        return this.decryption1({ iv, payload });
+    },
+};

package/dist/react/index.js

@@ -2,14 +2,16 @@ import { getIdbStore } from './indexdb/store/idbStore.js';
 import { useIdbStore } from './indexdb/hooks/idbHook.js';
 import { configureIdb } from "./indexdb/store/config.js";
 import { useColorSpark } from "./spark/index.js";
+import { encryptionService } from "./encryption/index.js";
 
 // Export everything as a unified object or individual pieces
-export { configureIdb, getIdbStore, useIdbStore, useColorSpark };
+export { configureIdb, getIdbStore, useIdbStore, useColorSpark, encryptionService };
 
 // Default export for easy usage
 export default {
     configureIdb,
     getIdbStore,
     useIdbStore,
-    useColorSpark
+    useColorSpark,
+    encryptionService
 };

package/dist/uiux/index.js

@@ -1,2 +1,2 @@
 export { UniverseToaster, toaster } from "./toaster";
-export { UniverseDataTable } from "./tables";
+export { UniverseDataTable } from "./table";

package/dist/uiux/{tables → table}/index.js

@@ -56,7 +56,7 @@ style.textContent = `
   display: flex;
   align-items: center;
   gap: 0.3rem;
-  font-size: 10px;
+  font-size: 12px;
   color: #757272;
 }
 
@@ -95,7 +95,7 @@ style.textContent = `
   white-space: nowrap;
   text-align: left;
   color: #4b5563;
-  font-size: var(--entriesTextFontSize, 10px);
+  font-size: var(--entriesTextFontSize, 12px);
 }
 
 /* Pagination buttons */
@@ -331,13 +331,17 @@ class UniverseDataTable {
 
         if (this.shouldShowPagination) {
             const jumpInputs = this.container.querySelectorAll("input.jumpto");
-            jumpInputs.forEach((input) =>
-                input.addEventListener("keypress", (e) => this.handleKeyPress(e))
-            );
+jumpInputs.forEach((input) => {
+  input.addEventListener("input", (e) => {
+    this.jumpToPage = e.target.value;
+  });
+
+  input.addEventListener("keypress", (e) => this.handleKeyPress(e));
+});
 
             const goButtons = this.container.querySelectorAll(".go-btn");
             goButtons.forEach((btn) => {
-                if (!btn.disabled) btn.addEventListener("click", () => this.handleJumpToPage());
+                if (!btn.disabled) btn.addEventListener("click", () => this.handleJumpToPage(this.jumpToPage));
             });
 
             const pgButtons = this.container.querySelectorAll(".pg-btn");

package/package.json

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