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

package/src/hooks/index.ts

@@ -1,9 +1,9 @@
 // Core hooks (no native module dependencies)
-export { useHarkenTheme } from './useHarkenTheme';
-export { useHarkenContext } from './useHarkenContext';
-export { useAnonymousId } from './useAnonymousId';
-export { useFeedback } from './useFeedback';
-export type { SubmitFeedbackParams, UseFeedbackResult } from './useFeedback';
+export { useHarkenTheme } from "./useHarkenTheme";
+export { useHarkenContext } from "./useHarkenContext";
+export { useAnonymousId } from "./useAnonymousId";
+export { useFeedback } from "./useFeedback";
+export type { SubmitFeedbackParams, UseFeedbackResult } from "./useFeedback";
 
 // Note: Attachment hooks (useAttachmentUpload, useAttachmentStatus) are
 // exported from '@harkenapp/sdk-react-native/attachments' to avoid eager

package/src/hooks/useAnonymousId.test.ts

@@ -0,0 +1,189 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import React from "react";
+import { useAnonymousId } from "./useAnonymousId";
+import { HarkenContext } from "../context";
+
+// Mock identityStore
+function createMockIdentityStore() {
+  return {
+    getAnonymousId: vi.fn(),
+    getUserId: vi.fn(),
+    setUserId: vi.fn(),
+    clearUserId: vi.fn(),
+  };
+}
+
+// Helper to create a wrapper with HarkenContext
+function createWrapper(contextValue: unknown) {
+  return function Wrapper({ children }: { children: React.ReactNode }) {
+    return React.createElement(HarkenContext.Provider, { value: contextValue as never }, children);
+  };
+}
+
+describe("useAnonymousId", () => {
+  let mockIdentityStore: ReturnType<typeof createMockIdentityStore>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockIdentityStore = createMockIdentityStore();
+  });
+
+  describe("context requirement", () => {
+    it("throws when used outside HarkenProvider", () => {
+      // Suppress console.error for expected error
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      expect(() => {
+        renderHook(() => useAnonymousId());
+      }).toThrow("useAnonymousId must be used within a HarkenProvider");
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe("loading state", () => {
+    it("starts with isLoading true and anonymousId null", () => {
+      mockIdentityStore.getAnonymousId.mockImplementation(
+        () => new Promise(() => {}) // Never resolves
+      );
+
+      const wrapper = createWrapper({
+        identityStore: mockIdentityStore,
+        client: {},
+        config: {},
+      });
+
+      const { result } = renderHook(() => useAnonymousId(), { wrapper });
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.anonymousId).toBeNull();
+    });
+
+    it("sets isLoading false after loading completes", async () => {
+      mockIdentityStore.getAnonymousId.mockResolvedValue("anon-123");
+
+      const wrapper = createWrapper({
+        identityStore: mockIdentityStore,
+        client: {},
+        config: {},
+      });
+
+      const { result } = renderHook(() => useAnonymousId(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+    });
+  });
+
+  describe("anonymousId retrieval", () => {
+    it("returns anonymousId from identityStore", async () => {
+      mockIdentityStore.getAnonymousId.mockResolvedValue("stable-uuid-abc");
+
+      const wrapper = createWrapper({
+        identityStore: mockIdentityStore,
+        client: {},
+        config: {},
+      });
+
+      const { result } = renderHook(() => useAnonymousId(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.anonymousId).toBe("stable-uuid-abc");
+      });
+
+      expect(mockIdentityStore.getAnonymousId).toHaveBeenCalledTimes(1);
+    });
+
+    it("returns different IDs for different stores", async () => {
+      const store1 = createMockIdentityStore();
+      const store2 = createMockIdentityStore();
+      store1.getAnonymousId.mockResolvedValue("id-from-store-1");
+      store2.getAnonymousId.mockResolvedValue("id-from-store-2");
+
+      const wrapper1 = createWrapper({
+        identityStore: store1,
+        client: {},
+        config: {},
+      });
+      const wrapper2 = createWrapper({
+        identityStore: store2,
+        client: {},
+        config: {},
+      });
+
+      const { result: result1 } = renderHook(() => useAnonymousId(), { wrapper: wrapper1 });
+      const { result: result2 } = renderHook(() => useAnonymousId(), { wrapper: wrapper2 });
+
+      await waitFor(() => {
+        expect(result1.current.anonymousId).toBe("id-from-store-1");
+      });
+      await waitFor(() => {
+        expect(result2.current.anonymousId).toBe("id-from-store-2");
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    it("handles storage errors gracefully", async () => {
+      mockIdentityStore.getAnonymousId.mockRejectedValue(new Error("Storage failed"));
+
+      const wrapper = createWrapper({
+        identityStore: mockIdentityStore,
+        client: {},
+        config: {},
+      });
+
+      const { result } = renderHook(() => useAnonymousId(), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Should have null ID but not crash
+      expect(result.current.anonymousId).toBeNull();
+    });
+  });
+
+  describe("cleanup", () => {
+    it("does not update state after unmount", async () => {
+      // Spy on console.error to detect React's unmounted component warning
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      let resolvePromise: (value: string) => void;
+      const promise = new Promise<string>((resolve) => {
+        resolvePromise = resolve;
+      });
+      mockIdentityStore.getAnonymousId.mockReturnValue(promise);
+
+      const wrapper = createWrapper({
+        identityStore: mockIdentityStore,
+        client: {},
+        config: {},
+      });
+
+      const { unmount } = renderHook(() => useAnonymousId(), { wrapper });
+
+      // Unmount before the promise resolves
+      unmount();
+
+      // Resolve after unmount - should not trigger setState on unmounted component
+      resolvePromise!("late-id");
+
+      // Wait for the async handler to run
+      await new Promise((resolve) => setTimeout(() => resolve(undefined), 10));
+
+      // Verify no React warning about updating unmounted component was logged
+      const reactWarnings = errorSpy.mock.calls.filter(
+        (call) => typeof call[0] === "string" && call[0].includes("unmounted component")
+      );
+      expect(reactWarnings).toHaveLength(0);
+
+      errorSpy.mockRestore();
+    });
+  });
+});

package/src/hooks/useAnonymousId.ts

@@ -1,5 +1,5 @@
-import { useState, useEffect, useContext } from 'react';
-import { HarkenContext } from '../context';
+import { useState, useEffect, useContext } from "react";
+import { HarkenContext } from "../context";
 
 /**
  * Hook to access the anonymous ID for the current installation.
@@ -31,7 +31,7 @@ export function useAnonymousId(): {
   const context = useContext(HarkenContext);
 
   if (!context) {
-    throw new Error('useAnonymousId must be used within a HarkenProvider');
+    throw new Error("useAnonymousId must be used within a HarkenProvider");
   }
 
   // Capture identityStore to satisfy TypeScript narrowing in useEffect

package/src/hooks/useAttachmentPicker.ts

@@ -6,10 +6,10 @@
  * - Warning when no sources are enabled
  */
 
-import { useState, useCallback, useMemo, useEffect } from 'react';
-import { useAttachmentUpload } from './useAttachmentUpload';
-import type { UseAttachmentUploadResult } from './useAttachmentUpload';
-import type { AttachmentPickerProps } from '../components/AttachmentPicker';
+import { useState, useCallback, useMemo, useEffect } from "react";
+import { useAttachmentUpload } from "./useAttachmentUpload";
+import type { UseAttachmentUploadResult } from "./useAttachmentUpload";
+import type { AttachmentPickerProps } from "../components/AttachmentPicker";
 
 /**
  * Configuration for which attachment sources are enabled.
@@ -39,7 +39,7 @@ export interface UseAttachmentPickerResult extends UseAttachmentUploadResult {
   /** Props to spread onto AttachmentPicker component */
   pickerProps: Pick<
     AttachmentPickerProps,
-    'visible' | 'onClose' | 'onTakePhoto' | 'onPickFromLibrary' | 'onPickDocument' | 'options'
+    "visible" | "onClose" | "onTakePhoto" | "onPickFromLibrary" | "onPickDocument" | "options"
   >;
 
   /** Which sources are enabled */
@@ -138,18 +138,18 @@ export function useAttachmentPicker(
   const handleTakePhoto = useCallback(async () => {
     setIsPickerVisible(false);
     try {
-      await pickImage('camera');
+      await pickImage("camera");
     } catch (e) {
-      console.error('[Harken] Failed to take photo:', e);
+      console.error("[Harken] Failed to take photo:", e);
     }
   }, [pickImage]);
 
   const handlePickFromLibrary = useCallback(async () => {
     setIsPickerVisible(false);
     try {
-      await pickImage('library');
+      await pickImage("library");
     } catch (e) {
-      console.error('[Harken] Failed to pick from library:', e);
+      console.error("[Harken] Failed to pick from library:", e);
     }
   }, [pickImage]);
 
@@ -158,7 +158,7 @@ export function useAttachmentPicker(
     try {
       await pickDocument();
     } catch (e) {
-      console.error('[Harken] Failed to pick document:', e);
+      console.error("[Harken] Failed to pick document:", e);
     }
   }, [pickDocument]);
 
@@ -175,8 +175,8 @@ export function useAttachmentPicker(
   const openPicker = useCallback(() => {
     if (enabledSourceCount === 0) {
       console.warn(
-        '[Harken] useAttachmentPicker: No attachment sources are enabled. ' +
-          'Enable at least one of: camera, library, or files.'
+        "[Harken] useAttachmentPicker: No attachment sources are enabled. " +
+          "Enable at least one of: camera, library, or files."
       );
       return;
     }

package/src/hooks/useAttachmentStatus.ts

@@ -4,9 +4,9 @@
  * Useful for components that display a single attachment with progress indicator.
  */
 
-import { useState, useEffect } from 'react';
-import { uploadQueueService } from '../services';
-import { UploadPhase, UploadProgress } from '../domain';
+import { useState, useEffect } from "react";
+import { uploadQueueService } from "../services";
+import type { UploadPhase, UploadProgress } from "../domain";
 
 /**
  * Status information for a single attachment.
@@ -52,9 +52,7 @@ export interface AttachmentStatus {
  * }
  * ```
  */
-export function useAttachmentStatus(
-  attachmentId: string
-): AttachmentStatus | null {
+export function useAttachmentStatus(attachmentId: string): AttachmentStatus | null {
   const [status, setStatus] = useState<AttachmentStatus | null>(() => {
     // Initialize with current state from queue
     const item = uploadQueueService.getItemByAttachmentId(attachmentId);
@@ -67,17 +65,15 @@ export function useAttachmentStatus(
   });
 
   useEffect(() => {
-    const unsubscribe = uploadQueueService.onProgress(
-      (progress: UploadProgress) => {
-        if (progress.attachmentId !== attachmentId) return;
+    const unsubscribe = uploadQueueService.onProgress((progress: UploadProgress) => {
+      if (progress.attachmentId !== attachmentId) return;
 
-        setStatus({
-          phase: progress.phase,
-          progress: progress.progress,
-          error: progress.error,
-        });
-      }
-    );
+      setStatus({
+        phase: progress.phase,
+        progress: progress.progress,
+        error: progress.error,
+      });
+    });
 
     return unsubscribe;
   }, [attachmentId]);