@majikah/majik-universal-id-client 0.0.1

package/dist/core/utils/idb-majik-system.d.ts

@@ -0,0 +1,15 @@
+import { type IDBPDatabase } from "idb";
+export interface MajikIDBSaveData {
+    id: string;
+    data: Blob;
+    savedAt: number;
+}
+interface MajikAutosaveSchema {
+    majikdata: MajikIDBSaveData;
+}
+export declare function initDB(name?: string): Promise<IDBPDatabase<MajikAutosaveSchema>>;
+export declare function idbSaveBlob(id: string, data: Blob, name?: string): Promise<void>;
+export declare function idbLoadBlob(id: string, name?: string): Promise<MajikIDBSaveData | undefined>;
+export declare function deleteBlob(id: string, name?: string): Promise<void>;
+export declare function clearAllBlobs(name?: string): Promise<void>;
+export {};

package/dist/core/utils/idb-majik-system.js

@@ -0,0 +1,44 @@
+// lib/indexedDB.ts
+import { openDB } from "idb";
+let dbPromise;
+export function initDB(name = "default") {
+    if (!dbPromise) {
+        const dbName = `MajikAutosaveDB_${name}`;
+        dbPromise = openDB(dbName, 1, {
+            upgrade(db) {
+                if (!db.objectStoreNames.contains("majikdata")) {
+                    db.createObjectStore("majikdata", { keyPath: "id" });
+                }
+            },
+        });
+    }
+    return dbPromise;
+}
+export async function idbSaveBlob(id, data, name = "default") {
+    const db = await initDB(name);
+    await db.put("majikdata", { id, data, savedAt: Date.now() });
+}
+export async function idbLoadBlob(id, name = "default") {
+    try {
+        const db = await initDB(name);
+        return await db.get("majikdata", id);
+    }
+    catch (err) {
+        console.error(`Failed to load blob with id "${id}":`, err);
+        return undefined;
+    }
+}
+export async function deleteBlob(id, name = "default") {
+    try {
+        const db = await initDB(name);
+        return db.delete("majikdata", id);
+    }
+    catch (err) {
+        console.error(`Failed to delete blob with id "${id}":`, err);
+        return undefined;
+    }
+}
+export async function clearAllBlobs(name = "default") {
+    const db = await initDB(name);
+    return db.clear("majikdata");
+}

package/dist/core/utils/majik-file-utils.d.ts

@@ -0,0 +1,16 @@
+interface MajikFileData {
+    /** JSON object */
+    j: unknown;
+    /** STX Timestamp */
+    s: string;
+    /** Version */
+    v: string;
+}
+export declare function importMajikFileData(file: File): Promise<MajikFileData>;
+export declare function loadSavedMajikFileData(file: Blob): Promise<MajikFileData>;
+export declare function autoSaveMajikFileData(json: unknown, version?: string): Blob;
+export declare function exportMajikFileData(json: unknown, name: string, version?: string): void;
+export declare function prepareToBlobFile(data: string): Blob;
+export declare function base64EncodeUtf8(str: string): string;
+export declare function base64DecodeUtf8(base64: string): string;
+export {};

package/dist/core/utils/majik-file-utils.js

@@ -0,0 +1,153 @@
+import APITranscoder from "./APITranscoder";
+export async function importMajikFileData(file) {
+    if (!file)
+        throw new Error("Invalid file.");
+    if (!file.name.endsWith(".mjkb")) {
+        throw new Error("Oops! Only .mjkb files are allowed. Please load a valid MajikFile.");
+    }
+    try {
+        // Step 1: Read as base64 text
+        const base64String = (await readBlobFile(file));
+        // Step 2: base64 → JSON
+        const jsonString = base64DecodeUtf8(base64String);
+        const parsedData = JSON.parse(jsonString);
+        // Step 3: Decrypt
+        const decryptedData = APITranscoder.decryptPayload(parsedData);
+        return decryptedData;
+    }
+    catch (error) {
+        console.error("Import Error:", error);
+        throw new Error("Failed to import and decrypt .mjkb file.");
+    }
+}
+export async function loadSavedMajikFileData(file) {
+    try {
+        const content = await readBlobFile(file);
+        // Step 2: base64 → UTF-8 JSON string
+        const jsonString = base64DecodeUtf8(content);
+        // Step 3: Parse encrypted payload
+        const parsedData = JSON.parse(jsonString);
+        const decryptedData = APITranscoder.decryptPayload(parsedData);
+        const MajikFileData = decryptedData;
+        return MajikFileData;
+    }
+    catch (error) {
+        console.error("Loading Autosaved File Error: ", error);
+        throw new Error("Failed to load autosaved .MajikFile file.");
+    }
+}
+export function autoSaveMajikFileData(json, version = "1.0.0") {
+    const rawData = {
+        j: json,
+        s: secureTimecode(),
+        v: version,
+    };
+    const generatedRQC = APITranscoder.generateRQC();
+    const encryptedData = APITranscoder.encryptPayload(rawData, generatedRQC);
+    const dataString = JSON.stringify(encryptedData);
+    // 🔐 Convert JSON string to base64
+    const base64Encoded = base64EncodeUtf8(dataString);
+    const blobData = prepareToBlobFile(base64Encoded);
+    return blobData;
+}
+export function exportMajikFileData(json, name, version = "1.0.0") {
+    const rawData = {
+        j: json,
+        s: secureTimecode(),
+        v: version,
+    };
+    const generatedRQC = APITranscoder.generateRQC();
+    const encryptedData = APITranscoder.encryptPayload(rawData, generatedRQC);
+    const dataString = JSON.stringify(encryptedData);
+    // 🔐 Convert JSON string to base64
+    const base64Encoded = base64EncodeUtf8(dataString);
+    const blobData = prepareToBlobFile(base64Encoded);
+    downloadBlob(blobData, "MajikFile", name);
+}
+// Prepare Blob file from various input types
+export function prepareToBlobFile(data) {
+    return new Blob([data], { type: "text/plain" });
+}
+// Download Blob file
+function downloadBlob(blob, filetype, fileName) {
+    const file = new File([blob], `${fileName}.${filetype}`, { type: blob.type });
+    const tryShare = async () => {
+        if (typeof navigator !== "undefined" &&
+            navigator.canShare &&
+            navigator.canShare({ files: [file] })) {
+            try {
+                await navigator.share({
+                    files: [file],
+                    title: fileName,
+                    text: `Download ${fileName}.${filetype}`,
+                });
+                return;
+            }
+            catch (error) {
+                console.warn("Share not supported in desktop:", error);
+                // Fallback continues
+            }
+        }
+        // Fallback to download
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = `${fileName}.${filetype}`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    };
+    // Ensure it's wrapped in a user-triggered event like a button click
+    void tryShare();
+}
+// Read Blob file and decode its content
+function readBlobFile(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(new Error("Error reading file"));
+        reader.readAsText(blob);
+    });
+}
+/**
+ * Converts a Unix timestamp, Date object, ISO string, or null/undefined into a secure Base64 string.
+ * Defaults to the current time if input is null or undefined.
+ *
+ * @param {(number | Date | string | null | undefined)} input - The time input.
+ * @returns {string} A secure Base64 encoded string generated from the timestamp.
+ * @throws {Error} Throws an error if the input is not a valid time format.
+ */
+function secureTimecode(input) {
+    const unixTimestamp = (() => {
+        if (input === null || input === undefined)
+            return Math.floor(Date.now() / 1000);
+        if (typeof input === "number")
+            return input;
+        if (input instanceof Date)
+            return Math.floor(input.getTime() / 1000);
+        if (typeof input === "string")
+            return Math.floor(new Date(input).getTime() / 1000);
+        throw new Error("Invalid input type. Must be Unix timestamp, Date object, or ISO string.");
+    })();
+    const unixArray = Array.from(String(unixTimestamp), Number);
+    const reversedArray = [...unixArray].reverse();
+    const invertedArray = [];
+    for (let i = 0; i < unixArray.length; i++) {
+        invertedArray.push(unixArray[i], reversedArray[i]);
+    }
+    return btoa(String.fromCharCode(...invertedArray));
+}
+export function base64EncodeUtf8(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = "";
+    bytes.forEach((b) => {
+        binary += String.fromCharCode(b);
+    });
+    return btoa(binary);
+}
+export function base64DecodeUtf8(base64) {
+    const binary = atob(base64);
+    const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}

package/dist/core/utils/utilities.d.ts

@@ -0,0 +1,18 @@
+import { MnemonicJSON } from "@majikah/majik-key";
+export declare function arrayToBase64(data: Uint8Array): string;
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+export declare function base64ToUtf8(base64: string): string;
+export declare function utf8ToBase64(str: string): string;
+export declare function concatArrayBuffers(a: ArrayBuffer, b: ArrayBuffer): ArrayBuffer;
+export declare function concatUint8Arrays(a: Uint8Array, b: Uint8Array): Uint8Array;
+/**
+ * Converts a space-separated seed phrase string into MnemonicJSON
+ */
+export declare function seedToJSON(seed: string, id: string, phrase?: string): MnemonicJSON;
+/**
+ * Converts MnemonicJSON into a single space-separated string
+ */
+export declare function jsonToSeed(json: MnemonicJSON): string;
+export declare function seedStringToArray(seed: string): string[];

package/dist/core/utils/utilities.js

@@ -0,0 +1,80 @@
+/* ================================
+ * Utilities
+ * ================================ */
+// utils/utilities.ts
+export function arrayToBase64(data) {
+    let binary = "";
+    const bytes = data;
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function base64ToUint8Array(base64) {
+    return new Uint8Array(base64ToArrayBuffer(base64));
+}
+export function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+}
+export function base64ToArrayBuffer(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.buffer;
+}
+export function base64ToUtf8(base64) {
+    const buf = base64ToArrayBuffer(base64);
+    return new TextDecoder().decode(new Uint8Array(buf));
+}
+export function utf8ToBase64(str) {
+    const bytes = new TextEncoder().encode(str);
+    return arrayBufferToBase64(bytes.buffer);
+}
+export function concatArrayBuffers(a, b) {
+    const tmp = new Uint8Array(a.byteLength + b.byteLength);
+    tmp.set(new Uint8Array(a), 0);
+    tmp.set(new Uint8Array(b), a.byteLength);
+    return tmp.buffer;
+}
+export function concatUint8Arrays(a, b) {
+    const out = new Uint8Array(a.byteLength + b.byteLength);
+    out.set(a, 0);
+    out.set(b, a.byteLength);
+    return out;
+}
+/**
+ * Converts a space-separated seed phrase string into MnemonicJSON
+ */
+export function seedToJSON(seed, id, phrase) {
+    return {
+        seed: seed
+            .trim()
+            .split(/\s+/)
+            .map((w) => w.toLowerCase())
+            .filter(Boolean),
+        id,
+        phrase,
+    };
+}
+/**
+ * Converts MnemonicJSON into a single space-separated string
+ */
+export function jsonToSeed(json) {
+    return json.seed.join(" ");
+}
+export function seedStringToArray(seed) {
+    return seed
+        .trim()
+        .split(/\s+/)
+        .map((w) => w.toLowerCase())
+        .filter(Boolean);
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./majik-universal-id-client";
+export type * from "./core/types";
+export * from "./core/contacts/majik-contact";
+export * from "./core/contacts/majik-contact-directory";
+export * from "./core/crypto/constants";
+export * from "./core/crypto/keystore";
+export * from "./core/utils/APITranscoder";
+export * from "./core/utils/utilities";
+export * from "./core/identity";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./majik-universal-id-client";
+export * from "./core/contacts/majik-contact";
+export * from "./core/contacts/majik-contact-directory";
+export * from "./core/crypto/constants";
+export * from "./core/crypto/keystore";
+export * from "./core/utils/APITranscoder";
+export * from "./core/utils/utilities";
+export * from "./core/identity";