@thezelijah/majik-message 1.0.0 → 1.0.1

package/dist/core/database/system/majik-user/types.d.ts

@@ -0,0 +1,186 @@
+import type { UserGenderOptions } from './enums';
+export type ISODateString = string;
+/**
+ * ISO Date string in YYYY-MM-DD format
+ */
+export type YYYYMMDD = `${number}-${number}-${number}`;
+export type CountryCode = string;
+export type LanguageCode = string;
+export interface Address {
+    /** Country name */
+    country?: string;
+    /** City name */
+    city?: string;
+    /** State or province name */
+    region?: string;
+    /** Barangay or local area */
+    area?: string;
+    /** Street address */
+    street?: string;
+    /** Optional building or suite information */
+    building?: string;
+    /** Optional postal/zip code */
+    zip?: string;
+    /** ISO 3166-1 alpha-2 country code (e.g., 'US', 'PH') */
+    country_code?: CountryCode;
+    /** Geographic coordinates */
+    coordinates?: {
+        /** Latitude in decimal degrees (-90 to 90) */
+        latitude: number;
+        /** Longitude in decimal degrees (-180 to 180) */
+        longitude: number;
+    };
+}
+/**
+ * Stores the user's personal and contact details, including demographics and device information.
+ */
+export interface UserBasicInformation {
+    /** Raw name of the customer */
+    name?: FullName;
+    /** Profile photo URL or path for the User */
+    picture?: string;
+    /** User's phone number for contact or verification */
+    phone?: string;
+    /** User's gender (e.g., 'male', 'female', 'non-binary', etc.) */
+    gender?: UserGenderOptions;
+    /** User's birthdate in ISO 8601 format (YYYY-MM-DD) */
+    birthdate?: YYYYMMDD;
+    /** Default address information */
+    address?: Address;
+    /** User's preferred pronouns */
+    pronouns?: string;
+    /** Short bio or description */
+    bio?: string;
+    /** Preferred language code (ISO 639-1, e.g., 'en', 'es') */
+    language?: string;
+    /** Timezone identifier (e.g., 'Asia/Manila', 'America/New_York') */
+    timezone?: string;
+    /** Verification status flags */
+    verification?: {
+        email_verified: boolean;
+        phone_verified: boolean;
+        identity_verified: boolean;
+    };
+    /** Social media or external profile links */
+    social_links?: Record<string, string>;
+    /** Company/organization affiliation */
+    company?: CompanyInformation;
+}
+/**
+ * Represents a person's full legal or professional name.
+ */
+export interface FullName {
+    /** First or given name of the person */
+    first_name: string;
+    /** Last or family name of the person */
+    last_name: string;
+    /** Optional middle name or initial */
+    middle_name?: string;
+    /** Optional suffix (e.g., Jr., Sr., III) */
+    suffix?: string;
+}
+/**
+ * Basic contact details for a person or organization.
+ */
+export interface ContactInformation {
+    /** Email address, if available */
+    email?: string;
+    /** Phone number, if available */
+    phone?: string;
+    /** Website URL, if applicable */
+    website?: string;
+}
+/**
+ * Information about the company associated with a client.
+ */
+export interface CompanyInformation {
+    /** Name of the company or organization */
+    name: string;
+    /** The role or position of the client within the company (e.g., CEO, Manager) */
+    role: string;
+    /** Contact details for the company or representative */
+    contact: ContactInformation;
+    /** Optional physical or mailing address of the company */
+    address?: string;
+}
+/**
+ * JSON representation of a MajikUser for serialization/deserialization
+ */
+export interface MajikUserJSON<TMetadata extends UserBasicInformation = UserBasicInformation> {
+    id: string;
+    email: string;
+    displayName: string;
+    hash: string;
+    metadata: TMetadata;
+    settings: UserSettings;
+    createdAt: string;
+    lastUpdate: string;
+}
+export interface UserSettings {
+    notifications: boolean;
+    system: {
+        isRestricted: boolean;
+        restrictedUntil?: Date;
+    };
+    [key: string]: unknown;
+}
+interface SupabaseUserAppMetadata {
+    provider?: string;
+    [key: string]: any;
+}
+interface SupabaseUserMetadata {
+    [key: string]: any;
+}
+interface Factor {
+    /** ID of the factor. */
+    id: string;
+    /** Friendly name of the factor, useful to disambiguate between multiple factors. */
+    friendly_name?: string;
+    /**
+     * Type of factor. `totp` and `phone` supported with this version
+     */
+    factor_type: 'totp' | 'phone' | (string & {});
+    /** Factor's status. */
+    status: 'verified' | 'unverified';
+    created_at: string;
+    updated_at: string;
+}
+interface SupabaseUserIdentity {
+    id: string;
+    user_id: string;
+    identity_data?: {
+        [key: string]: any;
+    };
+    identity_id: string;
+    provider: string;
+    created_at?: string;
+    last_sign_in_at?: string;
+    updated_at?: string;
+}
+export interface SupabaseUser {
+    id: string;
+    app_metadata: SupabaseUserAppMetadata;
+    user_metadata: SupabaseUserMetadata;
+    aud: string;
+    confirmation_sent_at?: string;
+    recovery_sent_at?: string;
+    email_change_sent_at?: string;
+    new_email?: string;
+    new_phone?: string;
+    invited_at?: string;
+    action_link?: string;
+    email?: string;
+    phone?: string;
+    created_at: string;
+    confirmed_at?: string;
+    email_confirmed_at?: string;
+    phone_confirmed_at?: string;
+    last_sign_in_at?: string;
+    role?: string;
+    updated_at?: string;
+    identities?: SupabaseUserIdentity[];
+    is_anonymous?: boolean;
+    is_sso_user?: boolean;
+    factors?: Factor[];
+}
+export {};

package/dist/core/database/system/majik-user/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/database/system/majik-user/utils.d.ts

@@ -0,0 +1,32 @@
+import type { YYYYMMDD } from './types';
+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;
+export interface MnemonicJSON {
+    seed: string[];
+    id: string;
+    phrase?: string;
+}
+/**
+ * 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[];
+/**
+ * Convert Date → YYYY-MM-DD (UTC-safe)
+ */
+export declare function dateToYYYYMMDD(date: Date): YYYYMMDD;
+/**
+ * Convert YYYY-MM-DD → Date (UTC midnight)
+ */
+export declare function YYYYMMDDToDate(yyyymmdd: YYYYMMDD): Date;
+export declare function stripUndefined<T extends Record<string, unknown>>(obj: T): Partial<T>;

package/dist/core/database/system/majik-user/utils.js

@@ -0,0 +1,110 @@
+/* ================================
+ * 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 arrayToBase64(bytes);
+}
+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);
+}
+/**
+ * Convert Date → YYYY-MM-DD (UTC-safe)
+ */
+export function dateToYYYYMMDD(date) {
+    if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+        throw new Error('Invalid Date object');
+    }
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    const d = String(date.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+}
+/**
+ * Convert YYYY-MM-DD → Date (UTC midnight)
+ */
+export function YYYYMMDDToDate(yyyymmdd) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(yyyymmdd)) {
+        throw new Error('Invalid ISO date format. Expected YYYY-MM-DD');
+    }
+    const [year, month, day] = yyyymmdd.split('-').map(Number);
+    const date = new Date(year, month - 1, day); // ✅ LOCAL midnight
+    // Validation
+    if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+        throw new Error('Invalid calendar date');
+    }
+    return date;
+}
+export function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}

package/dist/core/database/system/utils.d.ts

@@ -0,0 +1 @@
+export declare function autogenerateID(): string;

package/dist/core/database/system/utils.js

@@ -0,0 +1,8 @@
+import { customAlphabet } from "nanoid";
+export function autogenerateID() {
+    // Create the generator function ONCE with your custom alphabet and length
+    const generateID = customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 16);
+    // Call the generator function to produce the actual ID string
+    const genUID = generateID(); // Example output: 'G7K2aZp9'
+    return genUID;
+}

package/dist/core/types.d.ts

@@ -1,4 +1,7 @@
 export type ISODateString = string;
+export type MajikMessageAccountID = string;
+export type MajikMessagePublicKey = string;
+export type MajikMessageChatID = string;
 export interface MAJIK_API_RESPONSE {
     success: boolean;
     message: string;

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

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

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

@@ -20,3 +20,10 @@ export declare function seedToJSON(seed: string, id: string, phrase?: string): M
  */
 export declare function jsonToSeed(json: MnemonicJSON): string;
 export declare function seedStringToArray(seed: string): string[];
+/**
+ * Generates a unique, URL-safe ID for an item based on its name and current timestamp.
+ *
+ * @param prefix - The prefix string name to add.
+ * @returns A unique ID string prefixed.
+ */
+export declare function autogenerateID(prefix?: string): string;

package/dist/core/utils/utilities.js

@@ -1,6 +1,7 @@
 /* ================================
  * Utilities
  * ================================ */
+import { customAlphabet } from "nanoid";
 // utils/utilities.ts
 export function arrayToBase64(data) {
     let binary = "";
@@ -78,3 +79,16 @@ export function seedStringToArray(seed) {
         .map((w) => w.toLowerCase())
         .filter(Boolean);
 }
+/**
+ * Generates a unique, URL-safe ID for an item based on its name and current timestamp.
+ *
+ * @param prefix - The prefix string name to add.
+ * @returns A unique ID string prefixed.
+ */
+export function autogenerateID(prefix = "mjkmsg") {
+    // Create the generator function ONCE with your custom alphabet and length
+    const generateID = customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 8);
+    // Call the generator function to produce the actual ID string
+    const genUID = generateID(); // Example output: 'G7K2aZp9'
+    return `${prefix}-${genUID}`;
+}

package/dist/majik-message.d.ts

@@ -4,6 +4,8 @@ import { EnvelopeCache, type EnvelopeCacheItem, type EnvelopeCacheJSON } from ".
 import { KeyStore } from "./core/crypto/keystore";
 import { MajikContactDirectory, type MajikContactDirectoryData } from "./core/contacts/majik-contact-directory";
 import type { MAJIK_API_RESPONSE } from "./core/types";
+import { MajikMessageChat } from "./core/database/chat/majik-message-chat";
+import { MajikMessageIdentity } from "./core/database/system/identity";
 type MajikMessageEvents = "message" | "envelope" | "untrusted" | "error";
 export interface MajikMessageConfig {
     keyStore: KeyStore;
@@ -142,6 +144,22 @@ export declare class MajikMessage {
      */
     encryptGroupMessage(recipientIds: string[], plaintext: string, cache?: boolean): Promise<MessageEnvelope>;
     sendMessage(recipients: string[], plaintext: string): Promise<MessageEnvelope>;
+    /**
+     * Create a new MajikMessageChat with compression, then encrypt it.
+     * Returns the scanner-ready string containing the encrypted compressed message.
+     *
+     * Flow: Plaintext → Compress (MajikMessageChat) → Encrypt (EncryptionEngine) → Scanner String
+     */
+    createEncryptedMajikMessageChat(account: MajikMessageIdentity, recipients: string[], plaintext: string, expiresInMs?: number): Promise<{
+        messageChat: MajikMessageChat;
+        scannerString: string;
+    }>;
+    /**
+     * Decrypt and decompress a MajikMessageChat message.
+     *
+     * Flow: Encrypted Payload → Decrypt (EncryptionEngine) → Decompress (MajikCompressor) → Plaintext
+     */
+    decryptMajikMessageChat(encryptedPayload: string, recipientId?: string): Promise<string>;
     /**
      * Encrypts currently selected text in the browser DOM for given recipients.
      * If `recipients` is empty, defaults to the first own account.

package/dist/majik-message.js

@@ -11,6 +11,8 @@ import { arrayBufferToBase64, arrayToBase64, base64ToArrayBuffer, base64ToUtf8,
 import { autoSaveMajikFileData, loadSavedMajikFileData, } from "./core/utils/majik-file-utils";
 import { randomBytes } from "@stablelib/random";
 import { idbLoadBlob, idbSaveBlob } from "./core/utils/idb-majik-system";
+import { MajikMessageChat } from "./core/database/chat/majik-message-chat";
+import { MajikCompressor } from "./core/compressor/majik-compressor";
 export class MajikMessage {
     // Optional PIN protection (hashed). If set, UI should prompt for PIN to unlock.
     pinHash = null;
@@ -517,6 +519,105 @@ export class MajikMessage {
     /* ================================
      * High-Level DOM Wrapper
      * ================================ */
+    /**
+     * Create a new MajikMessageChat with compression, then encrypt it.
+     * Returns the scanner-ready string containing the encrypted compressed message.
+     *
+     * Flow: Plaintext → Compress (MajikMessageChat) → Encrypt (EncryptionEngine) → Scanner String
+     */
+    async createEncryptedMajikMessageChat(account, recipients, plaintext, expiresInMs) {
+        if (!plaintext?.trim()) {
+            throw new Error("No text provided to encrypt.");
+        }
+        if (!recipients || recipients.length === 0) {
+            const firstOwn = this.listOwnAccounts()[0];
+            if (!firstOwn) {
+                throw new Error("No own account available for encryption.");
+            }
+            recipients = [firstOwn.id];
+        }
+        if (!account) {
+            throw new Error("No active account available to send message");
+        }
+        try {
+            // Step 1: Create MajikMessageChat (compresses plaintext)
+            const messageChat = await MajikMessageChat.create(account, plaintext, recipients, expiresInMs);
+            // Step 2: Get compressed message for encryption
+            const compressedMessage = messageChat.getCompressedMessage();
+            // Step 3: Encrypt the compressed message using EncryptionEngine
+            let encryptedPayload;
+            if (recipients.length === 1) {
+                // Solo encryption
+                const contact = this.contactDirectory.getContact(recipients[0]);
+                if (!contact) {
+                    throw new Error(`No contact found for recipient: ${recipients[0]}`);
+                }
+                encryptedPayload = await EncryptionEngine.encryptSoloMessage(compressedMessage, contact.publicKey);
+            }
+            else {
+                // Group encryption
+                const recipientData = recipients.map((id) => {
+                    const contact = this.contactDirectory.getContact(id);
+                    if (!contact) {
+                        throw new Error(`No contact found for recipient: ${id}`);
+                    }
+                    return {
+                        id: contact.id,
+                        publicKey: contact.publicKey,
+                    };
+                });
+                encryptedPayload = await EncryptionEngine.encryptGroupMessage(compressedMessage, recipientData);
+            }
+            // Step 4: Convert encrypted payload to base64 string
+            const payloadJSON = JSON.stringify(encryptedPayload);
+            const payloadBase64 = utf8ToBase64(payloadJSON);
+            // Step 5: Create scanner string with MAJIK prefix
+            const scannerString = `${MessageEnvelope.PREFIX}:${payloadBase64}`;
+            // Step 6: Update the messageChat with encrypted payload for storage
+            messageChat.setMessage(payloadJSON); // Store encrypted version
+            return { messageChat, scannerString };
+        }
+        catch (err) {
+            this.emit("error", err, { context: "createEncryptedMajikMessageChat" });
+            throw err;
+        }
+    }
+    /**
+     * Decrypt and decompress a MajikMessageChat message.
+     *
+     * Flow: Encrypted Payload → Decrypt (EncryptionEngine) → Decompress (MajikCompressor) → Plaintext
+     */
+    async decryptMajikMessageChat(encryptedPayload, recipientId) {
+        const recipient = recipientId
+            ? this.getOwnAccountById(recipientId)
+            : this.getActiveAccount();
+        if (!recipient) {
+            throw new Error("No recipient account found for decryption");
+        }
+        try {
+            // Step 1: Ensure identity is unlocked
+            const privateKey = await this.ensureIdentityUnlocked(recipient.id);
+            // Step 2: Parse the encrypted payload
+            const payload = JSON.parse(encryptedPayload);
+            // Step 3: Decrypt using EncryptionEngine
+            let decryptedCompressed;
+            if (payload.keys) {
+                // Group message
+                decryptedCompressed = await EncryptionEngine.decryptGroupMessage(payload, privateKey, recipient.fingerprint);
+            }
+            else {
+                // Solo message
+                decryptedCompressed = await EncryptionEngine.decryptSoloMessage(payload, privateKey);
+            }
+            // Step 4: Decompress the message
+            const plaintext = await MajikCompressor.decompressString(decryptedCompressed);
+            return plaintext;
+        }
+        catch (err) {
+            this.emit("error", err, { context: "decryptMajikMessageChat" });
+            throw err;
+        }
+    }
     /**
      * Encrypts currently selected text in the browser DOM for given recipients.
      * If `recipients` is empty, defaults to the first own account.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@thezelijah/majik-message",
   "type": "module",
   "description": "Encrypt and decrypt messages on any website. Secure chats with keypairs and seed-based accounts. Open source.",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "Apache-2.0",
   "author": "Zelijah",
   "main": "./dist/index.js",
@@ -75,6 +75,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@bokuweb/zstd-wasm": "^0.0.27",
     "@scure/bip39": "^1.6.0",
     "@stablelib/aes": "^2.0.1",
     "@stablelib/ed25519": "^2.0.2",