/**
 * 应用渲染模块
 * 负责渲染React应用
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "AppRenderer", {
    enumerable: true,
    get: function() {
        return AppRenderer;
    }
});
const _jsxruntime = require("react/jsx-runtime");
const _client = require("react-dom/client");
const _react = require("react");
const _app = require("../app");
const _error = require("../error");
const _initialization = require("../initialization");
const _splash = require("../splash");
const _security = require("../../utils/security");
const _RouterManager = require("../router/RouterManager");
const _reactrouterdom = require("react-router-dom");
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;
}
function _getRequireWildcardCache(nodeInterop) {
    if (typeof WeakMap !== "function") return null;
    var cacheBabelInterop = new WeakMap();
    var cacheNodeInterop = new WeakMap();
    return (_getRequireWildcardCache = function(nodeInterop) {
        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
    })(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
    if (!nodeInterop && obj && obj.__esModule) {
        return obj;
    }
    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return {
            default: obj
        };
    }
    var cache = _getRequireWildcardCache(nodeInterop);
    if (cache && cache.has(obj)) {
        return cache.get(obj);
    }
    var newObj = {
        __proto__: null
    };
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
    for(var key in obj){
        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
            if (desc && (desc.get || desc.set)) {
                Object.defineProperty(newObj, key, desc);
            } else {
                newObj[key] = obj[key];
            }
        }
    }
    newObj.default = obj;
    if (cache) {
        cache.set(obj, newObj);
    }
    return newObj;
}
const OptimizedAppContent = /*#__PURE__*/ (0, _react.memo)(({ options, services, context, // securityConfig 用于未来扩展，当前暂不使用
// eslint-disable-next-line @typescript-eslint/no-unused-vars
securityConfig: _securityConfig })=>{
    // 优化：使用 useMemo 缓存初始语言计算
    const initialLocale = (0, _react.useMemo)(()=>{
        return options.locale ? Object.keys(options.locale)[0] || 'zh-CN' : 'zh-CN';
    }, [
        options.locale
    ]);
    // 优化：使用 useMemo 缓存路由判断结果
    const shouldUseRouter = (0, _react.useMemo)(()=>{
        const routerEnabled = options.router ? options.router.enabled !== false && options.router.enabled !== 'disabled' : false;
        if (!routerEnabled) {
            return false;
        }
        const routerManager = (0, _RouterManager.getRouterManager)();
        const router = routerManager.getRouter();
        return router !== null;
    }, [
        options.router
    ]);
    // 优化：使用 useMemo 缓存路由实例
    const router = (0, _react.useMemo)(()=>{
        if (!shouldUseRouter) {
            return null;
        }
        const routerManager = (0, _RouterManager.getRouterManager)();
        return routerManager.getRouter();
    }, [
        shouldUseRouter
    ]);
    // 优化：使用 useCallback 缓存错误处理函数
    const handleError = (0, _react.useCallback)((error)=>{
        services.monitoring.captureError(error);
    }, [
        services.monitoring
    ]);
    // 优化：使用 useMemo 缓存应用内容
    const appContent = (0, _react.useMemo)(()=>{
        if (shouldUseRouter && router) {
            return /*#__PURE__*/ (0, _jsxruntime.jsx)(_reactrouterdom.RouterProvider, {
                router: router
            });
        }
        return options.app || /*#__PURE__*/ (0, _jsxruntime.jsx)(_app.DefaultApp, {});
    }, [
        shouldUseRouter,
        router,
        options.app
    ]);
    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_error.ErrorBoundary, {
        fallback: options.errorFallback,
        onError: handleError,
        children: [
            /*#__PURE__*/ (0, _jsxruntime.jsx)(_initialization.InitializationErrorThrower, {}),
            /*#__PURE__*/ (0, _jsxruntime.jsx)(_app.AppContextProvider, {
                initialTheme: options.theme,
                initialLocale: initialLocale,
                initialAntdConfig: options.antd,
                initialInitializationContext: context,
                stateManager: services.stateManager,
                antdApp: options.antdApp,
                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_app.BasicLayout, {
                    children: appContent
                })
            })
        ]
    });
});
OptimizedAppContent.displayName = 'OptimizedAppContent';
let AppRenderer = class AppRenderer {
    /**
   * 初始化渲染器
   * 
   * @param container - React应用的挂载容器
   * @param rootOptions - React根节点配置选项
   */ initialize(container, rootOptions) {
        this.container = container;
        if (!this.root) {
            this.root = (0, _client.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 = _security.SecurityUtils.validateInput(configStr);
                    if (!validation.safe) {
                        services.monitoring.captureError(new Error('配置项包含不安全内容'), {
                            reason: validation.reason
                        });
                    }
                } catch (error) {
                // 忽略序列化错误（某些配置项可能包含不可序列化的内容）
                }
            });
        }
        // 初始化 CSRF 防护（如果启用，异步执行，不阻塞渲染）
        if (securityConfig.enableXSSProtection && securityConfig.csrf?.enabled !== false) {
            Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../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__*/ (0, _jsxruntime.jsx)(_react.StrictMode, {
            children: /*#__PURE__*/ (0, _jsxruntime.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__*/ (0, _jsxruntime.jsx)(_react.StrictMode, {
            children: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_error.ErrorBoundary, {
                fallback: options.errorFallback,
                onError: (error)=>{
                    services.monitoring.captureError(error);
                },
                children: [
                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_initialization.InitializationErrorThrower, {}),
                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_app.AppContextProvider, {
                        initialTheme: options.theme,
                        initialLocale: initialLocale,
                        initialAntdConfig: options.antd,
                        stateManager: services.stateManager,
                        antdApp: options.antdApp,
                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_app.BasicLayout, {
                            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_splash.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__*/ (0, _jsxruntime.jsx)(_react.StrictMode, {
            children: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_error.ErrorBoundary, {
                fallback: options.errorFallback,
                onError: (err)=>{
                    services.monitoring.captureError(err);
                    if (options.errorMonitor?.onError) {
                        options.errorMonitor.onError(err);
                    }
                },
                children: [
                    /*#__PURE__*/ (0, _jsxruntime.jsx)(_initialization.InitializationErrorThrower, {}),
                    /*#__PURE__*/ (0, _jsxruntime.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