@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.3

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);
-    },
-  };
-}

package/src/camera/cameraStateMachine.test.ts

@@ -1,602 +0,0 @@
-import { createActor, MockCameraProvider } from '@incodetech/infra';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { cameraMachine } from './cameraStateMachine';
-
-const createTestActor = () => {
-  const camera = new MockCameraProvider();
-  return createActor(cameraMachine, {
-    input: { camera },
-  }).start();
-};
-
-// Helper to mock permission query result
-const mockPermissionQuery = (state: 'granted' | 'denied' | 'prompt') => {
-  const setPermissionState = (
-    globalThis as {
-      __setPermissionState?: (state: 'granted' | 'denied' | 'prompt') => void;
-    }
-  ).__setPermissionState;
-  if (setPermissionState) {
-    setPermissionState(state);
-  }
-};
-
-describe('CameraStateMachine', () => {
-  describe('Initial state', () => {
-    it('should start in idle state', () => {
-      const actor = createTestActor();
-
-      expect(actor.getSnapshot().value).toBe('idle');
-      actor.stop();
-    });
-
-    it('should have initial context with camera capability', () => {
-      const actor = createTestActor();
-
-      const { context } = actor.getSnapshot();
-      expect(context.camera).toBeDefined();
-      expect(context.stream).toBeUndefined();
-      expect(context.permissionResult).toBeUndefined();
-      expect(context.error).toBeUndefined();
-      expect(context.errorType).toBeUndefined();
-
-      actor.stop();
-    });
-  });
-
-  describe('START event', () => {
-    it('should transition from idle to checkingPermission', () => {
-      const actor = createTestActor();
-
-      actor.send({ type: 'START' });
-
-      expect(actor.getSnapshot().value).toBe('checkingPermission');
-      actor.stop();
-    });
-  });
-
-  describe('Permission checking flow', () => {
-    it('should transition to routing after permission check', async () => {
-      const actor = createTestActor();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          const snapshot = actor.getSnapshot();
-          expect(['routing', 'requesting', 'streaming']).toContain(
-            snapshot.value,
-          );
-        },
-        { timeout: 2000 },
-      );
-
-      actor.stop();
-    });
-
-    it('should set permission result in context', async () => {
-      const actor = createTestActor();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          const snapshot = actor.getSnapshot();
-          if (
-            snapshot.value === 'routing' ||
-            snapshot.value === 'requesting' ||
-            snapshot.value === 'streaming'
-          ) {
-            expect(snapshot.context.permissionResult).toBeDefined();
-          }
-        },
-        { timeout: 2000 },
-      );
-
-      actor.stop();
-    });
-  });
-
-  describe('Stream request flow', () => {
-    it('should transition to streaming on successful stream', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          const value = actor.getSnapshot().value;
-          if (value !== 'streaming' && value !== 'error') {
-            throw new Error(`Still in state: ${value}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const snapshot = actor.getSnapshot();
-      expect(snapshot.value).toBe('streaming');
-      expect(snapshot.context.stream).toBe(mockStream);
-
-      actor.stop();
-    });
-
-    it('should transition to error on stream failure', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(true);
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          const value = actor.getSnapshot().value;
-          if (value !== 'error' && value !== 'streaming') {
-            throw new Error(`Still in state: ${value}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const snapshot = actor.getSnapshot();
-      expect(snapshot.value).toBe('error');
-      expect(snapshot.context.error).toBeDefined();
-      expect(snapshot.context.errorType).toBeDefined();
-
-      actor.stop();
-    });
-  });
-
-  describe('STOP event', () => {
-    it('should transition from checkingPermission to idle', () => {
-      const actor = createTestActor();
-
-      actor.send({ type: 'START' });
-      actor.send({ type: 'STOP' });
-
-      expect(actor.getSnapshot().value).toBe('idle');
-      actor.stop();
-    });
-
-    it('should transition from requesting to idle', () => {
-      const actor = createTestActor();
-
-      actor.send({ type: 'START' });
-      actor.send({ type: 'STOP' });
-
-      expect(actor.getSnapshot().value).toBe('idle');
-      actor.stop();
-    });
-  });
-
-  describe('Routing state', () => {
-    beforeEach(() => {
-      // Reset permission mock to default
-      mockPermissionQuery('prompt');
-    });
-
-    it('should route to requesting when permission is granted', async () => {
-      // Set mock BEFORE creating actor
-      mockPermissionQuery('granted');
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      // Wait for streaming state (granted -> routing -> requesting -> streaming)
-      await vi.waitFor(
-        () => {
-          const value = actor.getSnapshot().value;
-          if (value !== 'streaming' && value !== 'error') {
-            throw new Error(`Still in state: ${value}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      expect(actor.getSnapshot().value).toBe('streaming');
-      expect(actor.getSnapshot().context.permissionResult).toBe('granted');
-
-      actor.stop();
-    });
-
-    it('should route to error when permission is denied', async () => {
-      // Set mock BEFORE creating actor
-      mockPermissionQuery('denied');
-      const camera = new MockCameraProvider();
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      // Wait for error state (denied -> routing -> error)
-      await vi.waitFor(
-        () => {
-          const value = actor.getSnapshot().value;
-          if (value !== 'error' && value !== 'streaming') {
-            throw new Error(`Still in state: ${value}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const snapshot = actor.getSnapshot();
-      expect(snapshot.value).toBe('error');
-      expect(snapshot.context.permissionResult).toBe('denied');
-      expect(snapshot.context.errorType).toBe('permission_denied');
-
-      actor.stop();
-    });
-
-    it('should route to requesting when permission is prompt', async () => {
-      // Set mock BEFORE creating actor
-      mockPermissionQuery('prompt');
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      // Wait for streaming (prompt -> routing -> requesting -> streaming)
-      await vi.waitFor(
-        () => {
-          const value = actor.getSnapshot().value;
-          if (value !== 'streaming' && value !== 'error') {
-            throw new Error(`Still in state: ${value}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      expect(actor.getSnapshot().value).toBe('streaming');
-      expect(actor.getSnapshot().context.permissionResult).toBe('prompt');
-
-      actor.stop();
-    });
-  });
-
-  describe('Streaming state', () => {
-    it('should transition to idle when STOP is sent from streaming', async () => {
-      const camera = new MockCameraProvider();
-      const mockStream = new MediaStream();
-      camera.setMockStream(mockStream);
-      const stopSpy = vi.spyOn(camera, 'stopStream');
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      // Wait for streaming state
-      await vi.waitFor(
-        () => {
-          const snapshot = actor.getSnapshot();
-          if (snapshot.value !== 'streaming' || !snapshot.context.stream) {
-            throw new Error(`Not streaming yet: ${snapshot.value}`);
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      // Send STOP
-      actor.send({ type: 'STOP' });
-
-      // STOP should transition immediately (synchronous)
-      const stopSnapshot = actor.getSnapshot();
-      expect(stopSnapshot.value).toBe('idle');
-
-      // stopStream should be called because stream was in context
-      expect(stopSpy).toHaveBeenCalled();
-
-      actor.stop();
-    });
-  });
-
-  describe('Error state', () => {
-    it('should transition to idle when RESET is sent from error', () => {
-      const actor = createTestActor();
-
-      // Manually transition to error state
-      actor.send({ type: 'START' });
-      actor.send({
-        type: 'STREAM_ERROR',
-        error: 'Test error',
-        errorType: 'unknown',
-      });
-
-      // Wait a tick for state update
-      const errorSnapshot = actor.getSnapshot();
-      if (errorSnapshot.value === 'error') {
-        actor.send({ type: 'RESET' });
-        expect(actor.getSnapshot().value).toBe('idle');
-        expect(actor.getSnapshot().context.error).toBeUndefined();
-        expect(actor.getSnapshot().context.errorType).toBeUndefined();
-      }
-
-      actor.stop();
-    });
-
-    it('should transition to idle when STOP is sent from error', () => {
-      const actor = createTestActor();
-
-      // Manually transition to error state
-      actor.send({ type: 'START' });
-      actor.send({
-        type: 'STREAM_ERROR',
-        error: 'Test error',
-        errorType: 'unknown',
-      });
-
-      // Wait a tick for state update
-      const errorSnapshot = actor.getSnapshot();
-      if (errorSnapshot.value === 'error') {
-        actor.send({ type: 'STOP' });
-        expect(actor.getSnapshot().value).toBe('idle');
-      }
-
-      actor.stop();
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should set error type for NotAllowedError', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Permission denied', 'NotAllowedError'),
-      );
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('permission_denied');
-
-      actor.stop();
-    });
-
-    it('should set error type for NotFoundError', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Camera not found', 'NotFoundError'),
-      );
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('not_found');
-
-      actor.stop();
-    });
-
-    it('should set error type for NotReadableError', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Camera in use', 'NotReadableError'),
-      );
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('not_readable');
-
-      actor.stop();
-    });
-
-    it('should set error type for OverconstrainedError', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Constraints not supported', 'OverconstrainedError'),
-      );
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('overconstrained');
-
-      actor.stop();
-    });
-
-    it('should set error type for SecurityError', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Security error', 'SecurityError'),
-      );
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('security');
-
-      actor.stop();
-    });
-
-    it('should set error type for AbortError', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(
-        true,
-        new DOMException('Request aborted', 'AbortError'),
-      );
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('abort');
-
-      actor.stop();
-    });
-
-    it('should set error type to unknown for unrecognized errors', async () => {
-      const camera = new MockCameraProvider();
-      camera.setShouldReject(true, new Error('Unknown error'));
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.errorType).toBe('unknown');
-      expect(errorSnapshot.context.error).toBe('Unknown error');
-
-      actor.stop();
-    });
-
-    it('should handle error without message', async () => {
-      const camera = new MockCameraProvider();
-      const errorWithoutMessage = new Error();
-      errorWithoutMessage.message = '';
-      camera.setShouldReject(true, errorWithoutMessage);
-      const actor = createActor(cameraMachine, {
-        input: { camera },
-      }).start();
-
-      actor.send({ type: 'START' });
-
-      await vi.waitFor(
-        () => {
-          if (actor.getSnapshot().value !== 'error') {
-            throw new Error('Not in error state yet');
-          }
-        },
-        { timeout: 5000, interval: 50 },
-      );
-
-      const errorSnapshot = actor.getSnapshot();
-      expect(errorSnapshot.value).toBe('error');
-      expect(errorSnapshot.context.error).toBeDefined();
-      expect(errorSnapshot.context.errorType).toBe('unknown');
-
-      actor.stop();
-    });
-  });
-
-  describe('Permission check error handling', () => {
-    it('should handle permission check failure gracefully', async () => {
-      const actor = createTestActor();
-
-      actor.send({ type: 'START' });
-
-      // Wait for permission check to complete (even if it fails)
-      await vi.waitFor(
-        () => {
-          const snapshot = actor.getSnapshot();
-          // Should transition to routing even on error (with prompt as default)
-          return (
-            snapshot.value === 'routing' ||
-            snapshot.value === 'requesting' ||
-            snapshot.value === 'streaming'
-          );
-        },
-        { timeout: 2000 },
-      );
-
-      actor.stop();
-    });
-  });
-});