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, useMemo, useCallback, memo } 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";
const OptimizedAppContent = /*#__PURE__*/ memo(({ options, services, context, // securityConfig 用于未来扩展，当前暂不使用
// eslint-disable-next-line @typescript-eslint/no-unused-vars
securityConfig: _securityConfig })=>{
    // 优化：使用 useMemo 缓存初始语言计算
    const initialLocale = useMemo(()=>{
        return options.locale ? Object.keys(options.locale)[0] || 'zh-CN' : 'zh-CN';
    }, [
        options.locale
    ]);
    // 优化：使用 useMemo 缓存路由判断结果
    const shouldUseRouter = useMemo(()=>{
        const routerEnabled = options.router ? options.router.enabled !== false && options.router.enabled !== 'disabled' : false;
        if (!routerEnabled) {
            return false;
        }
        const routerManager = getRouterManager();
        const router = routerManager.getRouter();
        return router !== null;
    }, [
        options.router
    ]);
    // 优化：使用 useMemo 缓存路由实例
    const router = useMemo(()=>{
        if (!shouldUseRouter) {
            return null;
        }
        const routerManager = getRouterManager();
        return routerManager.getRouter();
    }, [
        shouldUseRouter
    ]);
    // 优化：使用 useCallback 缓存错误处理函数
    const handleError = useCallback((error)=>{
        services.monitoring.captureError(error);
    }, [
        services.monitoring
    ]);
    // 优化：使用 useMemo 缓存应用内容
    const appContent = useMemo(()=>{
        if (shouldUseRouter && router) {
            return /*#__PURE__*/ _jsx(RouterProvider, {
                router: router
            });
        }
        return options.app || /*#__PURE__*/ _jsx(DefaultApp, {});
    }, [
        shouldUseRouter,
        router,
        options.app
    ]);
    return /*#__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: appContent
                })
            })
        ]
    });
});
OptimizedAppContent.displayName = 'OptimizedAppContent';
/**
 * 应用渲染器
 */ 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. 优化组件渲染性能，使用 useMemo 缓存计算结果
   * 3. 将安全配置计算提取到初始化阶段
   * 
   * @param options - 启动配置选项
   * @param services - 服务实例
   * @param context - 初始化上下文（可选）
   */ async renderApp(options, services, context) {
        if (!this.root) {
            throw new Error('渲染器未初始化，请先调用 initialize()');
        }
        // 优化：安全配置在初始化阶段计算（在 startApp 中预计算）
        // 这里只使用预计算的值，避免在渲染时重复计算
        const securityConfig = {
            enableXSSProtection: options.security?.enableXSSProtection ?? true,
            validateConfig: options.security?.validateConfig ?? true,
            sanitizeUserInput: options.security?.sanitizeUserInput ?? true,
            csrf: options.security?.csrf
        };
        // 优化：安全验证在初始化阶段完成，这里只进行必要的运行时检查
        // 如果启用了安全模式（默认启用），对配置进行验证
        if (securityConfig.enableXSSProtection && securityConfig.validateConfig) {
            // 异步验证配置，不阻塞渲染
            Promise.resolve().then(()=>{
                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.enableXSSProtection && securityConfig.csrf?.enabled !== false) {
            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);
                }
            });
        }
        // 使用优化的应用内容组件，内部使用 useMemo 缓存计算结果
        this.root.render(/*#__PURE__*/ _jsx(StrictMode, {
            children: /*#__PURE__*/ _jsx(OptimizedAppContent, {
                options: options,
                services: services,
                context: context,
                securityConfig: securityConfig
            })
        }));
    }
    /**
   * 渲染启动页
   * 
   * 注意：启动页不使用 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