@incodetech/core 2.0.0-alpha.1

package/src/camera/cameraStateMachine.ts

@@ -0,0 +1,264 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,29 @@
+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

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

package/src/email/__mocks__/emailMocks.ts

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,15 @@
+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();
+}