@incodetech/web 2.0.0-alpha.1 → 2.0.0-alpha.11

package/src/flow/preloadFlow.test.ts

@@ -1,421 +0,0 @@
-import type { Mock } from 'vitest';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-type SubscribeCallback = (state: {
-  status: string;
-  currentStep?: string;
-  flow?: { flowModules: { key: string }[] };
-  error?: string;
-}) => void;
-
-const mockFlowManager = {
-  load: vi.fn(),
-  getState: vi.fn(() => ({ status: 'idle' })),
-  subscribe: vi.fn() as Mock<(cb: SubscribeCallback) => () => void>,
-  stop: vi.fn(),
-};
-
-const mockSetupSDK = vi.fn().mockResolvedValue(undefined);
-const mockFetchTheme = vi.fn().mockResolvedValue({
-  theme: { logo: 'logo.png' },
-  uiConfig: { logoSrc: 'logo.png' },
-});
-const mockWarmupWasmIfNeeded = vi.fn();
-const mockPreloadFirstModule = vi.fn();
-
-vi.mock('./flowInit', () => ({
-  createFlowManager: vi.fn(() => mockFlowManager),
-  setupSDK: (...args: unknown[]) => mockSetupSDK(...args),
-  fetchTheme: () => mockFetchTheme(),
-  warmupWasmIfNeeded: (...args: unknown[]) => mockWarmupWasmIfNeeded(...args),
-  preloadFirstModule: (...args: unknown[]) => mockPreloadFirstModule(...args),
-}));
-
-import {
-  consumePreloadedData,
-  getPreloadedData,
-  preloadIncodeFlow,
-} from './preloadFlow';
-
-describe('preloadFlow', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-    mockSetupSDK.mockResolvedValue(undefined);
-    mockFetchTheme.mockResolvedValue({
-      theme: { logo: 'logo.png' },
-      uiConfig: { logoSrc: 'logo.png' },
-    });
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  describe('preloadIncodeFlow', () => {
-    it('should return a PreloadHandle', () => {
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-1',
-      });
-
-      expect(handle).toBeDefined();
-      expect(typeof handle.isReady).toBe('boolean');
-      expect(typeof handle.error).toBe('object');
-      expect(typeof handle.waitUntilReady).toBe('function');
-      expect(typeof handle.cancel).toBe('function');
-    });
-
-    it('should start in loading state', () => {
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-2',
-      });
-
-      expect(handle.isReady).toBe(false);
-      expect(handle.error).toBeNull();
-    });
-
-    it('should call setupSDK with correct options', async () => {
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-3',
-        lang: 'es',
-      });
-
-      await vi.runAllTimersAsync();
-
-      expect(mockSetupSDK).toHaveBeenCalledWith({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-3',
-        lang: 'es',
-      });
-    });
-
-    it('should skip theme fetch when disableDashboardTheme is true', async () => {
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-4',
-        disableDashboardTheme: true,
-      });
-
-      await vi.runAllTimersAsync();
-
-      expect(mockFetchTheme).not.toHaveBeenCalled();
-    });
-
-    it('should fetch theme when disableDashboardTheme is false', async () => {
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-5',
-        disableDashboardTheme: false,
-      });
-
-      await vi.runAllTimersAsync();
-
-      expect(mockFetchTheme).toHaveBeenCalled();
-    });
-
-    it('should return same handle for same token', () => {
-      const handle1 = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-6',
-      });
-
-      const handle2 = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-6',
-      });
-
-      expect(handle1.isReady).toBe(handle2.isReady);
-    });
-
-    it('should become ready when flow manager reports ready', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-7',
-      });
-
-      await vi.runAllTimersAsync();
-
-      expect(handle.isReady).toBe(false);
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'ready',
-          currentStep: 'PHONE',
-          flow: { flowModules: [] },
-        });
-      }
-
-      expect(handle.isReady).toBe(true);
-    });
-
-    it('should call cancel and clean up state', async () => {
-      const unsubscribe = vi.fn();
-
-      mockFlowManager.subscribe.mockImplementation(() => {
-        return unsubscribe;
-      });
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-8',
-      });
-
-      const waitPromise = handle.waitUntilReady().catch((e) => e);
-
-      await vi.runAllTimersAsync();
-
-      handle.cancel();
-
-      const error = await waitPromise;
-      expect(error).toBeInstanceOf(Error);
-
-      expect(mockFlowManager.stop).toHaveBeenCalled();
-      expect(getPreloadedData('test-token-8')).toBeNull();
-    });
-
-    it('should warmup WASM when wasmConfig is provided and flow is ready', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-9',
-        wasmConfig: {
-          wasmPath: 'wasm.wasm',
-          wasmSimdPath: 'wasm-simd.wasm',
-          glueCodePath: 'glue.js',
-          modelsBasePath: 'models',
-        },
-      });
-
-      await vi.runAllTimersAsync();
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'ready',
-          currentStep: 'SELFIE',
-          flow: { flowModules: [{ key: 'SELFIE' }] },
-        });
-      }
-
-      expect(mockWarmupWasmIfNeeded).toHaveBeenCalled();
-    });
-
-    it('should preload first module when flow is ready', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-10',
-      });
-
-      await vi.runAllTimersAsync();
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'ready',
-          currentStep: 'PHONE',
-          flow: { flowModules: [] },
-        });
-      }
-
-      expect(mockPreloadFirstModule).toHaveBeenCalled();
-    });
-
-    it('should handle setupSDK failure and set error state', async () => {
-      mockSetupSDK.mockRejectedValueOnce(new Error('SDK setup failed'));
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-setup-error',
-      });
-
-      const waitPromise = handle.waitUntilReady().catch((e) => e);
-
-      await vi.runAllTimersAsync();
-
-      const error = await waitPromise;
-      expect(error).toBeInstanceOf(Error);
-      expect((error as Error).message).toBe('SDK setup failed');
-
-      expect(handle.error).toBe('SDK setup failed');
-      expect(getPreloadedData('test-token-setup-error')).toBeNull();
-    });
-
-    it('should handle non-Error thrown in setupSDK', async () => {
-      mockSetupSDK.mockRejectedValueOnce('string error');
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-string-error',
-      });
-
-      const waitPromise = handle.waitUntilReady().catch((e) => e);
-
-      await vi.runAllTimersAsync();
-
-      const error = await waitPromise;
-      expect(error).toBeInstanceOf(Error);
-      expect((error as Error).message).toBe('Failed to preload');
-
-      expect(handle.error).toBe('Failed to preload');
-    });
-  });
-
-  describe('getPreloadedData', () => {
-    it('should return null for unknown token', () => {
-      expect(getPreloadedData('unknown-token')).toBeNull();
-    });
-
-    it('should return preload state for known token', async () => {
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-11',
-      });
-
-      await vi.runAllTimersAsync();
-
-      const data = getPreloadedData('test-token-11');
-      expect(data).not.toBeNull();
-      expect(data?.status).toBe('loading');
-    });
-  });
-
-  describe('consumePreloadedData', () => {
-    it('should return null for unknown token', () => {
-      expect(consumePreloadedData('unknown-token')).toBeNull();
-    });
-
-    it('should return and delete preload state', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-12',
-      });
-
-      await vi.runAllTimersAsync();
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'ready',
-          currentStep: 'PHONE',
-          flow: { flowModules: [] },
-        });
-      }
-
-      const data = consumePreloadedData('test-token-12');
-      expect(data).not.toBeNull();
-      expect(data?.status).toBe('ready');
-
-      expect(getPreloadedData('test-token-12')).toBeNull();
-    });
-  });
-
-  describe('PreloadHandle.waitUntilReady', () => {
-    it('should resolve immediately if already ready', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-13',
-      });
-
-      await vi.runAllTimersAsync();
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'ready',
-          currentStep: 'PHONE',
-          flow: { flowModules: [] },
-        });
-      }
-
-      await expect(handle.waitUntilReady()).resolves.toBeUndefined();
-    });
-
-    it('should wait for ready state', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-14',
-      });
-
-      await vi.runAllTimersAsync();
-
-      const waitPromise = handle.waitUntilReady();
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'ready',
-          currentStep: 'PHONE',
-          flow: { flowModules: [] },
-        });
-      }
-
-      await expect(waitPromise).resolves.toBeUndefined();
-    });
-
-    it('should throw if preload errors', async () => {
-      let subscribeCallback: SubscribeCallback | undefined;
-
-      mockFlowManager.subscribe.mockImplementation((cb) => {
-        subscribeCallback = cb;
-        return vi.fn();
-      });
-
-      const handle = preloadIncodeFlow({
-        apiURL: 'https://api.example.com',
-        token: 'test-token-15',
-      });
-
-      const waitPromise = handle.waitUntilReady();
-
-      await vi.runAllTimersAsync();
-
-      if (subscribeCallback) {
-        subscribeCallback({
-          status: 'error',
-          error: 'Flow error',
-        });
-      }
-
-      await expect(waitPromise).rejects.toThrow('Flow error');
-    });
-  });
-});

package/src/flow/preloadFlow.ts

@@ -1,171 +0,0 @@
-import type { WasmConfig } from '@incodetech/core';
-import type { OrchestratedFlowReadyState } from '@incodetech/core/flow';
-import type { UiConfig } from '../shared/uiConfig/uiConfig';
-import type { ThemeConfig } from '../styles/themeTypes';
-import {
-  createFlowManager,
-  fetchTheme,
-  preloadFirstModule,
-  setupSDK,
-  warmupWasmIfNeeded,
-} from './flowInit';
-
-type PreloadConfig = {
-  apiURL: string;
-  token: string;
-  lang?: string;
-  disableDashboardTheme?: boolean;
-  wasmConfig?: WasmConfig;
-};
-
-type PreloadState = {
-  status: 'loading' | 'ready' | 'error';
-  flowManager: ReturnType<typeof createFlowManager>;
-  config: PreloadConfig;
-  theme?: ThemeConfig;
-  uiConfig?: UiConfig;
-  error?: string;
-  readyPromise: Promise<void>;
-  readyResolve: () => void;
-  readyReject: (error: Error) => void;
-  unsubscribe?: () => void;
-};
-
-const preloadCache = new Map<string, PreloadState>();
-
-export type PreloadHandle = {
-  get isReady(): boolean;
-  get error(): string | null;
-  waitUntilReady(): Promise<void>;
-  cancel(): void;
-};
-
-function createPreloadHandle(token: string): PreloadHandle {
-  const state = preloadCache.get(token);
-  if (!state) {
-    throw new Error('Preload state not found');
-  }
-
-  return {
-    get isReady() {
-      return state.status === 'ready';
-    },
-    get error() {
-      return state.status === 'error' ? (state.error ?? null) : null;
-    },
-    async waitUntilReady() {
-      if (state.status === 'ready') {
-        return;
-      }
-      if (state.status === 'error') {
-        throw new Error(state.error ?? 'Preload failed');
-      }
-      return state.readyPromise;
-    },
-    cancel() {
-      if (state.status === 'loading') {
-        if (state.unsubscribe) {
-          state.unsubscribe();
-        }
-        state.flowManager.stop();
-        state.readyReject(new Error('Preload cancelled'));
-        preloadCache.delete(token);
-      }
-    },
-  };
-}
-
-export function preloadIncodeFlow(config: PreloadConfig): PreloadHandle {
-  const { token } = config;
-
-  if (preloadCache.has(token)) {
-    return createPreloadHandle(token);
-  }
-
-  let readyResolve!: () => void;
-  let readyReject!: (error: Error) => void;
-  const readyPromise = new Promise<void>((resolve, reject) => {
-    readyResolve = resolve;
-    readyReject = reject;
-  });
-
-  const flowManager = createFlowManager();
-
-  const state: PreloadState = {
-    status: 'loading',
-    flowManager,
-    config,
-    readyPromise,
-    readyResolve,
-    readyReject,
-  };
-
-  preloadCache.set(token, state);
-
-  const preload = async () => {
-    try {
-      await setupSDK({
-        apiURL: config.apiURL,
-        token: config.token,
-        lang: config.lang,
-      });
-
-      const themePromise = config.disableDashboardTheme
-        ? Promise.resolve({})
-        : fetchTheme().then((result) => {
-            state.theme = result.theme;
-            state.uiConfig = result.uiConfig;
-          });
-
-      const unsubscribe = flowManager.subscribe((managerState) => {
-        if (managerState.status === 'ready') {
-          const readyState = managerState as OrchestratedFlowReadyState;
-          if (config.wasmConfig) {
-            warmupWasmIfNeeded(readyState, config.wasmConfig);
-          }
-          preloadFirstModule(readyState);
-          state.unsubscribe?.();
-          state.unsubscribe = undefined;
-          state.status = 'ready';
-          state.readyResolve();
-        } else if (managerState.status === 'error') {
-          state.unsubscribe?.();
-          state.unsubscribe = undefined;
-          state.status = 'error';
-          state.error = managerState.error;
-          state.readyReject(new Error(managerState.error));
-        }
-      });
-
-      state.unsubscribe = unsubscribe;
-
-      flowManager.load();
-
-      await themePromise;
-    } catch (error) {
-      state.status = 'error';
-      state.error =
-        error instanceof Error ? error.message : 'Failed to preload';
-      state.readyReject(
-        error instanceof Error ? error : new Error('Failed to preload'),
-      );
-      preloadCache.delete(token);
-    }
-  };
-
-  preload();
-
-  return createPreloadHandle(token);
-}
-
-export function getPreloadedData(token: string): PreloadState | null {
-  return preloadCache.get(token) ?? null;
-}
-
-export function consumePreloadedData(token: string): PreloadState | null {
-  const state = getPreloadedData(token);
-  if (state) {
-    preloadCache.delete(token);
-  }
-  return state;
-}

package/src/flow/styles.css

@@ -1,9 +0,0 @@
-@reference "../styles/tailwind.css";
-
-.IncodeFlow {
-  @apply w-full h-full;
-}
-
-.IncodeFlowModuleLoading {
-  @apply flex items-center justify-center h-full text-center;
-}

package/src/flow/unsupportedModule.css

@@ -1,21 +0,0 @@
-@reference "../styles/tailwind.css";
-
-.IncodeUnsupportedModule {
-  @apply flex flex-col items-center justify-center min-h-screen p-16;
-}
-
-.IncodeUnsupportedModuleContent {
-  @apply flex flex-col items-center gap-16 max-w-md text-center;
-}
-
-.IncodeUnsupportedModuleTitle {
-  @apply text-24 font-semibold text-text-body-primary;
-}
-
-.IncodeUnsupportedModuleMessage {
-  @apply text-16 text-text-body-secondary;
-}
-
-.IncodeUnsupportedModuleButton {
-  @apply mt-8;
-}

package/src/flow/unsupportedModule.tsx

@@ -1,39 +0,0 @@
-import type { FC } from 'preact/compat';
-import { useTranslation } from '../i18n';
-import { Button } from '../shared/button/button';
-import './unsupportedModule.css';
-
-export type UnsupportedModuleProps = {
-  moduleKey: string;
-  onNext: () => void;
-};
-
-export const UnsupportedModule: FC<UnsupportedModuleProps> = ({
-  moduleKey,
-  onNext,
-}) => {
-  const { t } = useTranslation();
-
-  return (
-    <section class="IncodeUnsupportedModule" aria-live="polite">
-      <div class="IncodeUnsupportedModuleContent">
-        <h2 class="IncodeUnsupportedModuleTitle">
-          {t('unsupportedModule.title', 'Module not available')}
-        </h2>
-        <p class="IncodeUnsupportedModuleMessage">
-          {t(
-            'unsupportedModule.message',
-            `The "${moduleKey}" module is not yet supported in this version.`,
-          )}
-        </p>
-        <Button
-          onClick={onNext}
-          class="IncodeUnsupportedModuleButton"
-          data-testid="unsupported-module-next-button"
-        >
-          {t('unsupportedModule.next', 'Next')}
-        </Button>
-      </div>
-    </section>
-  );
-};