@abelionorg/core 3.5.0

package/src/Brankas.ts

@@ -0,0 +1,322 @@
+import { argon2id } from '@noble/hashes/argon2.js';
+
+/**
+ * Brankas Engine: Web Crypto API & Argon2id implementation
+ * Standards: AES-GCM 256-bit, Argon2id (Pure JS)
+ *
+ * Version 3.4.0 Updates:
+ * - Added Quantum-Resistant Portable Backup Format
+ * - High-Memory Cost KDF for Backups
+ */
+
+/**
+ * Hasil: Standar pengembalian data untuk operasi Brankas.
+ * Mencegah manipulasi error yang tidak terduga (crash).
+ */
+export type Hasil<T> = { data: T; error: null } | { data: null; error: Error };
+
+const ALGO_ENC = 'AES-GCM';
+const MAX_CACHE_ITEMS = 100;
+
+export class Brankas {
+    private static key: CryptoKey | null = null;
+
+    /**
+     * Cache for decrypted strings to improve performance on repeated reads.
+     * Cleared whenever the vault is locked or key changes.
+     */
+    private static decryptionCache = new Map<string, string>();
+
+    /**
+     * @param extractable Apakah kunci dapat diekspor (diperlukan untuk backup)
+     */
+    static async deriveKey(password: string, salt: Uint8Array, extractable = false): Promise<Hasil<CryptoKey>> {
+        const passwordBuffer = new TextEncoder().encode(password);
+        let hash: Uint8Array | null = null;
+
+        try {
+            hash = argon2id(passwordBuffer, salt, {
+                t: 2,
+                m: 19 * 1024,
+                dkLen: 32,
+                p: 1,
+            });
+
+            const key = await crypto.subtle.importKey(
+                'raw',
+                hash as BufferSource,
+                { name: ALGO_ENC, length: 256 },
+                extractable,
+                ['encrypt', 'decrypt']
+            );
+            return { data: key, error: null };
+        } catch (error) {
+            console.error('[BRANKAS] Gagal menurunkan kunci (ERR_DRV_001)');
+            return { data: null, error: error instanceof Error ? error : new Error(String(error)) };
+        } finally {
+            passwordBuffer.fill(0);
+            if (hash) {
+                hash.fill(0);
+            }
+        }
+    }
+
+    /**
+     * Generates a random 256-bit AES-GCM master key.
+     */
+    static async generateMasterKey(): Promise<Hasil<CryptoKey>> {
+        try {
+            const key = await crypto.subtle.generateKey(
+                { name: ALGO_ENC, length: 256 },
+                true,
+                ['encrypt', 'decrypt']
+            );
+            return { data: key, error: null };
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    /**
+     * Imports a key from raw bytes.
+     */
+    static async importRawKey(keyBuffer: ArrayBuffer, extractable = true): Promise<Hasil<CryptoKey>> {
+        try {
+            const key = await crypto.subtle.importKey(
+                'raw',
+                keyBuffer,
+                { name: ALGO_ENC, length: 256 },
+                extractable,
+                ['encrypt', 'decrypt']
+            );
+            return { data: key, error: null };
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    /**
+     * Exports a key to raw bytes.
+     */
+    static async exportRawKey(key: CryptoKey): Promise<Hasil<ArrayBuffer>> {
+        try {
+            const buffer = await crypto.subtle.exportKey('raw', key);
+            return { data: buffer, error: null };
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    static setActiveKey(key: CryptoKey) {
+        this.key = key;
+        this.decryptionCache.clear();
+    }
+
+    static clearKey() {
+        this.key = null;
+        this.decryptionCache.clear();
+    }
+
+    static isLocked(): boolean {
+        return this.key === null;
+    }
+
+    static getActiveKey(): CryptoKey | null {
+        return this.key;
+    }
+
+    /**
+     * Mengenkripsi teks string
+     */
+    static async encrypt(text: string, customKey?: CryptoKey): Promise<Hasil<{ data: ArrayBuffer; iv: Uint8Array }>> {
+        const key = customKey || this.key;
+        if (!key) return { data: null, error: new Error('Brankas Terkunci: Kunci tidak aktif') };
+
+        try {
+            const iv = crypto.getRandomValues(new Uint8Array(12));
+            const encoder = new TextEncoder();
+
+            const data = await crypto.subtle.encrypt(
+                { name: ALGO_ENC, iv },
+                key,
+                encoder.encode(text)
+            );
+
+            return { data: { data, iv }, error: null };
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    /**
+     * Mendekripsi ArrayBuffer kembali ke string
+     */
+    static async decrypt(encryptedData: ArrayBuffer, iv: Uint8Array, customKey?: CryptoKey): Promise<Hasil<string>> {
+        const key = customKey || this.key;
+        if (!key) return { data: null, error: new Error('Brankas Terkunci: Kunci tidak aktif') };
+
+        try {
+            const decrypted = await crypto.subtle.decrypt(
+                { name: ALGO_ENC, iv: iv as BufferSource },
+                key,
+                encryptedData
+            );
+
+            const decoder = new TextDecoder();
+            return { data: decoder.decode(decrypted), error: null };
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    static async encryptPacked(text: string, customKey?: CryptoKey): Promise<Hasil<string>> {
+        const result = await this.encrypt(text, customKey);
+        if (result.error) return { data: null, error: result.error };
+
+        const { data, iv } = result.data;
+        const ivHex = Array.from(iv).map(b => b.toString(16).padStart(2, '0')).join('');
+        const base64 = btoa(String.fromCharCode(...new Uint8Array(data)));
+        return { data: `${ivHex}|${base64}`, error: null };
+    }
+
+    /**
+     * Optimized hex string to Uint8Array conversion without regex.
+     */
+    private static hexToBytes(hex: string): Uint8Array {
+        const bytes = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+
+    static async decryptPacked(packed: string, customKey?: CryptoKey): Promise<Hasil<string>> {
+        if (!packed || !packed.includes('|')) return { data: packed, error: null };
+
+        if (!customKey && this.decryptionCache.has(packed)) {
+            const cachedResult = this.decryptionCache.get(packed)!;
+            this.decryptionCache.delete(packed);
+            this.decryptionCache.set(packed, cachedResult);
+            return { data: cachedResult, error: null };
+        }
+
+        try {
+            const [ivHex, base64] = packed.split('|');
+            const iv = this.hexToBytes(ivHex);
+
+            const binaryString = atob(base64);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+
+            const result = await this.decrypt(bytes.buffer, iv, customKey);
+            if (result.error) return result;
+
+            if (!customKey) {
+                if (this.decryptionCache.size >= MAX_CACHE_ITEMS) {
+                    const firstKey = this.decryptionCache.keys().next().value;
+                    if (firstKey !== undefined) {
+                        this.decryptionCache.delete(firstKey);
+                    }
+                }
+                this.decryptionCache.set(packed, result.data);
+            }
+
+            return result;
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    /**
+     * Enkripsi Portabel (Quantum-Resistant Symmetric Structure)
+     * Format: [Magic:4][Ver:1][Salt:32][IV:12][Ciphertext:N]
+     */
+    static async encryptPortable(data: string, password: string): Promise<Hasil<Uint8Array>> {
+        try {
+            const salt = crypto.getRandomValues(new Uint8Array(32));
+            const iv = crypto.getRandomValues(new Uint8Array(12));
+
+            const hash = argon2id(password, salt, {
+                t: 4,
+                m: 64 * 1024,
+                dkLen: 32,
+                p: 1
+            });
+
+            const key = await crypto.subtle.importKey(
+                'raw',
+                hash as BufferSource,
+                { name: ALGO_ENC, length: 256 },
+                false,
+                ['encrypt']
+            );
+
+            const encoder = new TextEncoder();
+            const encryptedBuffer = await crypto.subtle.encrypt(
+                { name: 'AES-GCM', iv },
+                key,
+                encoder.encode(data)
+            );
+
+            const magic = new Uint8Array([0x4C, 0x4D, 0x42, 0x52]);
+            const version = new Uint8Array([0x01]);
+
+            const result = new Uint8Array(
+                magic.length + version.length + salt.length + iv.length + encryptedBuffer.byteLength
+            );
+
+            let offset = 0;
+            result.set(magic, offset); offset += magic.length;
+            result.set(version, offset); offset += version.length;
+            result.set(salt, offset); offset += salt.length;
+            result.set(iv, offset); offset += iv.length;
+            result.set(new Uint8Array(encryptedBuffer), offset);
+
+            return { data: result, error: null };
+        } catch (e) {
+            return { data: null, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+    }
+
+    static async decryptPortable(buffer: Uint8Array, password: string): Promise<Hasil<string>> {
+        try {
+            if (buffer.length < 50) return { data: null, error: new Error('Berkas terlalu kecil atau rusak') };
+
+            const magic = new TextDecoder().decode(buffer.slice(0, 4));
+            if (magic !== 'LMBR') return { data: null, error: new Error('Format berkas tidak valid (Magic mismatch)') };
+
+            const version = buffer[4];
+            if (version !== 1) return { data: null, error: new Error(`Versi berkas v${version} tidak didukung`) };
+
+            const salt = buffer.slice(5, 37);
+            const iv = buffer.slice(37, 49);
+            const ciphertext = buffer.slice(49);
+
+            const hash = argon2id(password, salt, {
+                t: 4,
+                m: 64 * 1024,
+                dkLen: 32,
+                p: 1
+            });
+
+            const key = await crypto.subtle.importKey(
+                'raw',
+                hash as BufferSource,
+                { name: ALGO_ENC, length: 256 },
+                false,
+                ['decrypt']
+            );
+
+            const decrypted = await crypto.subtle.decrypt(
+                { name: 'AES-GCM', iv },
+                key,
+                ciphertext
+            );
+            return { data: new TextDecoder().decode(decrypted), error: null };
+        } catch (e) {
+            return { data: null, error: new Error('Gagal membuka berkas: Password salah atau data rusak.', { cause: e }) };
+        }
+    }
+}

package/src/CrashReporter.ts

@@ -0,0 +1,45 @@
+import { AuditLog } from './AuditLog';
+
+export class CrashReporter {
+    private static terpasang = false;
+
+    /**
+     * Memasang pendengar (listener) global untuk menangkap crash aplikasi.
+     * Sangat disarankan untuk dipanggil sekali di root aplikasi (misalnya Layout Next.js atau Main CLI).
+     */
+    static pasang() {
+        if (this.terpasang) return;
+
+        // Lingkungan Browser
+        if (typeof window !== 'undefined') {
+            window.addEventListener('error', async (event) => {
+                const message = `[FATAL BROWSER CRASH] ${event.message}`;
+                const stack = event.error?.stack || 'Tanpa stack trace';
+
+                await AuditLog.catat('KESALAHAN', `${message}\nTrace:\n${stack}`);
+            });
+
+            window.addEventListener('unhandledrejection', async (event) => {
+                const reason = event.reason instanceof Error ? event.reason.stack : String(event.reason);
+                await AuditLog.catat('KESALAHAN', `[UNHANDLED PROMISE REJECTION]\nAlasan:\n${reason}`);
+            });
+        }
+
+        // Lingkungan Node (CLI/Server RSC)
+        if (typeof process !== 'undefined') {
+            process.on('uncaughtException', (error) => {
+                AuditLog.catat('KESALAHAN', `[FATAL NODE CRASH] Uncaught Exception\nTrace:\n${error.stack}`).catch(console.error);
+            });
+
+            process.on('unhandledRejection', (reason) => {
+                const r = reason instanceof Error ? reason.stack : String(reason);
+                AuditLog.catat('KESALAHAN', `[FATAL NODE CRASH] Unhandled Rejection\nAlasan:\n${r}`).catch(console.error);
+            });
+        }
+
+        this.terpasang = true;
+
+        // Log inisialisasi awal
+        AuditLog.catat('INFO', 'Crash Reporter Lembaran diaktifkan.').catch(() => {});
+    }
+}

package/src/Gudang.ts

@@ -0,0 +1,63 @@
+import { StorageAdapter, LembaranSchema } from './storage/types';
+import { BrowserAdapter } from './storage/BrowserAdapter';
+
+// Singleton instance adapter
+let adapter: StorageAdapter;
+
+const getAdapter = async (): Promise<StorageAdapter> => {
+    if (adapter) return adapter;
+
+    if (typeof window !== 'undefined' && typeof window.indexedDB !== 'undefined') {
+        adapter = new BrowserAdapter();
+    } else {
+        // Dynamic import to avoid 'fs' in browser bundle
+        const { FileAdapter } = await import('./storage/FileAdapter');
+        adapter = new FileAdapter();
+    }
+    return adapter;
+};
+
+// Re-export Schema for other consumers
+export type { LembaranSchema };
+
+export const Gudang = {
+    async inisialisasi(customPath?: string) {
+        if (process.env.DEBUG === 'true') {
+            if (process.env.DEBUG === 'true') console.log(`[GUDANG] Inisialisasi: ${customPath || 'default'}`);
+        }
+        if (typeof window === 'undefined') {
+            const { FileAdapter } = await import('./storage/FileAdapter');
+            adapter = new FileAdapter(customPath);
+        }
+    },
+
+    async set<K extends keyof LembaranSchema>(store: K, key: string, value: LembaranSchema[K]['value']) {
+        const adp = await getAdapter();
+        return adp.set(store, key, value);
+    },
+
+    async get<K extends keyof LembaranSchema>(store: K, key: string) {
+        const adp = await getAdapter();
+        return adp.get(store, key);
+    },
+
+    async getAll<K extends keyof LembaranSchema>(store: K) {
+        const adp = await getAdapter();
+        return adp.getAll(store);
+    },
+
+    async delete(store: keyof LembaranSchema, key: string) {
+        const adp = await getAdapter();
+        return adp.delete(store, key);
+    },
+
+    async count(store: keyof LembaranSchema) {
+        const adp = await getAdapter();
+        return adp.count(store);
+    },
+
+    async clear(store: keyof LembaranSchema) {
+        const adp = await getAdapter();
+        return adp.clear(store);
+    }
+};

package/src/GunakanTunda.ts

@@ -0,0 +1,19 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+
+export function useGunakanTunda<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+
+  return debouncedValue;
+}

package/src/Indera.ts

@@ -0,0 +1,61 @@
+export const haptic = {
+    light: () => {
+        if (typeof navigator !== 'undefined' && navigator.vibrate) {
+            navigator.vibrate(10);
+        }
+    },
+    medium: () => {
+        if (typeof navigator !== 'undefined' && navigator.vibrate) {
+            navigator.vibrate(25);
+        }
+    },
+    heavy: () => {
+        if (typeof navigator !== 'undefined' && navigator.vibrate) {
+            navigator.vibrate(50);
+        }
+    },
+    error: () => {
+        if (typeof navigator !== 'undefined' && navigator.vibrate) {
+            navigator.vibrate([30, 50, 30, 50]);
+        }
+    },
+    success: () => {
+        if (typeof navigator !== 'undefined' && navigator.vibrate) {
+            navigator.vibrate([10, 30, 10]);
+        }
+    }
+};
+
+export const audio = {
+    play: (frequency: number, type: OscillatorType = 'sine', duration: number = 0.1) => {
+        if (typeof window === 'undefined') return;
+        try {
+            const ctx = new (window.AudioContext || (window as any).webkitAudioContext)();
+            const osc = ctx.createOscillator();
+            const gain = ctx.createGain();
+
+            osc.type = type;
+            osc.frequency.setValueAtTime(frequency, ctx.currentTime);
+
+            gain.gain.setValueAtTime(0.05, ctx.currentTime);
+            gain.gain.exponentialRampToValueAtTime(0.0001, ctx.currentTime + duration);
+
+            osc.connect(gain);
+            gain.connect(ctx.destination);
+
+            osc.start();
+            osc.stop(ctx.currentTime + duration);
+        } catch (_e) {
+            // Silently fail as haptics/audio are non-critical enhancements
+        }
+    },
+    click: () => audio.play(440, 'sine', 0.05),
+    unlock: () => {
+        audio.play(523.25, 'sine', 0.1); // C5
+        setTimeout(() => audio.play(659.25, 'sine', 0.2), 100); // E5
+    },
+    lock: () => {
+        audio.play(329.63, 'sine', 0.1); // E4
+        setTimeout(() => audio.play(261.63, 'sine', 0.2), 100); // C4
+    }
+};

package/src/Integritas.ts

@@ -0,0 +1,36 @@
+/**
+ * Integritas Module: Handles data hashing for integrity checks.
+ * Follows Data Integrity Policy: Excludes metadata (_hash, _timestamp) during calculation.
+ */
+
+const encoder = new TextEncoder();
+
+export const Integritas = {
+    /**
+     * Calculates a SHA-256 hash of an object for integrity verification.
+     * Metadata fields are stripped before calculation using a replacer function.
+     * This is more efficient than cloning and deleting keys.
+     */
+    async hitungHash(data: unknown): Promise<string> {
+        // Exclude transient metadata per policy using JSON.stringify replacer
+        const text = JSON.stringify(data, (key, value) => {
+            if (key === '_hash' || key === '_timestamp' || key === 'updatedAt') {
+                return undefined;
+            }
+            return value;
+        });
+
+        const buffer = encoder.encode(text);
+
+        const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+        const hashArray = new Uint8Array(hashBuffer);
+
+        // Optimized bytes-to-hex conversion using a pre-allocated string for better performance
+        let hashHex = '';
+        for (let i = 0; i < hashArray.length; i++) {
+            hashHex += hashArray[i].toString(16).padStart(2, '0');
+        }
+
+        return hashHex;
+    }
+};

package/src/Kalender.ts

@@ -0,0 +1,59 @@
+/**
+ * Kalender.ts
+ * Utilitas untuk memproses tanggal puitis dan cerdas.
+ */
+
+export const parseSmartDate = (text: string): Date | null => {
+    const today = new Date();
+    const cleanText = text.toLowerCase().trim();
+
+    if (cleanText === '@hari_ini' || cleanText === '@sekarang') {
+        return today;
+    }
+
+    if (cleanText === '@besok') {
+        const tomorrow = new Date(today);
+        tomorrow.setDate(today.getDate() + 1);
+        return tomorrow;
+    }
+
+    if (cleanText === '@kemarin') {
+        const yesterday = new Date(today);
+        yesterday.setDate(today.getDate() - 1);
+        return yesterday;
+    }
+
+    if (cleanText === '@lusa') {
+        const afterTomorrow = new Date(today);
+        afterTomorrow.setDate(today.getDate() + 2);
+        return afterTomorrow;
+    }
+
+    if (cleanText === '@minggu_depan') {
+        const nextWeek = new Date(today);
+        nextWeek.setDate(today.getDate() + 7);
+        return nextWeek;
+    }
+
+    // Hari dalam seminggu
+    const days = ['minggu', 'senin', 'selasa', 'rabu', 'kamis', 'jumat', 'sabtu'];
+    for (let i = 0; i < days.length; i++) {
+        if (cleanText === `@${days[i]}`) {
+            const resultDate = new Date(today);
+            let diff = i - today.getDay();
+            if (diff <= 0) diff += 7; // Ambil hari tersebut di minggu depan
+            resultDate.setDate(today.getDate() + diff);
+            return resultDate;
+        }
+    }
+
+    return null;
+};
+
+export const formatArsipDate = (date: Date): string => {
+    return date.toLocaleDateString('id-ID', {
+        day: 'numeric',
+        month: 'long',
+        year: 'numeric'
+    });
+};

package/src/KataSandi.ts

@@ -0,0 +1,27 @@
+const WORDLIST = [
+    "abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract", "absurd", "abuse",
+    "access", "accident", "account", "accuse", "achieve", "acid", "acoustic", "acquire", "across", "act",
+    "action", "actor", "actress", "actual", "adapt", "add", "addict", "address", "adjust", "admit",
+    "adult", "advance", "advice", "aerobic", "affair", "afford", "afraid", "again", "age", "agent",
+    "agree", "ahead", "aim", "air", "airport", "aisle", "alarm", "album", "alcohol", "alert",
+    "alien", "all", "alley", "allow", "almost", "alone", "alpha", "already", "also", "alter",
+    "always", "amaze", "ambition", "amount", "amuse", "analyst", "anchor", "ancient", "anger", "angle",
+    "angry", "animal", "ankle", "announce", "annual", "another", "answer", "antenna", "antique", "anxiety",
+    "any", "apart", "apology", "appear", "apple", "approve", "april", "arch", "arctic", "area",
+    "arena", "argue", "arm", "armed", "armor", "army", "around", "arrange", "arrest", "arrive",
+    "arrow", "art", "artefact", "artist", "artwork", "ask", "aspect", "assault", "asset", "assist",
+    "assume", "asthma", "athlete", "atom", "attack", "attend", "attitude", "attract", "auction", "audit"
+]; // Reduced for space, in production use full 2048 words
+
+export const generateMnemonic = (wordCount: number = 12): string => {
+    const words: string[] = [];
+    const randomValues = new Uint32Array(wordCount);
+    crypto.getRandomValues(randomValues);
+
+    for (let i = 0; i < wordCount; i++) {
+        const index = randomValues[i] % WORDLIST.length;
+        words.push(WORDLIST[index]);
+    }
+
+    return words.join(' ');
+};