@harkenapp/sdk-react-native 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/storage/SecureStoreAdapter.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect, vi } from "vitest";
+import { createSecureStoreAdapter, createMemoryStorage } from "./SecureStoreAdapter";
+
+describe("createSecureStoreAdapter", () => {
+  describe("when SecureStore is available", () => {
+    it("maps getItem to getItemAsync", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn().mockResolvedValue("stored-value"),
+        setItemAsync: vi.fn(),
+        deleteItemAsync: vi.fn(),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+      const result = await adapter.getItem("test-key");
+
+      expect(mockSecureStore.getItemAsync).toHaveBeenCalledWith("test-key");
+      expect(result).toBe("stored-value");
+    });
+
+    it("maps setItem to setItemAsync", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn(),
+        setItemAsync: vi.fn().mockResolvedValue(undefined),
+        deleteItemAsync: vi.fn(),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+      await adapter.setItem("test-key", "test-value");
+
+      expect(mockSecureStore.setItemAsync).toHaveBeenCalledWith("test-key", "test-value");
+    });
+
+    it("maps deleteItem to deleteItemAsync", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn(),
+        setItemAsync: vi.fn(),
+        deleteItemAsync: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+      await adapter.deleteItem("test-key");
+
+      expect(mockSecureStore.deleteItemAsync).toHaveBeenCalledWith("test-key");
+    });
+
+    it("returns null when key not found", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn().mockResolvedValue(null),
+        setItemAsync: vi.fn(),
+        deleteItemAsync: vi.fn(),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+      const result = await adapter.getItem("nonexistent");
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("error handling", () => {
+    it("propagates getItemAsync errors", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn().mockRejectedValue(new Error("Storage error")),
+        setItemAsync: vi.fn(),
+        deleteItemAsync: vi.fn(),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+
+      await expect(adapter.getItem("test-key")).rejects.toThrow("Storage error");
+    });
+
+    it("propagates setItemAsync errors", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn(),
+        setItemAsync: vi.fn().mockRejectedValue(new Error("Write error")),
+        deleteItemAsync: vi.fn(),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+
+      await expect(adapter.setItem("key", "value")).rejects.toThrow("Write error");
+    });
+
+    it("propagates deleteItemAsync errors", async () => {
+      const mockSecureStore = {
+        getItemAsync: vi.fn(),
+        setItemAsync: vi.fn(),
+        deleteItemAsync: vi.fn().mockRejectedValue(new Error("Delete error")),
+      };
+
+      const adapter = createSecureStoreAdapter(mockSecureStore);
+
+      await expect(adapter.deleteItem("key")).rejects.toThrow("Delete error");
+    });
+  });
+});
+
+describe("createMemoryStorage", () => {
+  it("stores and retrieves values", async () => {
+    const storage = createMemoryStorage();
+
+    await storage.setItem("key1", "value1");
+    const result = await storage.getItem("key1");
+
+    expect(result).toBe("value1");
+  });
+
+  it("returns null for non-existent keys", async () => {
+    const storage = createMemoryStorage();
+
+    const result = await storage.getItem("nonexistent");
+
+    expect(result).toBeNull();
+  });
+
+  it("deletes values", async () => {
+    const storage = createMemoryStorage();
+
+    await storage.setItem("key", "value");
+    await storage.deleteItem("key");
+    const result = await storage.getItem("key");
+
+    expect(result).toBeNull();
+  });
+
+  it("overwrites existing values", async () => {
+    const storage = createMemoryStorage();
+
+    await storage.setItem("key", "first");
+    await storage.setItem("key", "second");
+    const result = await storage.getItem("key");
+
+    expect(result).toBe("second");
+  });
+
+  it("isolates storage between instances", async () => {
+    const storage1 = createMemoryStorage();
+    const storage2 = createMemoryStorage();
+
+    await storage1.setItem("key", "value1");
+    await storage2.setItem("key", "value2");
+
+    expect(await storage1.getItem("key")).toBe("value1");
+    expect(await storage2.getItem("key")).toBe("value2");
+  });
+});

package/src/storage/SecureStoreAdapter.ts

@@ -1,4 +1,4 @@
-import type { SecureStorage } from './types';
+import type { SecureStorage } from "./types";
 
 /**
  * Adapter for expo-secure-store.

package/src/storage/defaultStorage.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// We need to test the module in isolation, so we use dynamic imports
+// and reset the module state between tests
+
+describe("defaultStorage", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("getDefaultStorage", () => {
+    it("uses SecureStore when available", async () => {
+      // Mock expo-secure-store to be available
+      vi.doMock("expo-secure-store", () => ({
+        getItemAsync: vi.fn().mockResolvedValue("secure-value"),
+        setItemAsync: vi.fn().mockResolvedValue(undefined),
+        deleteItemAsync: vi.fn().mockResolvedValue(undefined),
+      }));
+
+      const { getDefaultStorage } = await import("./defaultStorage");
+      const storage = await getDefaultStorage();
+
+      // The storage should use SecureStore
+      const result = await storage.getItem("test-key");
+
+      // Since we mocked getItemAsync to return "secure-value"
+      expect(result).toBe("secure-value");
+    });
+
+    it("falls back to memory storage when SecureStore unavailable", async () => {
+      // Mock expo-secure-store to throw (simulating it not being installed)
+      vi.doMock("expo-secure-store", () => {
+        throw new Error("Cannot find module 'expo-secure-store'");
+      });
+
+      // Suppress console.warn for this test
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      const { getDefaultStorage } = await import("./defaultStorage");
+      const storage = await getDefaultStorage();
+
+      // Should fall back to memory storage and warn
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("expo-secure-store not available")
+      );
+
+      // Memory storage should work
+      await storage.setItem("key", "value");
+      const result = await storage.getItem("key");
+      expect(result).toBe("value");
+    });
+
+    it("caches the storage instance", async () => {
+      vi.doMock("expo-secure-store", () => ({
+        getItemAsync: vi.fn().mockResolvedValue(null),
+        setItemAsync: vi.fn().mockResolvedValue(undefined),
+        deleteItemAsync: vi.fn().mockResolvedValue(undefined),
+      }));
+
+      const { getDefaultStorage } = await import("./defaultStorage");
+
+      const storage1 = await getDefaultStorage();
+      const storage2 = await getDefaultStorage();
+
+      // Should return the same instance
+      expect(storage1).toBe(storage2);
+    });
+  });
+
+  describe("createDefaultStorage", () => {
+    it("returns a lazy wrapper that initializes on first use", async () => {
+      const mockGetItemAsync = vi.fn().mockResolvedValue("lazy-value");
+
+      vi.doMock("expo-secure-store", () => ({
+        getItemAsync: mockGetItemAsync,
+        setItemAsync: vi.fn().mockResolvedValue(undefined),
+        deleteItemAsync: vi.fn().mockResolvedValue(undefined),
+      }));
+
+      const { createDefaultStorage } = await import("./defaultStorage");
+      const storage = createDefaultStorage();
+
+      // SecureStore shouldn't be called yet (lazy)
+      expect(mockGetItemAsync).not.toHaveBeenCalled();
+
+      // First use triggers initialization
+      const result = await storage.getItem("test-key");
+
+      expect(mockGetItemAsync).toHaveBeenCalledWith("test-key");
+      expect(result).toBe("lazy-value");
+    });
+
+    it("caches initialization across method calls", async () => {
+      let initCount = 0;
+
+      vi.doMock("expo-secure-store", () => {
+        initCount++;
+        return {
+          getItemAsync: vi.fn().mockResolvedValue(null),
+          setItemAsync: vi.fn().mockResolvedValue(undefined),
+          deleteItemAsync: vi.fn().mockResolvedValue(undefined),
+        };
+      });
+
+      const { createDefaultStorage } = await import("./defaultStorage");
+      const storage = createDefaultStorage();
+
+      // Multiple operations should only initialize once
+      await storage.getItem("key1");
+      await storage.setItem("key2", "value");
+      await storage.deleteItem("key3");
+
+      // Module should only be imported once
+      expect(initCount).toBe(1);
+    });
+
+    it("handles concurrent initialization correctly", async () => {
+      vi.doMock("expo-secure-store", () => ({
+        getItemAsync: vi.fn().mockResolvedValue("concurrent-value"),
+        setItemAsync: vi.fn().mockResolvedValue(undefined),
+        deleteItemAsync: vi.fn().mockResolvedValue(undefined),
+      }));
+
+      const { createDefaultStorage } = await import("./defaultStorage");
+      const storage = createDefaultStorage();
+
+      // Concurrent calls should all succeed
+      const [result1, result2, result3] = await Promise.all([
+        storage.getItem("key1"),
+        storage.getItem("key2"),
+        storage.getItem("key3"),
+      ]);
+
+      expect(result1).toBe("concurrent-value");
+      expect(result2).toBe("concurrent-value");
+      expect(result3).toBe("concurrent-value");
+    });
+  });
+
+  describe("error handling", () => {
+    it("does not crash when SecureStore throws during operations", async () => {
+      vi.doMock("expo-secure-store", () => ({
+        getItemAsync: vi.fn().mockRejectedValue(new Error("SecureStore error")),
+        setItemAsync: vi.fn().mockRejectedValue(new Error("SecureStore error")),
+        deleteItemAsync: vi.fn().mockRejectedValue(new Error("SecureStore error")),
+      }));
+
+      const { createDefaultStorage } = await import("./defaultStorage");
+      const storage = createDefaultStorage();
+
+      // Errors from SecureStore should propagate (not swallowed)
+      await expect(storage.getItem("key")).rejects.toThrow("SecureStore error");
+    });
+  });
+});

package/src/storage/defaultStorage.ts

@@ -1,5 +1,5 @@
-import type { SecureStorage } from './types';
-import { createMemoryStorage } from './SecureStoreAdapter';
+import type { SecureStorage } from "./types";
+import { createMemoryStorage } from "./SecureStoreAdapter";
 
 /**
  * Cached default storage instance.
@@ -31,7 +31,7 @@ export async function getDefaultStorage(): Promise<SecureStorage> {
 
     try {
       // Dynamically import expo-secure-store
-      const SecureStore = await import('expo-secure-store');
+      const SecureStore = await import("expo-secure-store");
 
       defaultStorageInstance = {
         async getItem(key: string): Promise<string | null> {
@@ -49,9 +49,9 @@ export async function getDefaultStorage(): Promise<SecureStorage> {
     } catch {
       // expo-secure-store not available, fall back to memory storage
       console.warn(
-        '[Harken] expo-secure-store not available. Using in-memory storage. ' +
-          'Anonymous IDs will not persist across app restarts. ' +
-          'Install expo-secure-store for persistent storage.'
+        "[Harken] expo-secure-store not available. Using in-memory storage. " +
+          "Anonymous IDs will not persist across app restarts. " +
+          "Install expo-secure-store for persistent storage."
       );
     }
   }

package/src/storage/index.ts

@@ -1,5 +1,5 @@
-export type { SecureStorage } from './types';
-export { STORAGE_KEYS } from './types';
-export { createSecureStoreAdapter, createMemoryStorage } from './SecureStoreAdapter';
-export { createDefaultStorage } from './defaultStorage';
-export { IdentityStore } from './IdentityStore';
+export type { SecureStorage } from "./types";
+export { STORAGE_KEYS } from "./types";
+export { createSecureStoreAdapter, createMemoryStorage } from "./SecureStoreAdapter";
+export { createDefaultStorage } from "./defaultStorage";
+export { IdentityStore } from "./IdentityStore";

package/src/storage/types.ts

@@ -30,5 +30,5 @@ export interface SecureStorage {
  * @internal
  */
 export const STORAGE_KEYS = {
-  ANON_ID: 'harken_anon_id',
+  ANON_ID: "harken_anon_id",
 } as const;

package/src/theme/defaults.ts

@@ -3,33 +3,36 @@ import type {
   HarkenTypography,
   HarkenSpacing,
   HarkenRadii,
+  HarkenSizing,
+  HarkenOpacity,
   HarkenTheme,
-} from './types';
+} from "./types";
 
 /**
  * Default light mode colors.
  * Neutral, accessible palette with no hard-coded branding.
  */
 export const lightColors: HarkenColors = {
-  primary: '#2563EB', // Blue 600
-  primaryPressed: '#1D4ED8', // Blue 700
-  background: '#FFFFFF',
-  backgroundSecondary: '#F9FAFB', // Gray 50
-  text: '#111827', // Gray 900
-  textSecondary: '#6B7280', // Gray 500
-  textPlaceholder: '#9CA3AF', // Gray 400
-  textOnPrimary: '#FFFFFF',
-  border: '#E5E7EB', // Gray 200
-  borderFocused: '#2563EB', // Blue 600
-  error: '#DC2626', // Red 600
-  success: '#16A34A', // Green 600
-  warning: '#D97706', // Amber 600
-  info: '#2563EB', // Blue 600
-  overlay: 'rgba(0, 0, 0, 0.3)',
-  overlayDark: 'rgba(0, 0, 0, 0.6)',
-  accent1: '#2563EB', // Blue 600 (camera)
-  accent2: '#16A34A', // Green 600 (library)
-  accent3: '#D97706', // Amber 600 (files)
+  primary: "#2563EB", // Blue 600
+  primaryPressed: "#1D4ED8", // Blue 700
+  background: "#FFFFFF",
+  surface: "#F9FAFB", // Gray 50 - container/modal surface
+  backgroundSecondary: "#F9FAFB", // Gray 50 - alias for surface (backwards compat)
+  text: "#111827", // Gray 900
+  textSecondary: "#6B7280", // Gray 500
+  textPlaceholder: "#9CA3AF", // Gray 400
+  textOnPrimary: "#FFFFFF",
+  border: "#E5E7EB", // Gray 200
+  borderFocused: "#2563EB", // Blue 600
+  error: "#DC2626", // Red 600
+  success: "#16A34A", // Green 600
+  warning: "#D97706", // Amber 600
+  info: "#2563EB", // Blue 600
+  overlay: "rgba(0, 0, 0, 0.3)",
+  overlayDark: "rgba(0, 0, 0, 0.6)",
+  accent1: "#2563EB", // Blue 600 (camera)
+  accent2: "#16A34A", // Green 600 (library)
+  accent3: "#D97706", // Amber 600 (files)
 };
 
 /**
@@ -37,25 +40,26 @@ export const lightColors: HarkenColors = {
  * Inverted palette optimized for dark backgrounds.
  */
 export const darkColors: HarkenColors = {
-  primary: '#3B82F6', // Blue 500
-  primaryPressed: '#2563EB', // Blue 600
-  background: '#111827', // Gray 900
-  backgroundSecondary: '#1F2937', // Gray 800
-  text: '#F9FAFB', // Gray 50
-  textSecondary: '#9CA3AF', // Gray 400
-  textPlaceholder: '#6B7280', // Gray 500
-  textOnPrimary: '#FFFFFF',
-  border: '#374151', // Gray 700
-  borderFocused: '#3B82F6', // Blue 500
-  error: '#EF4444', // Red 500
-  success: '#22C55E', // Green 500
-  warning: '#F59E0B', // Amber 500
-  info: '#3B82F6', // Blue 500
-  overlay: 'rgba(0, 0, 0, 0.5)',
-  overlayDark: 'rgba(0, 0, 0, 0.8)',
-  accent1: '#3B82F6', // Blue 500 (camera)
-  accent2: '#22C55E', // Green 500 (library)
-  accent3: '#F59E0B', // Amber 500 (files)
+  primary: "#3B82F6", // Blue 500
+  primaryPressed: "#2563EB", // Blue 600
+  background: "#111827", // Gray 900
+  surface: "#1F2937", // Gray 800 - container/modal surface
+  backgroundSecondary: "#1F2937", // Gray 800 - alias for surface (backwards compat)
+  text: "#F9FAFB", // Gray 50
+  textSecondary: "#9CA3AF", // Gray 400
+  textPlaceholder: "#6B7280", // Gray 500
+  textOnPrimary: "#FFFFFF",
+  border: "#374151", // Gray 700
+  borderFocused: "#3B82F6", // Blue 500
+  error: "#EF4444", // Red 500
+  success: "#22C55E", // Green 500
+  warning: "#F59E0B", // Amber 500
+  info: "#3B82F6", // Blue 500
+  overlay: "rgba(0, 0, 0, 0.5)",
+  overlayDark: "rgba(0, 0, 0, 0.8)",
+  accent1: "#3B82F6", // Blue 500 (camera)
+  accent2: "#22C55E", // Green 500 (library)
+  accent3: "#F59E0B", // Amber 500 (files)
 };
 
 /**
@@ -63,22 +67,22 @@ export const darkColors: HarkenColors = {
  * Uses system font for maximum compatibility.
  */
 export const defaultTypography: HarkenTypography = {
-  fontFamily: 'System',
+  fontFamily: "System",
   fontFamilyHeading: undefined, // Falls back to fontFamily
 
   titleSize: 20,
   titleLineHeight: 1.3,
-  titleWeight: '600',
+  titleWeight: "600",
 
   bodySize: 16,
   bodyLineHeight: 1.5,
-  bodyWeight: 'normal',
+  bodyWeight: "normal",
 
   labelSize: 14,
-  labelWeight: '500',
+  labelWeight: "500",
 
   captionSize: 12,
-  captionWeight: 'normal',
+  captionWeight: "normal",
 };
 
 /**
@@ -126,26 +130,51 @@ export const darkTheme: HarkenTheme = {
   radii: defaultRadii,
 };
 
+/** Extended theme type that includes optional sizing and opacity */
+type ExtendedHarkenTheme = HarkenTheme & {
+  sizing?: Partial<HarkenSizing>;
+  opacity?: Partial<HarkenOpacity>;
+};
+
 /**
  * Creates a theme by merging overrides with a base theme.
+ *
+ * Note: For full resolved theme with component aliases, use `resolveTheme` instead.
+ * This function creates a raw HarkenTheme suitable for passing to resolveTheme.
  */
 export function createTheme(
-  baseTheme: HarkenTheme,
+  baseTheme: ExtendedHarkenTheme,
   overrides?: {
     colors?: Partial<HarkenColors>;
     typography?: Partial<HarkenTypography>;
     spacing?: Partial<HarkenSpacing>;
     radii?: Partial<HarkenRadii>;
+    sizing?: Partial<HarkenSizing>;
+    opacity?: Partial<HarkenOpacity>;
   }
-): HarkenTheme {
+): ExtendedHarkenTheme {
   if (!overrides) {
     return baseTheme;
   }
 
+  // Merge sizing if either base or overrides has it
+  const baseSizing = baseTheme.sizing;
+  const overrideSizing = overrides.sizing;
+  const mergedSizing =
+    baseSizing || overrideSizing ? { ...baseSizing, ...overrideSizing } : undefined;
+
+  // Merge opacity if either base or overrides has it
+  const baseOpacity = baseTheme.opacity;
+  const overrideOpacity = overrides.opacity;
+  const mergedOpacity =
+    baseOpacity || overrideOpacity ? { ...baseOpacity, ...overrideOpacity } : undefined;
+
   return {
     colors: { ...baseTheme.colors, ...overrides.colors },
     typography: { ...baseTheme.typography, ...overrides.typography },
     spacing: { ...baseTheme.spacing, ...overrides.spacing },
     radii: { ...baseTheme.radii, ...overrides.radii },
+    ...(mergedSizing && { sizing: mergedSizing }),
+    ...(mergedOpacity && { opacity: mergedOpacity }),
   };
 }

package/src/theme/index.ts

@@ -4,11 +4,21 @@ export type {
   HarkenTypography,
   HarkenSpacing,
   HarkenRadii,
+  HarkenSizing,
+  HarkenOpacity,
   HarkenTheme,
   PartialHarkenTheme,
   TextWeight,
   ThemeMode,
-} from './types';
+  // Resolved theme types
+  ResolvedHarkenColors,
+  ResolvedHarkenSpacing,
+  ResolvedHarkenRadii,
+  ResolvedHarkenSizing,
+  ResolvedHarkenOpacity,
+  ResolvedHarkenTheme,
+  HarkenComponentTokens,
+} from "./types";
 
 // Default theme exports
 export {
@@ -20,4 +30,7 @@ export {
   lightTheme,
   darkTheme,
   createTheme,
-} from './defaults';
+} from "./defaults";
+
+// Theme resolver
+export { resolveTheme } from "./resolver";