@vlian/framework 1.0.0

package/dist/core/startup/renderApp.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 应用渲染模块
+ * 负责渲染React应用
+ */
+import type { Container, RootOptions } from 'react-dom/client';
+import type { StartOptions } from '../types';
+import type { InitializationContext } from '../initialization';
+import type { MonitoringService } from '../../utils/monitoring';
+import type { StateManager } from '../../state';
+/**
+ * 应用渲染器
+ */
+export declare class AppRenderer {
+    private root;
+    private container;
+    /**
+     * 初始化渲染器
+     *
+     * @param container - React应用的挂载容器
+     * @param rootOptions - React根节点配置选项
+     */
+    initialize(container: Container, rootOptions?: RootOptions): void;
+    /**
+     * 渲染应用
+     *
+     * 优化：
+     * 1. 默认启用安全防护（XSS防护）
+     * 2. 优化组件渲染性能
+     * 3. 缓存计算结果，避免重复计算
+     *
+     * @param options - 启动配置选项
+     * @param services - 服务实例
+     * @param context - 初始化上下文（可选）
+     */
+    renderApp(options: StartOptions, services: {
+        monitoring: MonitoringService;
+        stateManager: StateManager;
+    }, context?: InitializationContext): Promise<void>;
+    /**
+     * 渲染启动页
+     *
+     * 注意：启动页不使用 RouterWrapper，因为启动页应该在路由系统之前渲染
+     *
+     * @param options - 启动配置选项
+     * @param services - 服务实例
+     * @param onComplete - 启动页完成回调
+     */
+    renderSplashScreen(options: StartOptions, services: {
+        monitoring: MonitoringService;
+        stateManager: StateManager;
+    }, onComplete: (context: InitializationContext) => void): void;
+    /**
+     * 渲染错误页面
+     *
+     * @param options - 启动配置选项
+     * @param services - 服务实例
+     * @param error - 错误信息
+     */
+    renderError(options: StartOptions, services: {
+        monitoring: MonitoringService;
+    }): void;
+    /**
+     * 销毁渲染器
+     */
+    destroy(): void;
+    /**
+     * 获取容器
+     */
+    getContainer(): Container | null;
+}
+//# sourceMappingURL=renderApp.d.ts.map

package/dist/core/startup/renderApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderApp.d.ts","sourceRoot":"","sources":["../../../src/core/startup/renderApp.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAK/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAMhD;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,SAAS,CAA0B;IAE3C;;;;;OAKG;IACH,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;IAOjE;;;;;;;;;;;OAWG;IACG,SAAS,CACb,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE;QACR,UAAU,EAAE,iBAAiB,CAAC;QAC9B,YAAY,EAAE,YAAY,CAAC;KAC5B,EACD,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,IAAI,CAAC;IA0GhB;;;;;;;;OAQG;IACH,kBAAkB,CAChB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE;QACR,UAAU,EAAE,iBAAiB,CAAC;QAC9B,YAAY,EAAE,YAAY,CAAC;KAC5B,EACD,UAAU,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI,GACnD,IAAI;IAwCP;;;;;;OAMG;IACH,WAAW,CACT,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE;QACR,UAAU,EAAE,iBAAiB,CAAC;KAC/B,GACA,IAAI;IAuBP;;OAEG;IACH,OAAO,IAAI,IAAI;IAQf;;OAEG;IACH,YAAY,IAAI,SAAS,GAAG,IAAI;CAGjC"}

package/dist/core/startup/renderApp.js

@@ -0,0 +1,226 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * 应用渲染模块
+ * 负责渲染React应用
+ */ import { createRoot } from "react-dom/client";
+import { StrictMode } from "react";
+import { BasicLayout, DefaultApp, AppContextProvider } from "../app";
+import { ErrorBoundary } from "../error";
+import { InitializationErrorThrower } from "../initialization";
+import { SplashScreen } from "../splash";
+import { SecurityUtils } from "../../utils/security";
+import { getRouterManager } from "../router/RouterManager";
+import { RouterProvider } from "react-router-dom";
+/**
+ * 应用渲染器
+ */ export class AppRenderer {
+    /**
+   * 初始化渲染器
+   * 
+   * @param container - React应用的挂载容器
+   * @param rootOptions - React根节点配置选项
+   */ initialize(container, rootOptions) {
+        this.container = container;
+        if (!this.root) {
+            this.root = createRoot(container, rootOptions);
+        }
+    }
+    /**
+   * 渲染应用
+   * 
+   * 优化：
+   * 1. 默认启用安全防护（XSS防护）
+   * 2. 优化组件渲染性能
+   * 3. 缓存计算结果，避免重复计算
+   * 
+   * @param options - 启动配置选项
+   * @param services - 服务实例
+   * @param context - 初始化上下文（可选）
+   */ async renderApp(options, services, context) {
+        if (!this.root) {
+            throw new Error('渲染器未初始化，请先调用 initialize()');
+        }
+        // 获取初始语言（从 locale 配置中推断，或使用默认值）
+        const initialLocale = options.locale ? Object.keys(options.locale)[0] || 'zh-CN' : 'zh-CN';
+        // 检查路由是否已启用
+        // 路由启用的条件：配置了 router 且 enabled !== false 且 enabled !== 'disabled'
+        const routerEnabled = options.router ? options.router.enabled !== false && options.router.enabled !== 'disabled' : false;
+        // 检查路由管理器是否已初始化（运行时状态）
+        const routerManager = getRouterManager();
+        const router = routerManager.getRouter();
+        // const isRouterInitialized = routerManager.isRouterEnabled();
+        // 如果路由已启用且已初始化，使用 RouterProvider（路由系统接管渲染）
+        // 否则直接渲染应用内容（不使用路由系统）
+        const shouldUseRouter = routerEnabled && router !== null;
+        // 安全性增强：应用默认安全策略
+        // 默认启用 XSS 防护、配置验证和用户输入清理
+        const securityConfig = {
+            enableXSSProtection: options.security?.enableXSSProtection ?? true,
+            validateConfig: options.security?.validateConfig ?? true,
+            sanitizeUserInput: options.security?.sanitizeUserInput ?? true,
+            csrf: options.security?.csrf
+        };
+        // 如果启用了安全模式（默认启用），对配置进行验证
+        if (securityConfig.enableXSSProtection) {
+            if (securityConfig.validateConfig) {
+                // 验证配置项中可能包含的字符串内容
+                try {
+                    const configStr = JSON.stringify(options);
+                    const validation = SecurityUtils.validateInput(configStr);
+                    if (!validation.safe) {
+                        services.monitoring.captureError(new Error('配置项包含不安全内容'), {
+                            reason: validation.reason
+                        });
+                    }
+                } catch (error) {
+                // 忽略序列化错误（某些配置项可能包含不可序列化的内容）
+                }
+            }
+            // 初始化 CSRF 防护（如果启用）
+            if (securityConfig.csrf?.enabled !== false) {
+                // 异步初始化 CSRF，但不阻塞渲染
+                import("../../utils/csrf").then(({ initCSRFManager })=>{
+                    initCSRFManager({
+                        headerName: securityConfig.csrf?.headerName,
+                        cookieName: securityConfig.csrf?.cookieName,
+                        getToken: securityConfig.csrf?.getToken,
+                        validateToken: securityConfig.csrf?.validateToken
+                    });
+                }).catch((error)=>{
+                    // CSRF 初始化失败不影响应用启动，但记录警告
+                    if (process.env.NODE_ENV === 'development') {
+                        console.warn('CSRF 防护初始化失败:', error);
+                    }
+                });
+            }
+        }
+        // 优化：缓存错误处理函数，避免每次渲染都创建新函数
+        const handleError = (error)=>{
+            services.monitoring.captureError(error);
+        };
+        this.root.render(/*#__PURE__*/ _jsx(StrictMode, {
+            children: /*#__PURE__*/ _jsxs(ErrorBoundary, {
+                fallback: options.errorFallback,
+                onError: handleError,
+                children: [
+                    /*#__PURE__*/ _jsx(InitializationErrorThrower, {}),
+                    /*#__PURE__*/ _jsx(AppContextProvider, {
+                        initialTheme: options.theme,
+                        initialLocale: initialLocale,
+                        initialAntdConfig: options.antd,
+                        initialInitializationContext: context,
+                        stateManager: services.stateManager,
+                        antdApp: options.antdApp,
+                        children: /*#__PURE__*/ _jsx(BasicLayout, {
+                            children: shouldUseRouter ? // 启用路由时，使用 RouterProvider（路由内容由路由配置决定）
+                            /*#__PURE__*/ _jsx(RouterProvider, {
+                                router: router
+                            }) : // 未启用路由时，直接渲染应用内容
+                            options.app || /*#__PURE__*/ _jsx(DefaultApp, {})
+                        })
+                    })
+                ]
+            })
+        }));
+    }
+    /**
+   * 渲染启动页
+   * 
+   * 注意：启动页不使用 RouterWrapper，因为启动页应该在路由系统之前渲染
+   * 
+   * @param options - 启动配置选项
+   * @param services - 服务实例
+   * @param onComplete - 启动页完成回调
+   */ renderSplashScreen(options, services, onComplete) {
+        if (!this.root) {
+            throw new Error('渲染器未初始化，请先调用 initialize()');
+        }
+        // 获取初始语言（从 locale 配置中推断，或使用默认值）
+        const initialLocale = options.locale ? Object.keys(options.locale)[0] || 'zh-CN' : 'zh-CN';
+        this.root.render(/*#__PURE__*/ _jsx(StrictMode, {
+            children: /*#__PURE__*/ _jsxs(ErrorBoundary, {
+                fallback: options.errorFallback,
+                onError: (error)=>{
+                    services.monitoring.captureError(error);
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(InitializationErrorThrower, {}),
+                    /*#__PURE__*/ _jsx(AppContextProvider, {
+                        initialTheme: options.theme,
+                        initialLocale: initialLocale,
+                        initialAntdConfig: options.antd,
+                        stateManager: services.stateManager,
+                        antdApp: options.antdApp,
+                        children: /*#__PURE__*/ _jsx(BasicLayout, {
+                            children: /*#__PURE__*/ _jsx(SplashScreen, {
+                                options: options,
+                                onComplete: onComplete
+                            })
+                        })
+                    })
+                ]
+            })
+        }));
+    }
+    /**
+   * 渲染错误页面
+   * 
+   * @param options - 启动配置选项
+   * @param services - 服务实例
+   * @param error - 错误信息
+   */ renderError(options, services) {
+        if (!this.root) {
+            throw new Error('渲染器未初始化，请先调用 initialize()');
+        }
+        this.root.render(/*#__PURE__*/ _jsx(StrictMode, {
+            children: /*#__PURE__*/ _jsxs(ErrorBoundary, {
+                fallback: options.errorFallback,
+                onError: (err)=>{
+                    services.monitoring.captureError(err);
+                    if (options.errorMonitor?.onError) {
+                        options.errorMonitor.onError(err);
+                    }
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(InitializationErrorThrower, {}),
+                    /*#__PURE__*/ _jsx("div", {
+                        children: "框架启动失败"
+                    })
+                ]
+            })
+        }));
+    }
+    /**
+   * 销毁渲染器
+   */ destroy() {
+        if (this.root) {
+            this.root.unmount();
+            this.root = null;
+        }
+        this.container = null;
+    }
+    /**
+   * 获取容器
+   */ getContainer() {
+        return this.container;
+    }
+    constructor(){
+        _define_property(this, "root", null);
+        _define_property(this, "container", null);
+    }
+}
+
+//# sourceMappingURL=renderApp.js.map

package/dist/core/startup/renderApp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/startup/renderApp.tsx"],"sourcesContent":["/**\n * 应用渲染模块\n * 负责渲染React应用\n */\n\nimport { createRoot } from 'react-dom/client';\nimport type { Root } from 'react-dom/client';\nimport { StrictMode } from 'react';\nimport type { Container, RootOptions } from 'react-dom/client';\nimport { BasicLayout, DefaultApp, AppContextProvider } from '../app';\nimport type { LangType } from '../../library/locale/types';\nimport { ErrorBoundary } from '../error';\nimport { InitializationErrorThrower } from '../initialization';\nimport type { StartOptions } from '../types';\nimport type { InitializationContext } from '../initialization';\nimport type { MonitoringService } from '../../utils/monitoring';\nimport type { StateManager } from '../../state';\nimport { SplashScreen } from '../splash';\nimport { SecurityUtils } from '../../utils/security';\nimport { getRouterManager } from '../router/RouterManager';\nimport { RouterProvider } from \"react-router-dom\";\n\n/**\n * 应用渲染器\n */\nexport class AppRenderer {\n  private root: Root | null = null;\n  private container: Container | null = null;\n\n  /**\n   * 初始化渲染器\n   * \n   * @param container - React应用的挂载容器\n   * @param rootOptions - React根节点配置选项\n   */\n  initialize(container: Container, rootOptions?: RootOptions): void {\n    this.container = container;\n    if (!this.root) {\n      this.root = createRoot(container, rootOptions);\n    }\n  }\n\n  /**\n   * 渲染应用\n   * \n   * 优化：\n   * 1. 默认启用安全防护（XSS防护）\n   * 2. 优化组件渲染性能\n   * 3. 缓存计算结果，避免重复计算\n   * \n   * @param options - 启动配置选项\n   * @param services - 服务实例\n   * @param context - 初始化上下文（可选）\n   */\n  async renderApp(\n    options: StartOptions,\n    services: {\n      monitoring: MonitoringService;\n      stateManager: StateManager;\n    },\n    context?: InitializationContext\n  ): Promise<void> {\n    if (!this.root) {\n      throw new Error('渲染器未初始化，请先调用 initialize()');\n    }\n\n    // 获取初始语言（从 locale 配置中推断，或使用默认值）\n    const initialLocale: LangType = options.locale\n      ? (Object.keys(options.locale)[0] as LangType) || 'zh-CN'\n      : 'zh-CN';\n\n    // 检查路由是否已启用\n    // 路由启用的条件：配置了 router 且 enabled !== false 且 enabled !== 'disabled'\n    const routerEnabled = options.router\n      ? options.router.enabled !== false && options.router.enabled !== 'disabled'\n      : false;\n    \n    // 检查路由管理器是否已初始化（运行时状态）\n    const routerManager = getRouterManager();\n    const router = routerManager.getRouter();\n    // const isRouterInitialized = routerManager.isRouterEnabled();\n\n    // 如果路由已启用且已初始化，使用 RouterProvider（路由系统接管渲染）\n    // 否则直接渲染应用内容（不使用路由系统）\n    const shouldUseRouter = routerEnabled && router !== null;\n\n    // 安全性增强：应用默认安全策略\n    // 默认启用 XSS 防护、配置验证和用户输入清理\n    const securityConfig = {\n      enableXSSProtection: options.security?.enableXSSProtection ?? true,\n      validateConfig: options.security?.validateConfig ?? true,\n      sanitizeUserInput: options.security?.sanitizeUserInput ?? true,\n      csrf: options.security?.csrf,\n    };\n\n    // 如果启用了安全模式（默认启用），对配置进行验证\n    if (securityConfig.enableXSSProtection) {\n      if (securityConfig.validateConfig) {\n        // 验证配置项中可能包含的字符串内容\n        try {\n          const configStr = JSON.stringify(options);\n          const validation = SecurityUtils.validateInput(configStr);\n          if (!validation.safe) {\n            services.monitoring.captureError(\n              new Error('配置项包含不安全内容'),\n              { reason: validation.reason }\n            );\n          }\n        } catch (error) {\n          // 忽略序列化错误（某些配置项可能包含不可序列化的内容）\n        }\n      }\n\n      // 初始化 CSRF 防护（如果启用）\n      if (securityConfig.csrf?.enabled !== false) {\n        // 异步初始化 CSRF，但不阻塞渲染\n        import('../../utils/csrf').then(({ initCSRFManager }) => {\n          initCSRFManager({\n            headerName: securityConfig.csrf?.headerName,\n            cookieName: securityConfig.csrf?.cookieName,\n            getToken: securityConfig.csrf?.getToken,\n            validateToken: securityConfig.csrf?.validateToken,\n          });\n        }).catch((error) => {\n          // CSRF 初始化失败不影响应用启动，但记录警告\n          if (process.env.NODE_ENV === 'development') {\n            console.warn('CSRF 防护初始化失败:', error);\n          }\n        });\n      }\n    }\n\n    // 优化：缓存错误处理函数，避免每次渲染都创建新函数\n    const handleError = (error: unknown) => {\n      services.monitoring.captureError(error);\n    };\n\n    this.root.render(\n      <StrictMode>\n        <ErrorBoundary\n          fallback={options.errorFallback}\n          onError={handleError}\n        >\n          <InitializationErrorThrower />\n          <AppContextProvider\n            initialTheme={options.theme}\n            initialLocale={initialLocale}\n            initialAntdConfig={options.antd}\n            initialInitializationContext={context}\n            stateManager={services.stateManager}\n            antdApp={options.antdApp}\n          >\n            <BasicLayout>\n              {shouldUseRouter ? (\n                // 启用路由时，使用 RouterProvider（路由内容由路由配置决定）\n                <RouterProvider router={router} />\n              ) : (\n                // 未启用路由时，直接渲染应用内容\n                options.app || <DefaultApp />\n              )}\n            </BasicLayout>\n          </AppContextProvider>\n        </ErrorBoundary>\n      </StrictMode>\n    );\n  }\n\n  /**\n   * 渲染启动页\n   * \n   * 注意：启动页不使用 RouterWrapper，因为启动页应该在路由系统之前渲染\n   * \n   * @param options - 启动配置选项\n   * @param services - 服务实例\n   * @param onComplete - 启动页完成回调\n   */\n  renderSplashScreen(\n    options: StartOptions,\n    services: {\n      monitoring: MonitoringService;\n      stateManager: StateManager;\n    },\n    onComplete: (context: InitializationContext) => void\n  ): void {\n    if (!this.root) {\n      throw new Error('渲染器未初始化，请先调用 initialize()');\n    }\n\n    // 获取初始语言（从 locale 配置中推断，或使用默认值）\n    const initialLocale: LangType = options.locale\n      ? (Object.keys(options.locale)[0] as LangType) || 'zh-CN'\n      : 'zh-CN';\n\n    this.root.render(\n      <StrictMode>\n        <ErrorBoundary\n          fallback={options.errorFallback}\n          onError={(error) => {\n            services.monitoring.captureError(error);\n          }}\n        >\n          <InitializationErrorThrower />\n          <AppContextProvider\n            initialTheme={options.theme}\n            initialLocale={initialLocale}\n            initialAntdConfig={options.antd}\n            stateManager={services.stateManager}\n            antdApp={options.antdApp}\n          >\n            {/* \n              启动页不使用 RouterWrapper，因为：\n              1. 启动页应该在路由系统初始化之前渲染\n              2. 启动页完成后才会渲染主应用，此时路由系统已经初始化完成\n            */}\n            <BasicLayout>\n              <SplashScreen options={options} onComplete={onComplete} />\n            </BasicLayout>\n          </AppContextProvider>\n        </ErrorBoundary>\n      </StrictMode>\n    );\n  }\n\n  /**\n   * 渲染错误页面\n   * \n   * @param options - 启动配置选项\n   * @param services - 服务实例\n   * @param error - 错误信息\n   */\n  renderError(\n    options: StartOptions,\n    services: {\n      monitoring: MonitoringService;\n    }\n  ): void {\n    if (!this.root) {\n      throw new Error('渲染器未初始化，请先调用 initialize()');\n    }\n\n    this.root.render(\n      <StrictMode>\n        <ErrorBoundary\n          fallback={options.errorFallback}\n          onError={(err) => {\n            services.monitoring.captureError(err);\n            if (options.errorMonitor?.onError) {\n              options.errorMonitor.onError(err);\n            }\n          }}\n        >\n          <InitializationErrorThrower />\n          <div>框架启动失败</div>\n        </ErrorBoundary>\n      </StrictMode>\n    );\n  }\n\n  /**\n   * 销毁渲染器\n   */\n  destroy(): void {\n    if (this.root) {\n      this.root.unmount();\n      this.root = null;\n    }\n    this.container = null;\n  }\n\n  /**\n   * 获取容器\n   */\n  getContainer(): Container | null {\n    return this.container;\n  }\n}\n"],"names":["createRoot","StrictMode","BasicLayout","DefaultApp","AppContextProvider","ErrorBoundary","InitializationErrorThrower","SplashScreen","SecurityUtils","getRouterManager","RouterProvider","AppRenderer","initialize","container","rootOptions","root","renderApp","options","services","context","Error","initialLocale","locale","Object","keys","routerEnabled","router","enabled","routerManager","getRouter","shouldUseRouter","securityConfig","enableXSSProtection","security","validateConfig","sanitizeUserInput","csrf","configStr","JSON","stringify","validation","validateInput","safe","monitoring","captureError","reason","error","then","initCSRFManager","headerName","cookieName","getToken","validateToken","catch","process","env","NODE_ENV","console","warn","handleError","render","fallback","errorFallback","onError","initialTheme","theme","initialAntdConfig","antd","initialInitializationContext","stateManager","antdApp","app","renderSplashScreen","onComplete","renderError","err","errorMonitor","div","destroy","unmount","getContainer"],"mappings":"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"}

package/dist/core/startup/startApp.cjs

@@ -0,0 +1,151 @@
+/**
+ * 应用启动主函数
+ * 重构后的启动逻辑，集成所有新功能
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "startApp", {
+    enumerable: true,
+    get: function() {
+        return startApp;
+    }
+});
+const _utils = require("../../utils");
+const _errors = require("../../utils/errors");
+const _traceId = require("../../utils/traceId");
+const _splash = require("../splash");
+const _index = require("../initialization/index");
+const _middleware = require("../middleware");
+const _initializeServices = require("./initializeServices");
+const _AppInstance = require("./AppInstance");
+const _environment = require("./environment");
+const _RouterManager = require("../router/RouterManager");
+async function startApp(options = {}, instanceId) {
+    const startTime = performance.now();
+    const envDetector = (0, _environment.getEnvironmentDetector)();
+    const instanceManager = (0, _AppInstance.getAppInstanceManager)();
+    // 初始化追踪 ID 生成器
+    (0, _traceId.initTraceIdGenerator)('app');
+    const traceId = (0, _traceId.generateTraceId)();
+    (0, _traceId.setCurrentTraceId)(traceId);
+    try {
+        // 1. 环境检测和容器获取
+        const container = options.container || envDetector.safeGetElement('#root');
+        if (!container) {
+            throw new _errors.InitializationError('未找到挂载容器', undefined, {
+                container: options.container
+            }, _errors.ErrorCode.CONTAINER_NOT_FOUND);
+        }
+        _utils.logger.info('框架启动中...');
+        // 2. 创建应用实例
+        const appInstance = instanceManager.createInstance(instanceId, options);
+        // 3. 初始化服务（并行）
+        const servicesInitStart = performance.now();
+        const services = await (0, _initializeServices.initializeServices)(options);
+        const servicesInitDuration = performance.now() - servicesInitStart;
+        // 4. 初始化应用实例
+        appInstance.initialize(container, services);
+        // 5. 初始化路由管理器
+        const routerManager = (0, _RouterManager.getRouterManager)();
+        if (options.router) {
+            await routerManager.initialize(options.router);
+        }
+        // 6. 性能追踪
+        const performanceTracker = appInstance.getPerformanceTracker();
+        if (performanceTracker) {
+            performanceTracker.recordServiceInit(servicesInitDuration);
+        }
+        // 6. 是否显示启动页
+        const shouldShowSplash = (0, _splash.shouldShowSplashScreen)(options.showSplashScreen);
+        const renderer = appInstance.getRenderer();
+        // 8. 渲染应用函数
+        const renderApp = async (context)=>{
+            const renderStart = performance.now();
+            await renderer.renderApp(options, services, context);
+            const renderDuration = performance.now() - renderStart;
+            if (performanceTracker) {
+                performanceTracker.recordFirstRender(renderDuration);
+                const totalDuration = performance.now() - startTime;
+                performanceTracker.recordTotalStartup(totalDuration);
+                performanceTracker.report();
+            }
+            // 开发模式下显示开发工具
+            if (process.env.NODE_ENV === 'development' && typeof window !== 'undefined') {
+                // 延迟显示开发工具，避免影响首次渲染
+                setTimeout(()=>{
+                    const devToolsContainer = document.createElement('div');
+                    devToolsContainer.id = '__framework_dev_tools__';
+                    document.body.appendChild(devToolsContainer);
+                // 这里需要动态导入React来渲染开发工具
+                // 为了简化，暂时注释掉，后续可以完善
+                // import('react-dom/client').then(({ createRoot }) => {
+                //   const root = createRoot(devToolsContainer);
+                //   root.render(<DevToolsTrigger appInstance={appInstance} />);
+                // });
+                }, 1000);
+            }
+        };
+        if (shouldShowSplash) {
+            // 场景1: 显示启动页，初始化在启动页中完成
+            const onSplashComplete = (context)=>{
+                _utils.logger.info('启动页初始化完成');
+                if (options.onSplashComplete) {
+                    Promise.resolve(options.onSplashComplete(()=>{
+                        _utils.logger.info('框架加载完成');
+                        renderApp(context);
+                    }, context)).catch((error)=>{
+                        _utils.logger.error('onSplashComplete 回调执行失败:', error);
+                        _index.initializationErrorState.setError(error);
+                        renderApp(context);
+                    });
+                } else {
+                    _utils.logger.info('框架加载完成');
+                    renderApp(context);
+                }
+            };
+            // 渲染启动页
+            renderer.renderSplashScreen(options, services, onSplashComplete);
+        } else {
+            // 场景2: 不显示启动页，直接执行初始化
+            _utils.logger.info('开始执行初始化（无启动页）');
+            try {
+                const initStart = performance.now();
+                // 使用中间件包装初始化函数
+                const initContext = await _middleware.middlewareManager.execute(options, async ()=>{
+                    return await (0, _index.initialization)(options, (progress, step)=>{
+                        _utils.logger.debug(`初始化进度: ${progress}%${step ? ` - ${step}` : ''}`);
+                    });
+                });
+                const initDuration = performance.now() - initStart;
+                if (performanceTracker) {
+                    performanceTracker.recordInitialization(initDuration);
+                }
+                _utils.logger.info('初始化完成（无启动页）', initContext);
+                _utils.logger.info('框架加载完成');
+                renderApp(initContext);
+            } catch (error) {
+                _utils.logger.error('初始化失败:', error);
+                _index.initializationErrorState.setError(error);
+                renderApp();
+            }
+        }
+        return instanceManager;
+    } catch (error) {
+        _utils.logger.error('框架启动失败:', error);
+        // 如果容器存在，尝试渲染错误页面
+        const container = options.container || envDetector.safeGetElement('#root');
+        if (container) {
+            const errorInstance = instanceManager.getInstance();
+            if (errorInstance && errorInstance.isInitialized()) {
+                const renderer = errorInstance.getRenderer();
+                const services = errorInstance.getServices();
+                _index.initializationErrorState.setError(error);
+                renderer.renderError(options, services);
+            }
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=startApp.js.map

package/dist/core/startup/startApp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/startup/startApp.ts"],"sourcesContent":["/**\n * 应用启动主函数\n * 重构后的启动逻辑，集成所有新功能\n */\n\nimport { logger } from '../../utils';\nimport { ErrorCode, InitializationError } from '../../utils/errors';\nimport { initTraceIdGenerator, generateTraceId, setCurrentTraceId } from '../../utils/traceId';\nimport type { StartOptions } from '../types';\nimport { shouldShowSplashScreen } from '../splash';\nimport { initialization, initializationErrorState } from '../initialization/index';\nimport { middlewareManager } from '../middleware';\nimport { initializeServices } from './initializeServices';\nimport { AppInstanceManager, getAppInstanceManager } from './AppInstance';\nimport { getEnvironmentDetector } from './environment';\nimport { getRouterManager } from '../router/RouterManager';\n\n/**\n * 启动应用\n * \n * @param options - 启动配置选项\n * @param instanceId - 应用实例ID（可选，用于多实例场景）\n * @returns 应用实例\n */\nexport async function startApp(\n  options: StartOptions = {},\n  instanceId?: string\n): Promise<AppInstanceManager> {\n  const startTime = performance.now();\n  const envDetector = getEnvironmentDetector();\n  const instanceManager = getAppInstanceManager();\n\n  // 初始化追踪 ID 生成器\n  initTraceIdGenerator('app');\n  const traceId = generateTraceId();\n  setCurrentTraceId(traceId);\n\n  try {\n    // 1. 环境检测和容器获取\n    const container = options.container || envDetector.safeGetElement('#root');\n    if (!container) {\n      throw new InitializationError(\n        '未找到挂载容器',\n        undefined,\n        { container: options.container },\n        ErrorCode.CONTAINER_NOT_FOUND\n      );\n    }\n\n    logger.info('框架启动中...');\n\n    // 2. 创建应用实例\n    const appInstance = instanceManager.createInstance(instanceId, options);\n\n    // 3. 初始化服务（并行）\n    const servicesInitStart = performance.now();\n    const services = await initializeServices(options);\n    const servicesInitDuration = performance.now() - servicesInitStart;\n\n    // 4. 初始化应用实例\n    appInstance.initialize(container, services);\n\n    // 5. 初始化路由管理器\n    const routerManager = getRouterManager();\n    if (options.router) {\n      await routerManager.initialize(options.router);\n    }\n\n    // 6. 性能追踪\n    const performanceTracker = appInstance.getPerformanceTracker();\n    if (performanceTracker) {\n      performanceTracker.recordServiceInit(servicesInitDuration);\n    }\n\n    // 6. 是否显示启动页\n    const shouldShowSplash = shouldShowSplashScreen(options.showSplashScreen);\n\n    const renderer = appInstance.getRenderer();\n\n    // 8. 渲染应用函数\n    const renderApp = async (context?: Awaited<ReturnType<typeof initialization>>) => {\n      const renderStart = performance.now();\n      await renderer.renderApp(options, services, context);\n      const renderDuration = performance.now() - renderStart;\n\n      if (performanceTracker) {\n        performanceTracker.recordFirstRender(renderDuration);\n        const totalDuration = performance.now() - startTime;\n        performanceTracker.recordTotalStartup(totalDuration);\n        performanceTracker.report();\n      }\n\n      // 开发模式下显示开发工具\n      if (process.env.NODE_ENV === 'development' && typeof window !== 'undefined') {\n        // 延迟显示开发工具，避免影响首次渲染\n        setTimeout(() => {\n          const devToolsContainer = document.createElement('div');\n          devToolsContainer.id = '__framework_dev_tools__';\n          document.body.appendChild(devToolsContainer);\n          \n          // 这里需要动态导入React来渲染开发工具\n          // 为了简化，暂时注释掉，后续可以完善\n          // import('react-dom/client').then(({ createRoot }) => {\n          //   const root = createRoot(devToolsContainer);\n          //   root.render(<DevToolsTrigger appInstance={appInstance} />);\n          // });\n        }, 1000);\n      }\n    };\n\n    if (shouldShowSplash) {\n      // 场景1: 显示启动页，初始化在启动页中完成\n      const onSplashComplete = (context: Awaited<ReturnType<typeof initialization>>) => {\n        logger.info('启动页初始化完成');\n\n        if (options.onSplashComplete) {\n          Promise.resolve(\n            options.onSplashComplete(() => {\n              logger.info('框架加载完成');\n              renderApp(context);\n            }, context)\n          ).catch((error) => {\n            logger.error('onSplashComplete 回调执行失败:', error);\n            initializationErrorState.setError(error);\n            renderApp(context);\n          });\n        } else {\n          logger.info('框架加载完成');\n          renderApp(context);\n        }\n      };\n\n      // 渲染启动页\n      renderer.renderSplashScreen(options, services, onSplashComplete);\n    } else {\n      // 场景2: 不显示启动页，直接执行初始化\n      logger.info('开始执行初始化（无启动页）');\n\n      try {\n        const initStart = performance.now();\n\n        // 使用中间件包装初始化函数\n        const initContext = await middlewareManager.execute(\n          options,\n          async () => {\n            return await initialization(options, (progress, step) => {\n              logger.debug(`初始化进度: ${progress}%${step ? ` - ${step}` : ''}`);\n            });\n          }\n        );\n\n        const initDuration = performance.now() - initStart;\n        if (performanceTracker) {\n          performanceTracker.recordInitialization(initDuration);\n        }\n\n        logger.info('初始化完成（无启动页）', initContext);\n        logger.info('框架加载完成');\n        renderApp(initContext);\n      } catch (error) {\n        logger.error('初始化失败:', error);\n        initializationErrorState.setError(error);\n        renderApp();\n      }\n    }\n\n    return instanceManager;\n  } catch (error) {\n    logger.error('框架启动失败:', error);\n\n    // 如果容器存在，尝试渲染错误页面\n    const container = options.container || envDetector.safeGetElement('#root');\n    if (container) {\n      const errorInstance = instanceManager.getInstance();\n      if (errorInstance && errorInstance.isInitialized()) {\n        const renderer = errorInstance.getRenderer();\n        const services = errorInstance.getServices();\n        initializationErrorState.setError(error);\n        renderer.renderError(options, services);\n      }\n    }\n\n    throw error;\n  }\n}\n"],"names":["startApp","options","instanceId","startTime","performance","now","envDetector","getEnvironmentDetector","instanceManager","getAppInstanceManager","initTraceIdGenerator","traceId","generateTraceId","setCurrentTraceId","container","safeGetElement","InitializationError","undefined","ErrorCode","CONTAINER_NOT_FOUND","logger","info","appInstance","createInstance","servicesInitStart","services","initializeServices","servicesInitDuration","initialize","routerManager","getRouterManager","router","performanceTracker","getPerformanceTracker","recordServiceInit","shouldShowSplash","shouldShowSplashScreen","showSplashScreen","renderer","getRenderer","renderApp","context","renderStart","renderDuration","recordFirstRender","totalDuration","recordTotalStartup","report","process","env","NODE_ENV","window","setTimeout","devToolsContainer","document","createElement","id","body","appendChild","onSplashComplete","Promise","resolve","catch","error","initializationErrorState","setError","renderSplashScreen","initStart","initContext","middlewareManager","execute","initialization","progress","step","debug","initDuration","recordInitialization","errorInstance","getInstance","isInitialized","getServices","renderError"],"mappings":"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"}

package/dist/core/startup/startApp.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 应用启动主函数
+ * 重构后的启动逻辑，集成所有新功能
+ */
+import type { StartOptions } from '../types';
+import { AppInstanceManager } from './AppInstance';
+/**
+ * 启动应用
+ *
+ * @param options - 启动配置选项
+ * @param instanceId - 应用实例ID（可选，用于多实例场景）
+ * @returns 应用实例
+ */
+export declare function startApp(options?: StartOptions, instanceId?: string): Promise<AppInstanceManager>;
+//# sourceMappingURL=startApp.d.ts.map

package/dist/core/startup/startApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startApp.d.ts","sourceRoot":"","sources":["../../../src/core/startup/startApp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAK7C,OAAO,EAAE,kBAAkB,EAAyB,MAAM,eAAe,CAAC;AAI1E;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,GAAE,YAAiB,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,kBAAkB,CAAC,CA6J7B"}