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

package/src/camera/cameraStateMachine.ts

@@ -1,264 +0,0 @@
-import type { ICameraCapability } from '@incodetech/infra';
-import {
-  type ActorRefFrom,
-  assign,
-  fromPromise,
-  setup,
-} from '@incodetech/infra';
-import { createCameraServices } from './cameraServices';
-import type { PermissionResult } from './types';
-
-export type CameraContext = {
-  camera: ICameraCapability;
-  config: {
-    facingMode?: 'user' | 'environment';
-    deviceId?: string;
-  };
-  stream: MediaStream | undefined;
-  permissionResult: PermissionResult | undefined;
-  error: string | undefined;
-  errorType:
-    | 'permission_denied'
-    | 'not_found'
-    | 'not_readable'
-    | 'overconstrained'
-    | 'security'
-    | 'abort'
-    | 'unknown'
-    | undefined;
-};
-
-export type CameraEvent =
-  | { type: 'START' }
-  | { type: 'STOP' }
-  | { type: 'PERMISSION_RESULT'; result: PermissionResult }
-  | { type: 'STREAM_READY'; stream: MediaStream }
-  | {
-      type: 'STREAM_ERROR';
-      error: string;
-      errorType: CameraContext['errorType'];
-    }
-  | { type: 'RESET' };
-
-export type CameraInput = {
-  camera: ICameraCapability;
-  config?: {
-    facingMode?: 'user' | 'environment';
-    deviceId?: string;
-  };
-};
-
-export const cameraMachine = setup({
-  types: {
-    context: {} as CameraContext,
-    events: {} as CameraEvent,
-    input: {} as CameraInput,
-  },
-  actors: {
-    checkPermission: fromPromise<
-      PermissionResult,
-      { camera: ICameraCapability }
-    >(async ({ input }) => {
-      const services = createCameraServices(input.camera);
-      return services.checkPermission();
-    }),
-    requestStream: fromPromise<
-      MediaStream,
-      { camera: ICameraCapability; config: CameraContext['config'] }
-    >(async ({ input }) => {
-      const services = createCameraServices(input.camera);
-      return services.requestStream(input.config);
-    }),
-  },
-  actions: {
-    setPermissionResult: assign({
-      permissionResult: ({ event }) => {
-        // Handle onDone events from fromPromise actors
-        if ('output' in event) {
-          return (event as { output: PermissionResult }).output;
-        }
-        // Handle manual PERMISSION_RESULT events
-        if (event.type === 'PERMISSION_RESULT') {
-          return event.result;
-        }
-        return undefined;
-      },
-    }),
-    setStream: assign({
-      stream: ({ event }) => {
-        // Handle onDone events from fromPromise actors
-        if ('output' in event) {
-          return (event as { output: MediaStream }).output;
-        }
-        // Handle manual STREAM_READY events
-        if (event.type === 'STREAM_READY') {
-          return event.stream;
-        }
-        return undefined;
-      },
-    }),
-    setError: assign({
-      error: ({ event }) => {
-        // Handle onError events from fromPromise actors
-        if ('error' in event && event.type?.startsWith?.('xstate.error')) {
-          const err = (event as unknown as { error: Error }).error;
-          return err.message || String(err);
-        }
-        // Handle manual STREAM_ERROR events
-        if (event.type === 'STREAM_ERROR') {
-          return event.error;
-        }
-        return undefined;
-      },
-      errorType: ({ event }) => {
-        // Handle onError events from fromPromise actors
-        if ('error' in event && event.type?.startsWith?.('xstate.error')) {
-          const err = (event as unknown as { error: Error }).error;
-          if (err.name === 'NotAllowedError') return 'permission_denied';
-          if (err.name === 'NotFoundError') return 'not_found';
-          if (err.name === 'NotReadableError') return 'not_readable';
-          if (err.name === 'OverconstrainedError') return 'overconstrained';
-          if (err.name === 'SecurityError') return 'security';
-          if (err.name === 'AbortError') return 'abort';
-          return 'unknown';
-        }
-        // Handle manual STREAM_ERROR events
-        if (event.type === 'STREAM_ERROR') {
-          return event.errorType;
-        }
-        return undefined;
-      },
-    }),
-    stopStream: ({ context }) => {
-      if (context.stream) {
-        const services = createCameraServices(context.camera);
-        services.stopStream(context.stream);
-      }
-    },
-    resetContext: assign(({ context }) => ({
-      camera: context.camera,
-      config: context.config,
-      stream: undefined,
-      permissionResult: undefined,
-      error: undefined,
-      errorType: undefined,
-    })),
-  },
-  guards: {
-    permissionGranted: ({ context }) => context.permissionResult === 'granted',
-    permissionDenied: ({ context }) => context.permissionResult === 'denied',
-    hasStream: ({ context }) => context.stream !== undefined,
-  },
-}).createMachine({
-  id: 'camera',
-  initial: 'idle',
-  context: ({ input }) => ({
-    camera: input.camera,
-    config: input.config ?? {},
-    stream: undefined,
-    permissionResult: undefined,
-    error: undefined,
-    errorType: undefined,
-  }),
-  states: {
-    idle: {
-      on: {
-        START: 'checkingPermission',
-      },
-    },
-
-    checkingPermission: {
-      invoke: {
-        id: 'checkPermission',
-        src: 'checkPermission',
-        input: ({ context }) => ({ camera: context.camera }),
-        onDone: {
-          target: 'routing',
-          actions: 'setPermissionResult',
-        },
-        onError: {
-          target: 'routing',
-          actions: assign({
-            permissionResult: () => 'prompt' as PermissionResult,
-          }),
-        },
-      },
-      on: {
-        STOP: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-
-    routing: {
-      always: [
-        {
-          target: 'requesting',
-          guard: 'permissionGranted',
-        },
-        {
-          target: 'error',
-          guard: 'permissionDenied',
-          actions: assign({
-            error: () => 'Camera permission denied',
-            errorType: () => 'permission_denied' as const,
-          }),
-        },
-        {
-          target: 'requesting',
-        },
-      ],
-    },
-
-    requesting: {
-      invoke: {
-        id: 'requestStream',
-        src: 'requestStream',
-        input: ({ context }) => ({
-          camera: context.camera,
-          config: context.config,
-        }),
-        onDone: {
-          target: 'streaming',
-          actions: 'setStream',
-        },
-        onError: {
-          target: 'error',
-          actions: 'setError',
-        },
-      },
-      on: {
-        STOP: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-
-    streaming: {
-      on: {
-        STOP: {
-          target: 'idle',
-          actions: ['stopStream', 'resetContext'],
-        },
-      },
-    },
-
-    error: {
-      on: {
-        RESET: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-        STOP: {
-          target: 'idle',
-          actions: 'resetContext',
-        },
-      },
-    },
-  },
-});
-
-export type CameraMachine = typeof cameraMachine;
-export type CameraActor = ActorRefFrom<CameraMachine>;

package/src/camera/index.ts

@@ -1,5 +0,0 @@
-export { createCameraActor } from './cameraActor';
-export type { CameraService, CameraState } from './cameraService';
-export { createCameraService } from './cameraService';
-export type { CameraActor, CameraMachine } from './cameraStateMachine';
-export type { CameraConfig, CameraErrorType, PermissionResult } from './types';

package/src/camera/types.ts

@@ -1,17 +0,0 @@
-import type { FacingMode } from '@incodetech/infra';
-
-export type CameraConfig = {
-  facingMode?: FacingMode;
-  deviceId?: string;
-};
-
-export type PermissionResult = 'granted' | 'denied' | 'prompt';
-
-export type CameraErrorType =
-  | 'permission_denied'
-  | 'not_found'
-  | 'not_readable'
-  | 'overconstrained'
-  | 'security'
-  | 'abort'
-  | 'unknown';

package/src/device/getBrowser.ts

@@ -1,31 +0,0 @@
-import { getUserAgent } from '@incodetech/infra';
-
-export type Browser = 'chrome' | 'firefox' | 'safari' | 'edge' | 'other';
-
-export function getBrowser(): Browser {
-  const userAgent = getUserAgent();
-
-  if (!userAgent) {
-    return 'other';
-  }
-
-  const ua = userAgent.toLowerCase();
-
-  if (ua.includes('edg/')) {
-    return 'edge';
-  }
-
-  if (ua.includes('chrome') && !ua.includes('edg/')) {
-    return 'chrome';
-  }
-
-  if (ua.includes('firefox')) {
-    return 'firefox';
-  }
-
-  if (ua.includes('safari') && !ua.includes('chrome')) {
-    return 'safari';
-  }
-
-  return 'other';
-}

package/src/device/getDeviceClass.ts

@@ -1,29 +0,0 @@
-import { getDeviceInfo } from '@incodetech/infra';
-
-export type DeviceClass = 'ios' | 'android' | 'desktop';
-
-export function getDeviceClass(): DeviceClass {
-  const { userAgent, platform, maxTouchPoints } = getDeviceInfo();
-
-  if (!userAgent) {
-    return 'desktop';
-  }
-
-  const ua = userAgent.toLowerCase();
-
-  const isIOS =
-    /iphone|ipad|ipod/.test(ua) ||
-    (platform === 'MacIntel' && maxTouchPoints > 1);
-
-  if (isIOS) {
-    return 'ios';
-  }
-
-  const isAndroid = /android/.test(ua);
-
-  if (isAndroid) {
-    return 'android';
-  }
-
-  return 'desktop';
-}

package/src/device/index.ts

@@ -1,2 +0,0 @@
-export { type Browser, getBrowser } from './getBrowser';
-export { type DeviceClass, getDeviceClass } from './getDeviceClass';

package/src/email/__mocks__/emailMocks.ts

@@ -1,59 +0,0 @@
-import { vi } from 'vitest';
-import type { EmailConfig, VerifyOtpResponse } from '../types';
-
-export const mockEmailConfig: EmailConfig = {
-  otpVerification: true,
-  otpExpirationInMinutes: 5,
-  prefill: false,
-  maxOtpAttempts: 3,
-};
-
-export const mockEmailConfigNoOtp: EmailConfig = {
-  ...mockEmailConfig,
-  otpVerification: false,
-};
-
-export const mockEmailConfigWithPrefill: EmailConfig = {
-  ...mockEmailConfig,
-  prefill: true,
-};
-
-export const mockPrefilledEmail = 'user@example.com';
-
-export function createMockFetchEmail(email = mockPrefilledEmail) {
-  return vi.fn().mockResolvedValue({ email });
-}
-
-export function createMockAddEmail(success = true) {
-  return vi.fn().mockResolvedValue({ success });
-}
-
-export function createMockSendEmailOtp() {
-  return vi.fn().mockResolvedValue(undefined);
-}
-
-export function createMockVerifyEmailOtp(
-  success = true,
-): () => Promise<VerifyOtpResponse> {
-  return vi.fn().mockResolvedValue({ success });
-}
-
-export function createFailingMockFetchEmail(error: string) {
-  return vi.fn().mockRejectedValue(new Error(error));
-}
-
-export function createFailingMockAddEmail(error: string) {
-  return vi.fn().mockRejectedValue(new Error(error));
-}
-
-export function createFailingMockVerifyEmailOtp(error: string) {
-  return vi.fn().mockRejectedValue(new Error(error));
-}
-
-export function createDelayedMock<T>(value: T, delayMs = 1000) {
-  return vi
-    .fn()
-    .mockImplementation(
-      () => new Promise((resolve) => setTimeout(() => resolve(value), delayMs)),
-    );
-}

package/src/email/emailActor.ts

@@ -1,15 +0,0 @@
-import { type ActorRefFrom, createActor } from '@incodetech/infra';
-import { type EmailMachine, emailMachine } from './emailStateMachine';
-import type { EmailConfig } from './types';
-
-export type CreateEmailActorOptions = {
-  config: EmailConfig;
-};
-
-export type EmailActor = ActorRefFrom<EmailMachine>;
-
-export function createEmailActor(options: CreateEmailActorOptions): EmailActor {
-  return createActor(emailMachine, {
-    input: { config: options.config },
-  }).start();
-}