@qlover/create-app 0.6.2 → 0.7.0

package/dist/templates/react-app/__tests__/src/core/IOC.test.ts

@@ -0,0 +1,257 @@
+import { IOC, type IOCContainer, type IOCIdentifierMap } from '@/core/IOC';
+import { InversifyContainer } from '@/base/cases/InversifyContainer';
+import { IocRegisterImpl } from '@/core/registers/IocRegisterImpl';
+import { IOCIdentifier } from '@config/IOCIdentifier';
+import type { AppConfig } from '@/base/cases/AppConfig';
+
+describe('IOC Container Tests', () => {
+  let container: IOCContainer;
+  let mockAppConfig: AppConfig;
+
+  beforeEach(() => {
+    container = new InversifyContainer();
+    mockAppConfig = {
+      appName: '',
+      appVersion: '',
+      env: 'test',
+      userInfoStorageKey: '__fe_user_info__',
+      userTokenStorageKey: '__fe_user_token__',
+      openAiModels: [
+        'gpt-4o-mini',
+        'gpt-3.5-turbo',
+        'gpt-3.5-turbo-2',
+        'gpt-4',
+        'gpt-4-32k'
+      ],
+      openAiBaseUrl: '',
+      openAiToken: '',
+      openAiTokenPrefix: '',
+      openAiRequireToken: true,
+      loginUser: '',
+      loginPassword: '',
+      feApiBaseUrl: '',
+      userApiBaseUrl: '',
+      aiApiBaseUrl: 'https://api.openai.com/v1',
+      aiApiToken: '',
+      aiApiTokenPrefix: 'Bearer',
+      aiApiRequireToken: true,
+      bootHref: ''
+    };
+  });
+
+  describe('InversifyContainer', () => {
+    it('should create container with correct configuration', () => {
+      expect(container).toBeInstanceOf(InversifyContainer);
+    });
+
+    it('should bind and get services correctly', () => {
+      const mockService = { test: 'service' };
+      const mockKey = 'testKey';
+
+      container.bind(mockKey, mockService);
+      const result = container.get(mockKey);
+
+      expect(result).toBe(mockService);
+    });
+
+    it('should handle string identifiers correctly', () => {
+      const mockLogger = { info: vi.fn() };
+      container.bind(IOCIdentifier.Logger, mockLogger);
+
+      const result = container.get(IOCIdentifier.Logger);
+      expect(result).toBe(mockLogger);
+    });
+  });
+
+  describe('IOC Function', () => {
+    it('should be a function', () => {
+      expect(typeof IOC).toBe('function');
+    });
+
+    it('should accept string identifiers', () => {
+      // This test verifies that IOC function can be called with string identifiers
+      // The function should accept the identifier, but will throw if service is not bound
+      expect(() => {
+        IOC(IOCIdentifier.Logger);
+      }).toThrow();
+    });
+
+    it('should accept class constructors', () => {
+      // Mock class for testing
+      class TestService {
+        constructor() {}
+      }
+
+      // if service is not bound, it will return the class itself
+      const result = IOC(TestService);
+      expect(result).toBeInstanceOf(TestService);
+    });
+  });
+
+  describe('IocRegisterImpl', () => {
+    let registerImpl: IocRegisterImpl;
+
+    beforeEach(() => {
+      registerImpl = new IocRegisterImpl({
+        pathname: '/test',
+        appConfig: mockAppConfig
+      });
+    });
+
+    it('should create register implementation correctly', () => {
+      expect(registerImpl).toBeInstanceOf(IocRegisterImpl);
+    });
+
+    it('should return register list', () => {
+      const registerList = registerImpl.getRegisterList();
+      expect(Array.isArray(registerList)).toBe(true);
+      expect(registerList.length).toBeGreaterThan(0);
+    });
+
+    it('should register services without throwing', () => {
+      const mockManager = {
+        get: vi.fn(),
+        bind: vi.fn(),
+        implement: vi.fn(),
+        implemention: container
+      };
+
+      expect(() => {
+        registerImpl.register(container, mockManager);
+      }).not.toThrow();
+    });
+  });
+
+  describe('IOCIdentifierMap Type Safety', () => {
+    it('should have correct type mapping for JSON', () => {
+      // This test verifies that the type mapping is correct
+      const identifierMap: IOCIdentifierMap = {} as IOCIdentifierMap;
+
+      // TypeScript should enforce that these keys exist
+      expect(IOCIdentifier.JSON in identifierMap).toBeDefined();
+      expect(IOCIdentifier.LocalStorage in identifierMap).toBeDefined();
+      expect(IOCIdentifier.Logger in identifierMap).toBeDefined();
+      expect(IOCIdentifier.AppConfig in identifierMap).toBeDefined();
+    });
+
+    it('should have all required identifiers', () => {
+      const requiredIdentifiers = [
+        'JSON',
+        'LocalStorage',
+        'LocalStorageEncrypt',
+        'CookieStorage',
+        'Logger',
+        'FeApiToken',
+        'FeApiCommonPlugin',
+        'AppConfig',
+        'ApiMockPlugin',
+        'ApiCatchPlugin',
+        'DialogHandler'
+      ];
+
+      requiredIdentifiers.forEach((identifier) => {
+        expect(IOCIdentifier).toHaveProperty(identifier);
+      });
+    });
+  });
+
+  describe('Service Registration Integration', () => {
+    it('should register global services correctly', async () => {
+      const registerImpl = new IocRegisterImpl({
+        pathname: '/test',
+        appConfig: mockAppConfig
+      });
+
+      const mockManager = {
+        get: vi.fn(),
+        bind: vi.fn(),
+        implement: vi.fn(),
+        implemention: container
+      };
+
+      // This should not throw and should register services
+      expect(() => {
+        registerImpl.register(container, mockManager);
+      }).not.toThrow();
+    });
+
+    it('should handle app config registration', () => {
+      container.bind(IOCIdentifier.AppConfig, mockAppConfig);
+      const result = container.get(IOCIdentifier.AppConfig);
+
+      expect(result).toBe(mockAppConfig);
+      expect(result.appName).toBe('');
+      expect(result.env).toBe('test');
+    });
+
+    it('should handle logger registration', () => {
+      const mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn()
+      };
+
+      container.bind(IOCIdentifier.Logger, mockLogger);
+      const result = container.get(IOCIdentifier.Logger);
+
+      expect(result).toBe(mockLogger);
+      expect(typeof result.info).toBe('function');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle missing service gracefully', () => {
+      expect(() => {
+        container.get('NonExistentService');
+      }).toThrow();
+    });
+
+    it('should handle invalid identifier types', () => {
+      expect(() => {
+        container.get(null as never);
+      }).toThrow();
+    });
+  });
+
+  describe('Dependency Injection', () => {
+    it('should support injectable decorators', () => {
+      // This test verifies that the container supports @injectable decorators
+      // The autobind configuration should allow this
+      expect(container).toBeDefined();
+    });
+
+    it('should support singleton scope', () => {
+      // This test verifies that the container uses singleton scope by default
+      const service1 = { id: 'test' };
+      const service2 = { id: 'test' };
+
+      container.bind('TestService1', service1);
+      container.bind('TestService2', service2);
+
+      const result1 = container.get('TestService1');
+      const result2 = container.get('TestService2');
+
+      expect(result1).toBe(service1);
+      expect(result2).toBe(service2);
+    });
+  });
+
+  describe('IOCIdentifier Constants', () => {
+    it('should be frozen object', () => {
+      expect(Object.isFrozen(IOCIdentifier)).toBe(true);
+    });
+
+    it('should have string values', () => {
+      Object.values(IOCIdentifier).forEach((value) => {
+        expect(typeof value).toBe('string');
+      });
+    });
+
+    it('should have unique values', () => {
+      const values = Object.values(IOCIdentifier);
+      const uniqueValues = new Set(values);
+      expect(uniqueValues.size).toBe(values.length);
+    });
+  });
+});

package/dist/templates/react-app/__tests__/src/core/bootstraps/BootstrapsApp.test.ts

@@ -0,0 +1,72 @@
+import { InversifyContainer } from '@/base/cases/InversifyContainer';
+import { BootstrapApp } from '@/core/bootstraps/BootstrapApp';
+import type { BootstrapAppArgs } from '@/core/bootstraps/BootstrapApp';
+import { createIOCFunction } from '@qlover/corekit-bridge';
+import type { IOCIdentifierMap } from '@/core/IOC';
+import { name, version } from '../../../../package.json';
+import { browserGlobalsName } from '@config/common';
+
+// Mock IocRegisterImpl to properly handle registration
+vi.mock('@/core/registers/IocRegisterImpl', () => ({
+  IocRegisterImpl: vi.fn().mockImplementation((_options) => ({
+    getRegisterList: vi.fn().mockReturnValue([]),
+    register: vi.fn().mockImplementation((_container, _manager) => {
+      // Mock the actual registration process to avoid I18nService constructor issues
+      // This prevents the real registration from happening which causes the error
+    })
+  }))
+}));
+
+// Mock BootstrapsRegistry to avoid I18nService instantiation
+vi.mock('@/core/bootstraps/BootstrapsRegistry', () => ({
+  BootstrapsRegistry: vi.fn().mockImplementation(() => ({
+    register: vi.fn().mockReturnValue([])
+  }))
+}));
+
+describe('BootstrapApp', () => {
+  let mockArgs: BootstrapAppArgs;
+  let mockIOC: ReturnType<typeof createIOCFunction<IOCIdentifierMap>>;
+
+  beforeEach(() => {
+    // Reset all mocks
+    vi.clearAllMocks();
+
+    // Setup mock IOC with proper typing
+    const container = new InversifyContainer();
+    mockIOC = createIOCFunction<IOCIdentifierMap>(container);
+
+    // Setup test arguments
+    mockArgs = {
+      root: {},
+      bootHref: 'http://localhost:3000',
+      IOC: mockIOC
+    };
+  });
+
+  describe('main', () => {
+    it('should initialize bootstrap successfully', async () => {
+      const result = await BootstrapApp.main(mockArgs);
+
+      expect(result.bootHref).toBe('http://localhost:3000');
+      // default inject env,globals var, ioc
+
+      expect(
+        (mockArgs.root as Record<string, unknown>)[browserGlobalsName]
+      ).toBeDefined();
+
+      // Verify that the globals object is injected into root
+      const injectedGlobals = (mockArgs.root as Record<string, unknown>)[
+        browserGlobalsName
+      ] as Record<string, unknown>;
+      expect(injectedGlobals).toHaveProperty('logger');
+      expect(injectedGlobals).toHaveProperty('appConfig');
+      expect(
+        (injectedGlobals.appConfig as Record<string, unknown>).appName
+      ).toBe(name);
+      expect(
+        (injectedGlobals.appConfig as Record<string, unknown>).appVersion
+      ).toBe(version);
+    });
+  });
+});

package/dist/templates/react-app/__tests__/src/main.integration.test.tsx

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+describe('main.tsx Integration Tests', () => {
+  beforeAll(() => {
+    // Setup test environment
+    if (!document.getElementById('root')) {
+      const rootElement = document.createElement('div');
+      rootElement.id = 'root';
+      document.body.appendChild(rootElement);
+    }
+  });
+
+  afterAll(() => {
+    // Clean up DOM
+    const rootElement = document.getElementById('root');
+    if (rootElement) {
+      rootElement.remove();
+    }
+  });
+
+  beforeEach(() => {
+    // Clean up root element content
+    const rootElement = document.getElementById('root');
+    if (rootElement) {
+      rootElement.innerHTML = '';
+    }
+  });
+
+  it('should have main.tsx file', () => {
+    // Test if file exists
+    const mainPath = join(process.cwd(), 'src/main.tsx');
+    expect(existsSync(mainPath)).toBe(true);
+  });
+
+  it('should have main.tsx with correct structure', () => {
+    // Test file content structure
+    const mainPath = join(process.cwd(), 'src/main.tsx');
+    const content = readFileSync(mainPath, 'utf-8');
+
+    // Check if it contains necessary imports
+    expect(content).toContain('import');
+    expect(content).toContain('BootstrapApp');
+    expect(content).toContain('createRoot');
+  });
+
+  it('should have App.tsx file', () => {
+    // Test if App.tsx file exists
+    const appPath = join(process.cwd(), 'src/App.tsx');
+    expect(existsSync(appPath)).toBe(true);
+  });
+
+  it('should have BootstrapApp.ts file', () => {
+    // Test if BootstrapApp.ts file exists
+    const bootstrapPath = join(
+      process.cwd(),
+      'src/core/bootstraps/BootstrapApp.ts'
+    );
+    expect(existsSync(bootstrapPath)).toBe(true);
+  });
+});

package/dist/templates/react-app/__tests__/src/main.test.tsx

@@ -0,0 +1,46 @@
+import { BootstrapApp } from '@/core/bootstraps/BootstrapApp';
+
+// Mock BootstrapApp
+vi.mock('@/core/bootstraps/BootstrapApp', () => ({
+  BootstrapApp: {
+    main: vi.fn()
+  }
+}));
+
+// Mock react-dom
+vi.mock('react-dom/client', () => ({
+  createRoot: vi.fn(() => ({
+    render: vi.fn(),
+    unmount: vi.fn()
+  }))
+}));
+
+// Mock App component
+vi.mock('@/App', () => ({
+  default: vi.fn(() => 'MockedApp')
+}));
+
+describe('main.tsx', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('BootstrapApp initialization', () => {
+    it('should call BootstrapApp.main()', async () => {
+      await import('@/main');
+      expect(BootstrapApp.main).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Module loading', () => {
+    it('should load main module without errors', async () => {
+      const mainModule = await import('@/main');
+      expect(mainModule).toBeDefined();
+    });
+  });
+});

package/dist/templates/react-app/__tests__/src/uikit/components/BaseHeader.test.tsx

@@ -0,0 +1,88 @@
+import { render, screen } from '@testing-library/react';
+import { vi, expect } from 'vitest';
+import BaseHeader from '@/uikit/components/BaseHeader';
+import { PublicAssetsPath } from '@/base/cases/PublicAssetsPath';
+
+// Mock dependencies
+const mockPublicAssetsPath = new PublicAssetsPath('');
+
+vi.mock('@/core/IOC', () => ({
+  IOC: vi.fn((key) => {
+    if (key === 'AppConfig') {
+      return { appName: 'Test App' };
+    }
+    if (key === PublicAssetsPath) {
+      return mockPublicAssetsPath;
+    }
+    return {};
+  })
+}));
+
+// Mock child components
+vi.mock('@/uikit/components/ThemeSwitcher', () => ({
+  default: () => <div data-testid="theme-switcher">Theme Switcher</div>
+}));
+
+interface LocaleLinkProps {
+  children: React.ReactNode;
+  href: string;
+  className?: string;
+}
+
+vi.mock('@/uikit/components/LocaleLink', () => ({
+  default: ({ children, href, className }: LocaleLinkProps) => (
+    <a href={href} className={className} data-testid="locale-link">
+      {children}
+    </a>
+  )
+}));
+
+vi.mock('@/uikit/components/LanguageSwitcher', () => ({
+  default: () => <div data-testid="language-switcher">Language Switcher</div>
+}));
+
+vi.mock('@/uikit/components/LogoutButton', () => ({
+  default: () => <div data-testid="logout-button">Logout</div>
+}));
+
+describe('BaseHeader', () => {
+  it('renders header with correct structure', () => {
+    render(<BaseHeader />);
+    expect(screen.getByTestId('base-header')).toBeDefined();
+  });
+
+  it('renders logo and app name correctly', () => {
+    render(<BaseHeader />);
+    const logo = screen.getByTestId('base-header-logo');
+    const appName = screen.getByTestId('base-header-app-name');
+
+    expect(logo).toBeDefined();
+    expect(logo.getAttribute('src')).toBe('/logo.svg');
+    expect(logo.getAttribute('alt')).toBe('logo');
+    expect(appName).toBeDefined();
+    expect(appName.textContent).toBe('Test App');
+  });
+
+  it('renders theme and language switchers', () => {
+    render(<BaseHeader />);
+    expect(screen.getByTestId('theme-switcher')).toBeDefined();
+    expect(screen.getByTestId('language-switcher')).toBeDefined();
+  });
+
+  it('renders logout button when showLogoutButton is true', () => {
+    render(<BaseHeader showLogoutButton />);
+    expect(screen.getByTestId('logout-button')).toBeDefined();
+  });
+
+  it('does not render logout button when showLogoutButton is false', () => {
+    render(<BaseHeader showLogoutButton={false} />);
+    expect(screen.queryByTestId('logout-button')).toBeNull();
+  });
+
+  it('renders home link correctly', () => {
+    render(<BaseHeader />);
+    const link = screen.getByTestId('locale-link');
+    expect(link).toBeDefined();
+    expect(link.getAttribute('href')).toBe('/');
+  });
+});

package/dist/templates/react-app/config/app.router.ts

@@ -161,3 +161,158 @@ export const baseRoutes: RouteConfigValue[] = [
     }
   }
 ];
+
+export const baseNoLocaleRoutes: RouteConfigValue[] = [
+  {
+    path: '/',
+    element: 'base/Layout',
+    meta: {
+      category: 'main'
+    },
+    children: [
+      {
+        index: true,
+        element: 'base/HomePage',
+        meta: {
+          title: identifier.PAGE_HOME_TITLE,
+          description: identifier.PAGE_HOME_DESCRIPTION,
+          icon: 'home',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: 'about',
+        element: 'base/AboutPage',
+        meta: {
+          title: identifier.PAGE_ABOUT_TITLE,
+          description: identifier.PAGE_ABOUT_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: 'jsonStorage',
+        element: 'base/JSONStoragePage',
+        meta: {
+          title: identifier.PAGE_JSONSTORAGE_TITLE,
+          description: identifier.PAGE_JSONSTORAGE_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: 'request',
+        element: 'base/RequestPage',
+        meta: {
+          title: identifier.PAGE_REQUEST_TITLE,
+          description: identifier.PAGE_REQUEST_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: 'executor',
+        element: 'base/ExecutorPage',
+        meta: {
+          title: identifier.PAGE_EXECUTOR_TITLE,
+          description: identifier.PAGE_EXECUTOR_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: 'errorIdentifier',
+        element: 'base/ErrorIdentifierPage',
+        meta: {
+          title: identifier.PAGE_ERROR_IDENTIFIER_TITLE,
+          description: identifier.PAGE_ERROR_IDENTIFIER_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: '404',
+        element: '404',
+        meta: {
+          category: 'common',
+          title: identifier.PAGE_404_TITLE,
+          description: identifier.PAGE_404_DESCRIPTION,
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: '500',
+        element: '500',
+        meta: {
+          category: 'common',
+          title: identifier.PAGE_500_TITLE,
+          description: identifier.PAGE_500_DESCRIPTION,
+          localNamespace: 'common'
+        }
+      }
+    ]
+  },
+  {
+    path: '/',
+    element: 'auth/Layout',
+    meta: {
+      category: 'auth'
+    },
+    children: [
+      {
+        index: true,
+        element: 'auth/LoginPage'
+      },
+      {
+        path: 'login',
+        element: 'auth/LoginPage',
+        meta: {
+          title: identifier.PAGE_LOGIN_TITLE,
+          description: identifier.PAGE_LOGIN_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      },
+      {
+        path: 'register',
+        element: 'auth/RegisterPage',
+        meta: {
+          title: identifier.PAGE_REGISTER_TITLE,
+          description: identifier.PAGE_REGISTER_DESCRIPTION,
+          icon: 'info',
+          localNamespace: 'common'
+        }
+      }
+    ]
+  },
+  {
+    path: '404',
+    element: '404',
+    meta: {
+      category: 'common',
+      title: identifier.PAGE_404_TITLE,
+      description: identifier.PAGE_404_DESCRIPTION,
+      localNamespace: 'common'
+    }
+  },
+  {
+    path: '500',
+    element: '500',
+    meta: {
+      category: 'common',
+      title: identifier.PAGE_500_TITLE,
+      description: identifier.PAGE_500_DESCRIPTION,
+      localNamespace: 'common'
+    }
+  },
+  {
+    path: '*',
+    element: '404',
+    meta: {
+      category: 'common',
+      title: identifier.PAGE_404_TITLE,
+      description: identifier.PAGE_404_DESCRIPTION,
+      localNamespace: 'common'
+    }
+  }
+];

package/dist/templates/react-app/config/common.ts

@@ -16,7 +16,7 @@ export const overrideAntdThemeMode: ViteDeprecatedAntdOptions['mode'] =
   'noGlobals';
 
 /**
- * bootstrap ,not inject env
+ * 启动器环境变量注入黑名单
  */
 export const envBlackList = ['env', 'userNodeEnv'];
 
@@ -37,3 +37,11 @@ export const loggerStyles = {
  * - 但是不能只有 /
  */
 export const routerPrefix = '/router-root';
+
+/**
+ * 是否使用本地化路由
+ *
+ * - true: 使用本地化路由，路由会带有语言前缀 (例如: /en/home)
+ * - false: 不使用本地化路由，直接使用路径 (例如: /home)
+ */
+export const useLocaleRoutes = true;