@incodetech/core 2.0.0-alpha.2 → 2.0.0-alpha.4

package/src/camera/cameraService.test.ts

@@ -1,437 +0,0 @@
-import { MockCameraProvider } from '@incodetech/infra';
-import { describe, expect, it, vi } from 'vitest';
-import { createCameraService } from './cameraService';
-
-describe('createCameraService', () => {
-  describe('Initial state', () => {
-    it('should create a camera service', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      expect(service).toBeDefined();
-      expect(service.getState).toBeDefined();
-      expect(service.subscribe).toBeDefined();
-      expect(service.stop).toBeDefined();
-      expect(service.start).toBeDefined();
-      expect(service.captureFrame).toBeDefined();
-      expect(service.reset).toBeDefined();
-      expect(service.dispose).toBeDefined();
-
-      service.dispose();
-    });
-
-    it('should start in idle state', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      expect(service.getState()).toEqual({ status: 'idle' });
-
-      service.dispose();
-    });
-  });
-
-  describe('start()', () => {
-    it('should transition to checking state', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      expect(service.getState().status).toBe('checking');
-
-      service.dispose();
-    });
-
-    it('should eventually transition to streaming on success', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          const state = service.getState();
-          if (state.status !== 'streaming' && state.status !== 'error') {
-            throw new Error(`Still in state: ${state.status}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const state = service.getState();
-      expect(state.status).toBe('streaming');
-      if (state.status === 'streaming') {
-        expect(state.stream).toBe(mockStream);
-      }
-
-      service.dispose();
-    });
-
-    it('should transition to error state on failure', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(true);
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          const state = service.getState();
-          if (state.status !== 'error' && state.status !== 'streaming') {
-            throw new Error(`Still in state: ${state.status}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const state = service.getState();
-      expect(state.status).toBe('error');
-      if (state.status === 'error') {
-        expect(state.error).toBeDefined();
-        expect(state.errorType).toBeDefined();
-      }
-
-      service.dispose();
-    });
-
-    it('should pass through requesting state', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const service = createCameraService({ camera });
-      const observedStatuses: string[] = [];
-
-      service.subscribe((state) => {
-        if (!observedStatuses.includes(state.status)) {
-          observedStatuses.push(state.status);
-        }
-      });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'streaming') {
-            throw new Error('Not streaming yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      // Verify we passed through requesting state
-      expect(observedStatuses).toContain('requesting');
-
-      service.dispose();
-    });
-  });
-
-  describe('stop()', () => {
-    it('should transition from checking to idle', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      service.start();
-      service.stop();
-
-      expect(service.getState().status).toBe('idle');
-
-      service.dispose();
-    });
-  });
-
-  describe('captureFrame()', () => {
-    it('should return null when not streaming', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-      const video = document.createElement('video');
-
-      const result = service.captureFrame(video);
-
-      expect(result).toBeNull();
-
-      service.dispose();
-    });
-
-    it('should capture frame when streaming', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const video = document.createElement('video');
-      video.srcObject = mockStream;
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'streaming') {
-            throw new Error('Not streaming yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      // Now that we're in streaming state, capture a frame
-      const result = service.captureFrame(video);
-      // MockCameraProvider now returns ImageData
-      expect(result).toBeInstanceOf(ImageData);
-
-      service.dispose();
-    });
-
-    it('should return null when in checking state', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-      const video = document.createElement('video');
-
-      service.start();
-
-      // Should be in checking state
-      expect(service.getState().status).toBe('checking');
-      const result = service.captureFrame(video);
-      expect(result).toBeNull();
-
-      service.dispose();
-    });
-  });
-
-  describe('reset()', () => {
-    it('should reset from idle state', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      service.reset();
-
-      expect(service.getState().status).toBe('idle');
-
-      service.dispose();
-    });
-  });
-
-  describe('State mapping', () => {
-    it('should map checking state correctly', () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      const state = service.getState();
-      expect(state.status).toBe('checking');
-
-      service.dispose();
-    });
-
-    it('should map streaming state correctly with stream', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'streaming') {
-            throw new Error('Not streaming yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const state = service.getState();
-      expect(state.status).toBe('streaming');
-      if (state.status === 'streaming') {
-        expect(state.stream).toBe(mockStream);
-      }
-
-      service.dispose();
-    });
-
-    it('should map error state correctly with error details', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Test error', 'NotFoundError'),
-      );
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const state = service.getState();
-      expect(state.status).toBe('error');
-      if (state.status === 'error') {
-        expect(state.error).toBe('Test error');
-        expect(state.errorType).toBe('not_found');
-      }
-
-      service.dispose();
-    });
-
-    it('should map error state with default values when context values are missing', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(true, new Error());
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const state = service.getState();
-      expect(state.status).toBe('error');
-      if (state.status === 'error') {
-        expect(state.errorType).toBe('unknown');
-      }
-
-      service.dispose();
-    });
-  });
-
-  describe('State subscription', () => {
-    it('should notify subscribers on state changes', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const service = createCameraService({ camera });
-      const states: Array<{ status: string }> = [];
-
-      service.subscribe((state) => {
-        states.push(state);
-      });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'streaming') {
-            throw new Error('Not streaming yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      expect(states.length).toBeGreaterThan(0);
-      expect(states.some((s) => s.status === 'streaming')).toBe(true);
-
-      service.dispose();
-    });
-
-    it('should allow unsubscribing', async () => {
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-      const states: Array<{ status: string }> = [];
-
-      const unsubscribe = service.subscribe((state) => {
-        states.push(state);
-      });
-
-      // Initial state is pushed
-      expect(states.length).toBe(1);
-
-      // Unsubscribe before starting
-      unsubscribe();
-
-      service.start();
-
-      // Wait a tick
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      // Should not receive more states after unsubscribing
-      expect(states.length).toBe(1);
-
-      service.dispose();
-    });
-  });
-
-  describe('Configuration', () => {
-    it('should use provided config when requesting stream', async () => {
-      const camera = new MockCameraProvider();
-      const requestSpy = vi.spyOn(camera, 'requestStream');
-      const service = createCameraService({
-        camera,
-        config: {
-          facingMode: 'environment',
-          deviceId: 'device1',
-        },
-      });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (requestSpy.mock.calls.length === 0) {
-            throw new Error('requestStream not called yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      expect(requestSpy).toHaveBeenCalledWith({
-        facingMode: 'environment',
-        deviceId: 'device1',
-      });
-
-      service.dispose();
-    });
-  });
-
-  describe('Permission denied flow', () => {
-    it('should transition to error when permission is denied', async () => {
-      // Set permission to denied before creating service
-      const setPermissionState = (
-        globalThis as {
-          __setPermissionState?: (
-            state: 'granted' | 'denied' | 'prompt',
-          ) => void;
-        }
-      ).__setPermissionState;
-      if (setPermissionState) {
-        setPermissionState('denied');
-      }
-
-      const camera = new MockCameraProvider();
-      const service = createCameraService({ camera });
-
-      service.start();
-
-      await vi.waitFor(
-        () => {
-          if (service.getState().status !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const state = service.getState();
-      expect(state.status).toBe('error');
-      if (state.status === 'error') {
-        expect(state.errorType).toBe('permission_denied');
-      }
-
-      // Reset permission state
-      if (setPermissionState) {
-        setPermissionState('prompt');
-      }
-
-      service.dispose();
-    });
-  });
-});

package/src/camera/cameraService.ts

@@ -1,165 +0,0 @@
-import type { ICameraCapability } from '@incodetech/infra';
-import { createActor } from '@incodetech/infra';
-import { cameraMachine } from './cameraStateMachine';
-import type { CameraConfig, CameraErrorType } from './types';
-
-export type CameraState =
-  | { status: 'idle' }
-  | { status: 'checking' }
-  | { status: 'requesting' }
-  | { status: 'streaming'; stream: MediaStream }
-  | { status: 'error'; error: string; errorType: CameraErrorType };
-
-export type CameraServiceOptions = {
-  camera: ICameraCapability;
-  config?: CameraConfig;
-};
-
-/**
- * Creates a camera service instance for handling camera lifecycle.
- *
- * The camera service provides:
- * - State management with statuses: `idle`, `checking`, `requesting`, `streaming`, `error`
- * - Permission handling (checks current permission before requesting stream)
- * - Stream lifecycle management (start/stop)
- * - Frame capture from active stream
- * - Error handling with typed error states
- *
- * This is an internal service intended for use by higher-level modules like Selfie Capture and ID Capture.
- *
- * @param options - Configuration for the camera service
- * @param options.camera - The camera capability implementation (from Layer 0)
- * @param options.config - Optional camera configuration (facingMode, deviceId)
- * @returns A camera service instance with state subscription, API methods, and lifecycle controls
- *
- * @example
- * ```ts
- * import { BrowserCameraProvider } from '@incodetech/infra';
- * import { createCameraService } from '@incodetech/core/camera';
- *
- * const camera = new BrowserCameraProvider();
- * const cameraService = createCameraService({ camera });
- *
- * cameraService.subscribe((state) => {
- *   if (state.status === 'streaming') {
- *     videoElement.srcObject = state.stream;
- *   }
- * });
- *
- * cameraService.start();
- * ```
- */
-export function createCameraService(options: CameraServiceOptions) {
-  const actor = createActor(cameraMachine, {
-    input: {
-      camera: options.camera,
-      config: options.config,
-    },
-  }).start();
-
-  function getState(): CameraState {
-    const { value, context } = actor.getSnapshot();
-
-    if (value === 'idle') {
-      return { status: 'idle' };
-    }
-
-    if (value === 'checkingPermission' || value === 'routing') {
-      return { status: 'checking' };
-    }
-
-    if (value === 'requesting') {
-      return { status: 'requesting' };
-    }
-
-    if (value === 'streaming') {
-      if (!context.stream) {
-        return { status: 'idle' };
-      }
-      return {
-        status: 'streaming',
-        stream: context.stream,
-      };
-    }
-
-    if (value === 'error') {
-      return {
-        status: 'error',
-        error: context.error || 'Unknown error',
-        errorType: context.errorType || 'unknown',
-      };
-    }
-
-    return { status: 'idle' };
-  }
-
-  function subscribe(callback: (state: CameraState) => void) {
-    callback(getState());
-
-    const subscription = actor.subscribe(() => {
-      callback(getState());
-    });
-
-    return () => subscription.unsubscribe();
-  }
-
-  return {
-    /**
-     * Starts camera acquisition.
-     * Transitions from idle → checking permission → requesting → streaming.
-     */
-    start() {
-      actor.send({ type: 'START' });
-    },
-
-    /**
-     * Stops the camera stream and returns to idle state.
-     * Only effective when in requesting or streaming state.
-     */
-    stop() {
-      actor.send({ type: 'STOP' });
-    },
-
-    /**
-     * Captures a frame from the provided video element.
-     * Returns null if no stream is active or capture fails.
-     */
-    captureFrame(video: HTMLVideoElement): ImageData | null {
-      const snapshot = actor.getSnapshot();
-      if (snapshot.value !== 'streaming' || !snapshot.context.stream) {
-        return null;
-      }
-
-      const services = snapshot.context.camera;
-      return services.captureFrame(video);
-    },
-
-    /**
-     * Resets the camera service to idle state.
-     * Clears all state including stream, errors, and permission results.
-     */
-    reset() {
-      actor.send({ type: 'RESET' });
-    },
-
-    /**
-     * Gets the current camera state.
-     */
-    getState,
-
-    /**
-     * Subscribes to camera state changes.
-     * Returns an unsubscribe function.
-     */
-    subscribe,
-
-    /**
-     * Cleans up resources and stops the camera service.
-     */
-    dispose() {
-      actor.stop();
-    },
-  };
-}
-
-export type CameraService = ReturnType<typeof createCameraService>;

package/src/camera/cameraServices.test.ts

@@ -1,66 +0,0 @@
-import { MockCameraProvider } from '@incodetech/infra';
-import { describe, expect, it, vi } from 'vitest';
-import { createCameraServices } from './cameraServices';
-
-describe('createCameraServices', () => {
-  describe('checkPermission', () => {
-    it('should call camera capability checkPermission', async () => {
-      const camera = new MockCameraProvider();
-      const services = createCameraServices(camera);
-
-      const result = await services.checkPermission();
-
-      expect(['granted', 'denied', 'prompt']).toContain(result);
-    });
-  });
-
-  describe('requestStream', () => {
-    it('should call camera capability requestStream with config', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const requestSpy = vi.spyOn(camera, 'requestStream');
-
-      const services = createCameraServices(camera);
-
-      const stream = await services.requestStream({
-        facingMode: 'environment',
-        deviceId: 'device1',
-      });
-
-      expect(requestSpy).toHaveBeenCalledWith({
-        facingMode: 'environment',
-        deviceId: 'device1',
-      });
-      expect(stream).toBe(mockStream);
-    });
-  });
-
-  describe('stopStream', () => {
-    it('should call camera capability stopStream', () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      const stopSpy = vi.spyOn(camera, 'stopStream');
-
-      const services = createCameraServices(camera);
-
-      services.stopStream(mockStream);
-
-      expect(stopSpy).toHaveBeenCalledWith(mockStream);
-    });
-  });
-
-  describe('captureFrame', () => {
-    it('should call camera capability captureFrame', () => {
-      const camera = new MockCameraProvider();
-      const video = document.createElement('video');
-      const captureSpy = vi.spyOn(camera, 'captureFrame');
-
-      const services = createCameraServices(camera);
-
-      services.captureFrame(video);
-
-      expect(captureSpy).toHaveBeenCalledWith(video);
-    });
-  });
-});

package/src/camera/cameraServices.ts

@@ -1,26 +0,0 @@
-import type { ICameraCapability } from '@incodetech/infra';
-import { queryCameraPermission } from '@incodetech/infra';
-import type { CameraConfig } from './types';
-
-export function createCameraServices(camera: ICameraCapability) {
-  return {
-    async checkPermission() {
-      return queryCameraPermission();
-    },
-
-    async requestStream(config: CameraConfig) {
-      return camera.requestStream({
-        facingMode: config.facingMode,
-        deviceId: config.deviceId,
-      });
-    },
-
-    stopStream(stream: MediaStream) {
-      camera.stopStream(stream);
-    },
-
-    captureFrame(video: HTMLVideoElement) {
-      return camera.captureFrame(video);
-    },
-  };
-}