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

package/src/selfie/selfieErrorUtils.test.ts

@@ -1,116 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  getFaceErrorCodeFromUnknown,
-  isFaceErrorCode,
-  validateUploadResponse,
-} from './selfieErrorUtils';
-import { FACE_ERROR_CODES } from './types';
-
-describe('selfieErrorUtils', () => {
-  it('isFaceErrorCode returns true for known codes and false otherwise', () => {
-    expect(isFaceErrorCode(FACE_ERROR_CODES.FACE_NOT_FOUND)).toBe(true);
-    expect(isFaceErrorCode('NOT_A_CODE')).toBe(false);
-  });
-
-  it('getFaceErrorCodeFromUnknown extracts FaceErrorCode from Error.message', () => {
-    expect(
-      getFaceErrorCodeFromUnknown(new Error(FACE_ERROR_CODES.SERVER)),
-    ).toBe(FACE_ERROR_CODES.SERVER);
-    expect(getFaceErrorCodeFromUnknown(new Error('boom'))).toBeUndefined();
-  });
-
-  it('getFaceErrorCodeFromUnknown extracts FaceErrorCode from string', () => {
-    expect(getFaceErrorCodeFromUnknown(FACE_ERROR_CODES.BAD_REQUEST)).toBe(
-      FACE_ERROR_CODES.BAD_REQUEST,
-    );
-    expect(getFaceErrorCodeFromUnknown('nope')).toBeUndefined();
-  });
-
-  it('validateUploadResponse returns SERVER_ERROR when response is missing', () => {
-    expect(
-      validateUploadResponse({
-        config: {
-          showTutorial: false,
-          showPreview: false,
-          assistedOnboarding: false,
-          enableFaceRecording: false,
-          autoCaptureTimeout: 1,
-          captureAttempts: 1,
-          validateLenses: true,
-          validateFaceMask: true,
-          validateHeadCover: true,
-          validateClosedEyes: true,
-          validateBrightness: true,
-          deepsightLiveness: 'SINGLE_FRAME',
-        },
-        response: undefined,
-      }),
-    ).toBe(FACE_ERROR_CODES.SERVER);
-  });
-
-  it('validateUploadResponse returns LIVENESS_ERROR when confidence is not 0', () => {
-    expect(
-      validateUploadResponse({
-        config: {
-          showTutorial: false,
-          showPreview: false,
-          assistedOnboarding: false,
-          enableFaceRecording: false,
-          autoCaptureTimeout: 1,
-          captureAttempts: 1,
-          validateLenses: true,
-          validateFaceMask: true,
-          validateHeadCover: true,
-          validateClosedEyes: true,
-          validateBrightness: true,
-          deepsightLiveness: 'SINGLE_FRAME',
-        },
-        response: {
-          age: 0,
-          confidence: 1,
-          hasClosedEyes: false,
-          hasFaceMask: false,
-          hasHeadCover: false,
-          hasLenses: false,
-          isBright: true,
-          liveness: true,
-          imageBase64: '',
-          sessionStatus: 'ok',
-        },
-      }),
-    ).toBe(FACE_ERROR_CODES.LIVENESS);
-  });
-
-  it('validateUploadResponse respects config flags', () => {
-    expect(
-      validateUploadResponse({
-        config: {
-          showTutorial: false,
-          showPreview: false,
-          assistedOnboarding: false,
-          enableFaceRecording: false,
-          autoCaptureTimeout: 1,
-          captureAttempts: 1,
-          validateLenses: false,
-          validateFaceMask: false,
-          validateHeadCover: false,
-          validateClosedEyes: false,
-          validateBrightness: false,
-          deepsightLiveness: 'SINGLE_FRAME',
-        },
-        response: {
-          age: 0,
-          confidence: 0,
-          hasClosedEyes: true,
-          hasFaceMask: true,
-          hasHeadCover: true,
-          hasLenses: true,
-          isBright: false,
-          liveness: true,
-          imageBase64: '',
-          sessionStatus: 'ok',
-        },
-      }),
-    ).toBeUndefined();
-  });
-});

package/src/selfie/selfieErrorUtils.ts

@@ -1,66 +0,0 @@
-import type {
-  FaceErrorCode,
-  SelfieConfig,
-  SendFaceImageResponse,
-} from './types';
-import { FACE_ERROR_CODES } from './types';
-
-const FACE_ERROR_CODE_VALUES = Object.values(
-  FACE_ERROR_CODES,
-) as FaceErrorCode[];
-
-export const isFaceErrorCode = (value: string): value is FaceErrorCode => {
-  return FACE_ERROR_CODE_VALUES.includes(value as FaceErrorCode);
-};
-
-export const getFaceErrorCodeFromUnknown = (
-  value: unknown,
-): FaceErrorCode | undefined => {
-  if (value instanceof Error && typeof value.message === 'string') {
-    return isFaceErrorCode(value.message) ? value.message : undefined;
-  }
-  if (typeof value === 'string') {
-    return isFaceErrorCode(value) ? value : undefined;
-  }
-  return undefined;
-};
-
-type ValidateUploadResponseParams = {
-  config: SelfieConfig;
-  response: SendFaceImageResponse | undefined;
-};
-
-export const validateUploadResponse = ({
-  config,
-  response,
-}: ValidateUploadResponseParams): FaceErrorCode | undefined => {
-  if (!response) {
-    return FACE_ERROR_CODES.SERVER;
-  }
-
-  if (response.confidence !== 0) {
-    return FACE_ERROR_CODES.LIVENESS;
-  }
-
-  if (config.validateBrightness && !response.isBright) {
-    return FACE_ERROR_CODES.BRIGHTNESS;
-  }
-
-  if (config.validateLenses && response.hasLenses) {
-    return FACE_ERROR_CODES.LENSES;
-  }
-
-  if (config.validateFaceMask && response.hasFaceMask) {
-    return FACE_ERROR_CODES.MASK;
-  }
-
-  if (config.validateClosedEyes && response.hasClosedEyes) {
-    return FACE_ERROR_CODES.CLOSED_EYES;
-  }
-
-  if (config.validateHeadCover && response.hasHeadCover) {
-    return FACE_ERROR_CODES.HEAD_COVER;
-  }
-
-  return undefined;
-};

package/src/selfie/selfieManager.test.ts

@@ -1,297 +0,0 @@
-import { IncodeCanvas } from '@incodetech/infra';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  mockSelfieConfig,
-  mockSelfieConfigWithTutorial,
-} from './__mocks__/selfieMocks';
-import { createSelfieManager } from './selfieManager';
-
-vi.mock('../events/addEvent', () => ({
-  addEvent: vi.fn().mockResolvedValue(undefined),
-}));
-
-vi.mock('../permissions/permissionServices', () => ({
-  checkPermission: vi.fn().mockResolvedValue('prompt'),
-  requestPermission: vi.fn().mockResolvedValue('granted'),
-}));
-
-vi.mock('./selfieServices', () => ({
-  encryptSelfieImage: vi.fn().mockResolvedValue('encrypted'),
-  initializeCamera: vi.fn().mockResolvedValue({
-    stream: new MediaStream(),
-    provider: { dispose: vi.fn().mockResolvedValue(undefined) },
-  }),
-  startDetection: vi
-    .fn()
-    .mockImplementation(
-      ({ onUpdate }: { onUpdate: (status: string) => void }) => {
-        onUpdate('detecting');
-        return { cleanup: vi.fn(), reset: vi.fn() };
-      },
-    ),
-  startRecordingSession: vi.fn().mockResolvedValue(undefined),
-  stopRecording: vi.fn(),
-  stopStream: vi.fn(),
-  uploadSelfie: vi.fn().mockResolvedValue({
-    age: 0,
-    confidence: 0,
-    hasClosedEyes: false,
-    hasFaceMask: false,
-    hasHeadCover: false,
-    hasLenses: false,
-    isBright: true,
-    liveness: true,
-    imageBase64: '',
-    sessionStatus: 'ok',
-  }),
-}));
-
-describe('createSelfieManager', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('creates a manager with the expected API shape', () => {
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    expect(typeof manager.getState).toBe('function');
-    expect(typeof manager.subscribe).toBe('function');
-    expect(typeof manager.stop).toBe('function');
-
-    expect(typeof manager.load).toBe('function');
-    expect(typeof manager.nextStep).toBe('function');
-    expect(typeof manager.requestPermission).toBe('function');
-    expect(typeof manager.goToLearnMore).toBe('function');
-    expect(typeof manager.back).toBe('function');
-    expect(typeof manager.close).toBe('function');
-    expect(typeof manager.reset).toBe('function');
-    expect(typeof manager.retryCapture).toBe('function');
-    expect(typeof manager.capture).toBe('function');
-
-    manager.stop();
-  });
-
-  it('starts in idle state', () => {
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    expect(manager.getState()).toEqual({ status: 'idle' });
-    manager.stop();
-  });
-
-  it('goes to tutorial on load when showTutorial is true', async () => {
-    const { addEvent } = await import('../events/addEvent');
-    const manager = createSelfieManager({
-      config: mockSelfieConfigWithTutorial,
-    });
-
-    manager.load();
-
-    await vi.waitFor(() => {
-      expect(manager.getState().status).toBe('tutorial');
-    });
-
-    expect(vi.mocked(addEvent)).toHaveBeenCalledWith({
-      code: 'tutorialSelfie',
-      payload: { tutorialSelfie: true },
-    });
-
-    manager.stop();
-  });
-
-  it('goes to permissions on load when showTutorial is false and permission is not granted', async () => {
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-
-    manager.load();
-
-    await vi.waitFor(() => {
-      expect(manager.getState().status).toBe('permissions');
-    });
-
-    const state = manager.getState();
-    if (state.status === 'permissions') {
-      expect(state.permissionStatus).toBe('idle');
-    }
-
-    manager.stop();
-  });
-
-  it('supports learnMore navigation inside permissions', async () => {
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-
-    manager.load();
-    await vi.waitFor(() => {
-      expect(manager.getState().status).toBe('permissions');
-    });
-
-    manager.goToLearnMore();
-    await vi.waitFor(() => {
-      const state = manager.getState();
-      expect(state.status).toBe('permissions');
-      if (state.status === 'permissions') {
-        expect(state.permissionStatus).toBe('learnMore');
-      }
-    });
-
-    manager.back();
-    await vi.waitFor(() => {
-      const state = manager.getState();
-      expect(state.status).toBe('permissions');
-      if (state.status === 'permissions') {
-        expect(state.permissionStatus).toBe('idle');
-      }
-    });
-
-    manager.stop();
-  });
-
-  it('can be closed from any state', async () => {
-    const manager = createSelfieManager({
-      config: mockSelfieConfigWithTutorial,
-    });
-
-    manager.load();
-    await vi.waitFor(() => {
-      expect(manager.getState().status).toBe('tutorial');
-    });
-
-    manager.close();
-
-    await vi.waitFor(() => {
-      expect(manager.getState().status).toBe('closed');
-    });
-
-    manager.stop();
-  });
-
-  it('goes to permissions.requesting while permission request is pending', async () => {
-    const permissionServices = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(permissionServices.checkPermission).mockResolvedValue('prompt');
-    vi.mocked(permissionServices.requestPermission).mockImplementation(
-      () => new Promise(() => {}),
-    );
-
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    manager.load();
-
-    await vi.waitFor(() => {
-      expect(manager.getState().status).toBe('permissions');
-    });
-
-    manager.requestPermission();
-
-    await vi.waitFor(() => {
-      const state = manager.getState();
-      expect(state.status).toBe('permissions');
-      if (state.status === 'permissions') {
-        expect(state.permissionStatus).toBe('requesting');
-      }
-    });
-
-    manager.stop();
-  });
-
-  it('maps denied permission state', async () => {
-    const permissionServices = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(permissionServices.checkPermission).mockResolvedValue('denied');
-
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    manager.load();
-
-    await vi.waitFor(() => {
-      const state = manager.getState();
-      expect(state.status).toBe('permissions');
-      if (state.status === 'permissions') {
-        expect(state.permissionStatus).toBe('denied');
-      }
-    });
-
-    manager.stop();
-  });
-
-  it('reaches capture state when permission is granted and exposes stream', async () => {
-    const permissionServices = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(permissionServices.checkPermission).mockResolvedValue('granted');
-
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    manager.load();
-
-    await vi.waitFor(() => {
-      const state = manager.getState();
-      expect(state.status).toBe('capture');
-      if (state.status === 'capture') {
-        expect(state.captureStatus).toBe('detecting');
-        expect(state.stream).toBeDefined();
-      }
-    });
-
-    manager.stop();
-  });
-
-  it('can complete capture flow to finished and reset back to idle', async () => {
-    const permissionServices = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(permissionServices.checkPermission).mockResolvedValue('granted');
-
-    const selfieServices = await import('./selfieServices');
-    vi.mocked(selfieServices.startDetection).mockImplementation(
-      ({ onSuccess }: { onSuccess: (canvas: IncodeCanvas) => void }) => {
-        const raw = document.createElement('canvas');
-        raw.width = 10;
-        raw.height = 10;
-        onSuccess(new IncodeCanvas(raw));
-        return { cleanup: vi.fn(), reset: vi.fn() };
-      },
-    );
-
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    manager.load();
-
-    await vi.waitFor(
-      () => {
-        expect(manager.getState().status).toBe('finished');
-      },
-      { timeout: 4000 },
-    );
-
-    manager.reset();
-
-    await vi.waitFor(
-      () => {
-        expect(manager.getState()).toEqual({ status: 'idle' });
-      },
-      { timeout: 2000 },
-    );
-
-    manager.stop();
-  });
-
-  it('maps error state when camera initialization fails', async () => {
-    const permissionServices = await import(
-      '../permissions/permissionServices'
-    );
-    vi.mocked(permissionServices.checkPermission).mockResolvedValue('granted');
-
-    const selfieServices = await import('./selfieServices');
-    vi.mocked(selfieServices.initializeCamera).mockRejectedValueOnce(
-      new Error('INIT_FAILED'),
-    );
-
-    const manager = createSelfieManager({ config: mockSelfieConfig });
-    manager.load();
-
-    await vi.waitFor(() => {
-      const state = manager.getState();
-      expect(state.status).toBe('error');
-      if (state.status === 'error') {
-        expect(state.error).toContain('INIT_FAILED');
-      }
-    });
-
-    manager.stop();
-  });
-});