@autobe/ui 0.22.0 → 0.23.0

package/src/utils/__tests__/storage.test.ts

@@ -0,0 +1,229 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+import {
+  clearEncryptedSessionStorage,
+  getEncryptedSessionStorage,
+  hasEncryptedSessionStorage,
+  removeEncryptedSessionStorage,
+  setEncryptedSessionStorage,
+} from "../storage";
+
+// Mock sessionStorage for testing
+const mockSessionStorage = {
+  store: new Map<string, string>(),
+  getItem: vi.fn((key: string) => mockSessionStorage.store.get(key) || null),
+  setItem: vi.fn((key: string, value: string) => {
+    mockSessionStorage.store.set(key, value);
+  }),
+  removeItem: vi.fn((key: string) => {
+    mockSessionStorage.store.delete(key);
+  }),
+  clear: vi.fn(() => {
+    mockSessionStorage.store.clear();
+  }),
+};
+
+// Mock global sessionStorage
+Object.defineProperty(global, "sessionStorage", {
+  value: mockSessionStorage,
+  writable: true,
+});
+
+Object.defineProperty(global, "window", {
+  value: { sessionStorage: mockSessionStorage },
+  writable: true,
+});
+
+describe("Storage Utils", () => {
+  beforeEach(() => {
+    mockSessionStorage.store.clear();
+    vi.clearAllMocks();
+  });
+
+  describe("encrypted sessionStorage operations", () => {
+    test("should store and retrieve encrypted data", () => {
+      const key = "test_key";
+      const value = "sk-test123456789";
+
+      setEncryptedSessionStorage(key, value);
+      const retrieved = getEncryptedSessionStorage(key);
+
+      expect(retrieved).toBe(value);
+      expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+        key,
+        expect.any(String),
+      );
+      expect(mockSessionStorage.getItem).toHaveBeenCalledWith(key);
+    });
+
+    test("should store encrypted value, not plain text", () => {
+      const key = "test_encrypted";
+      const value = "secret-api-key";
+
+      setEncryptedSessionStorage(key, value);
+      const storedValue = mockSessionStorage.store.get(key);
+
+      expect(storedValue).not.toBe(value); // Should not store plain text
+      expect(storedValue).toBeTruthy(); // Should store something
+      expect(storedValue!.length).toBeGreaterThan(0); // Should have content
+    });
+
+    test("should handle empty values correctly", () => {
+      const key = "empty_test";
+      const value = "";
+
+      setEncryptedSessionStorage(key, value);
+      const retrieved = getEncryptedSessionStorage(key);
+
+      expect(retrieved).toBe("");
+    });
+
+    test("should return empty string for non-existent keys", () => {
+      const result = getEncryptedSessionStorage("non_existent_key");
+      expect(result).toBe("");
+    });
+
+    test("should remove encrypted data", () => {
+      const key = "test_remove";
+      const value = "test-value";
+
+      setEncryptedSessionStorage(key, value);
+      expect(getEncryptedSessionStorage(key)).toBe(value);
+
+      removeEncryptedSessionStorage(key);
+      expect(getEncryptedSessionStorage(key)).toBe("");
+      expect(mockSessionStorage.removeItem).toHaveBeenCalledWith(key);
+    });
+
+    test("should check if encrypted data exists", () => {
+      const key = "existence_test";
+      const value = "test-value";
+
+      // Initially should not exist
+      expect(hasEncryptedSessionStorage(key)).toBe(false);
+
+      // After storing should exist
+      setEncryptedSessionStorage(key, value);
+      expect(hasEncryptedSessionStorage(key)).toBe(true);
+
+      // After removing should not exist
+      removeEncryptedSessionStorage(key);
+      expect(hasEncryptedSessionStorage(key)).toBe(false);
+    });
+
+    test("should handle storage errors gracefully", () => {
+      const originalSetItem = mockSessionStorage.setItem;
+      mockSessionStorage.setItem = vi.fn(() => {
+        throw new Error("Storage quota exceeded");
+      });
+
+      // Should throw error with meaningful message
+      expect(() => {
+        setEncryptedSessionStorage("test", "value");
+      }).toThrow(
+        'Failed to store encrypted data for key "test": Storage quota exceeded',
+      );
+
+      mockSessionStorage.setItem = originalSetItem; // Restore
+    });
+
+    test("should clear all sessionStorage data", () => {
+      // Mock setItem to not throw for this test
+      const originalSetItem = mockSessionStorage.setItem;
+      mockSessionStorage.setItem = vi.fn((key: string, value: string) => {
+        mockSessionStorage.store.set(key, value);
+      });
+
+      // Store some test data
+      setEncryptedSessionStorage("key1", "value1");
+      setEncryptedSessionStorage("key2", "value2");
+
+      expect(hasEncryptedSessionStorage("key1")).toBe(true);
+      expect(hasEncryptedSessionStorage("key2")).toBe(true);
+
+      // Clear all
+      clearEncryptedSessionStorage();
+
+      expect(hasEncryptedSessionStorage("key1")).toBe(false);
+      expect(hasEncryptedSessionStorage("key2")).toBe(false);
+      expect(mockSessionStorage.clear).toHaveBeenCalled();
+
+      mockSessionStorage.setItem = originalSetItem; // Restore
+    });
+  });
+
+  describe("Unicode and special data", () => {
+    const testCases = [
+      { key: "korean", value: "안녕하세요" },
+      { key: "emoji", value: "🚀🔐💎✨" },
+      { key: "mixed", value: "Hello 안녕 🚀 World!" },
+      { key: "api_key", value: "sk-proj-1234567890abcdefghijklmnop" },
+      { key: "json", value: '{"name":"test","value":123}' },
+      { key: "multiline", value: "line1\nline2\nline3" },
+    ];
+
+    test.each(testCases)(
+      "should handle $key: $value correctly",
+      ({ key, value }) => {
+        // Mock setItem to not throw for unicode tests
+        const originalSetItem = mockSessionStorage.setItem;
+        mockSessionStorage.setItem = vi.fn((key: string, value: string) => {
+          mockSessionStorage.store.set(key, value);
+        });
+
+        setEncryptedSessionStorage(key, value);
+        const retrieved = getEncryptedSessionStorage(key);
+
+        expect(retrieved).toBe(value);
+        expect(hasEncryptedSessionStorage(key)).toBe(true);
+
+        // Verify it's actually encrypted in storage
+        const rawStored = mockSessionStorage.store.get(key);
+        expect(rawStored).not.toBe(value);
+        expect(rawStored).toBeTruthy();
+
+        mockSessionStorage.setItem = originalSetItem; // Restore
+      },
+    );
+  });
+
+  describe("Edge cases", () => {
+    test("should handle null/undefined gracefully", () => {
+      // These should not throw
+      expect(() => getEncryptedSessionStorage("")).not.toThrow();
+      expect(() => hasEncryptedSessionStorage("")).not.toThrow();
+      expect(() => removeEncryptedSessionStorage("")).not.toThrow();
+    });
+
+    test("should handle SSR environment (no window)", () => {
+      const originalWindow = global.window;
+      // @ts-ignore
+      delete global.window;
+
+      // Should not throw and return safe defaults
+      expect(() => {
+        setEncryptedSessionStorage("test", "value");
+        const result = getEncryptedSessionStorage("test");
+        expect(result).toBe("");
+        const exists = hasEncryptedSessionStorage("test");
+        expect(exists).toBe(false);
+        removeEncryptedSessionStorage("test");
+        clearEncryptedSessionStorage();
+      }).not.toThrow();
+
+      global.window = originalWindow; // Restore
+    });
+
+    test("should handle corrupted storage data", () => {
+      const key = "corrupted_test";
+
+      // Manually put invalid encrypted data
+      mockSessionStorage.store.set(key, "invalid-base64-data!");
+
+      // Should throw error on corrupted data
+      expect(() => {
+        getEncryptedSessionStorage(key);
+      }).toThrow('Failed to retrieve encrypted data for key "corrupted_test"');
+    });
+  });
+});

package/src/utils/crypto.ts

@@ -0,0 +1,95 @@
+/**
+ * Simple and reliable encryption utilities using browser built-in functions
+ * Uses TextEncoder/TextDecoder for proper Unicode support + XOR + Base64
+ */
+
+const ENCRYPTION_KEY = "AutoBE_Secret_2024_v3.0_Unicode"; // Unicode-safe key
+
+/**
+ * Simple encrypt using TextEncoder for Unicode safety
+ *
+ * @param text - Text to encrypt
+ * @returns Encrypted base64 string
+ */
+export const encrypt = (text: string): string => {
+  if (!text) return "";
+
+  try {
+    // Use TextEncoder for proper Unicode → UTF-8 bytes conversion
+    const encoder = new TextEncoder();
+    const textBytes = encoder.encode(text);
+
+    // Generate simple salt
+    const salt = Math.random().toString(36).substring(2, 10);
+    const keyBytes = encoder.encode(ENCRYPTION_KEY + salt);
+
+    // XOR encryption on bytes level
+    const encryptedBytes = new Uint8Array(textBytes.length);
+    for (let i = 0; i < textBytes.length; i++) {
+      encryptedBytes[i] = textBytes[i] ^ keyBytes[i % keyBytes.length];
+    }
+
+    // Convert to hex string for safe concatenation
+    const encryptedHex = Array.from(encryptedBytes)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+
+    // Combine salt + encrypted hex
+    const combined = salt + ":" + encryptedHex;
+
+    // Base64 encode the final result (handle Unicode properly)
+    const result = btoa(unescape(encodeURIComponent(combined)));
+    return result;
+  } catch (error) {
+    throw new Error(
+      `Encryption failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};
+
+/**
+ * Simple decrypt using TextDecoder for Unicode safety
+ *
+ * @param encryptedText - Base64 encrypted string
+ * @returns Decrypted plain text
+ */
+export const decrypt = (encryptedText: string): string => {
+  if (!encryptedText) return "";
+
+  try {
+    // Base64 decode (handle Unicode properly)
+    const combined = decodeURIComponent(escape(atob(encryptedText)));
+    const parts = combined.split(":");
+
+    if (parts.length !== 2) {
+      throw new Error("Invalid encrypted format: expected salt:data format");
+    }
+
+    const salt = parts[0];
+    const encryptedHex = parts[1];
+
+    // Convert hex back to bytes
+    const encryptedBytes = new Uint8Array(
+      encryptedHex.match(/.{2}/g)?.map((hex) => parseInt(hex, 16)) || [],
+    );
+
+    // Recreate key
+    const encoder = new TextEncoder();
+    const keyBytes = encoder.encode(ENCRYPTION_KEY + salt);
+
+    // XOR decryption
+    const decryptedBytes = new Uint8Array(encryptedBytes.length);
+    for (let i = 0; i < encryptedBytes.length; i++) {
+      decryptedBytes[i] = encryptedBytes[i] ^ keyBytes[i % keyBytes.length];
+    }
+
+    // Use TextDecoder for proper UTF-8 → Unicode conversion
+    const decoder = new TextDecoder();
+    const result = decoder.decode(decryptedBytes);
+    return result;
+  } catch (error) {
+    throw new Error(
+      `Decryption failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};

package/src/utils/index.ts

@@ -1,4 +1,6 @@
 export * from "./AutoBeFileUploader";
 export * from "./AutoBeVoiceRecorder";
 export * from "./time";
+export * from "./crypto";
+export * from "./storage";
 export * from "./number";

package/src/utils/storage.ts

@@ -0,0 +1,96 @@
+/**
+ * Encrypted sessionStorage utilities Provides secure storage functions using
+ * encryption
+ */
+import { decrypt, encrypt } from "./crypto";
+
+/**
+ * Safely store encrypted data in sessionStorage
+ *
+ * @param key - Storage key
+ * @param value - Plain text value to encrypt and store
+ */
+export const setEncryptedSessionStorage = (
+  key: string,
+  value: string,
+): void => {
+  if (typeof window === "undefined") return;
+
+  try {
+    const encrypted = encrypt(value);
+    sessionStorage.setItem(key, encrypted);
+  } catch (error) {
+    throw new Error(
+      `Failed to store encrypted data for key "${key}": ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};
+
+/**
+ * Safely retrieve and decrypt data from sessionStorage
+ *
+ * @param key - Storage key
+ * @returns Decrypted plain text value
+ */
+export const getEncryptedSessionStorage = (key: string): string => {
+  if (typeof window === "undefined") return "";
+
+  try {
+    const encrypted = sessionStorage.getItem(key);
+    if (!encrypted) return "";
+    return decrypt(encrypted);
+  } catch (error) {
+    throw new Error(
+      `Failed to retrieve encrypted data for key "${key}": ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};
+
+/**
+ * Remove encrypted data from sessionStorage
+ *
+ * @param key - Storage key
+ */
+export const removeEncryptedSessionStorage = (key: string): void => {
+  if (typeof window === "undefined") return;
+
+  try {
+    sessionStorage.removeItem(key);
+  } catch (error) {
+    throw new Error(
+      `Failed to remove encrypted data for key "${key}": ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};
+
+/**
+ * Check if encrypted data exists in sessionStorage
+ *
+ * @param key - Storage key
+ * @returns Whether the key exists and has a value
+ */
+export const hasEncryptedSessionStorage = (key: string): boolean => {
+  if (typeof window === "undefined") return false;
+
+  try {
+    const value = sessionStorage.getItem(key);
+    return value !== null && value !== "";
+  } catch (error) {
+    throw new Error(
+      `Failed to check encrypted data for key "${key}": ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};
+
+/** Clear all sessionStorage data (use with caution) */
+export const clearEncryptedSessionStorage = (): void => {
+  if (typeof window === "undefined") return;
+
+  try {
+    sessionStorage.clear();
+  } catch (error) {
+    throw new Error(
+      `Failed to clear sessionStorage: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+};

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "happy-dom",
+    globals: true,
+    setupFiles: [],
+    include: ["src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    exclude: ["node_modules", "lib", "dist"],
+    coverage: {
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "src/**/*.test.ts", "src/**/*.spec.ts"],
+    },
+  },
+});