import { jsx as _jsx } from "react/jsx-runtime";
import React from "react";
import { Navigate } from "react-router-dom";
import { RouteErrorBoundary } from "./RouteErrorBoundary";
import { Spin } from "antd";
export const transformRoutesToReactRoutes = async (routes, transformResult, defaultRouteErrorComponent, defaultRouteLoadingComponent)=>{
    /**
     * 批量处理路由
     * @param routes 路由组
     */ function transformRouteToReactRoutes(routes) {
        return routes.flatMap((route)=>transformRouteToReactRoute(route));
    }
    /**
     * 处理单个路由
     * @param route 路由
     */ function transformRouteToReactRoute(route) {
        const { isGroup = false, enableRedirection = false, name, path, handle, children, page, layout, loading, errors } = route;
        // 获取错误组件
        async function getErrorComponent() {
            // 如果 errors 是函数，直接使用
            if (typeof errors === 'function') {
                return errors();
            }
            const errorsMap = transformResult.errors;
            // 判断 errors 是否为 string 且不是空字符串
            if (typeof errors === 'string' && errors !== '') {
                // 使用 errors 作为 key 获取 transformResult.errors 的值
                const errorResolver = errorsMap.get(errors);
                // 如果获取不到，返回 null
                if (!errorResolver) {
                    return null;
                }
                // 如果获取到，返回对应的值（调用动态导入函数）
                if (typeof errorResolver === 'function') {
                    return errorResolver();
                }
                return null;
            }
            // 如果 errors 为空，使用配置的默认错误组件或内置的 RouteErrorBoundary 组件
            if (defaultRouteErrorComponent) {
                // 如果配置了默认错误组件，使用配置的组件
                return defaultRouteErrorComponent();
            }
            // 如果没有配置默认错误组件，使用内置的 RouteErrorBoundary 组件
            // 直接导入而非懒加载，因为：
            // 1. RouteErrorBoundary 是框架核心组件，体积小
            // 2. 错误边界需要快速响应，直接导入速度更快
            // 3. 作为基础设施组件，应该保证可用性
            return {
                default: RouteErrorBoundary
            };
        }
        // 获取默认加载组件（配置的或内置的 Spin）
        function getDefaultLoadingComponent() {
            if (defaultRouteLoadingComponent) {
                // 如果配置了默认加载组件，使用 React.lazy 包装
                // 使用懒加载是因为用户可能希望自定义组件支持代码分割
                return /*#__PURE__*/ React.lazy(()=>defaultRouteLoadingComponent().then((module)=>({
                            default: module.default || module
                        })));
            }
            // 如果没有配置默认加载组件，使用 antd 的 Spin 作为默认组件
            // 直接导入而非懒加载，因为：
            // 1. Spin 是 antd 的基础组件，体积小
            // 2. 加载组件需要快速显示，直接导入速度更快
            // 3. 作为基础设施组件，应该保证可用性
            return Spin;
        }
        // 获取加载组件
        function getLoadingComponent() {
            // 如果 loading 是函数，直接使用 React.lazy 包装
            if (typeof loading === 'function') {
                return /*#__PURE__*/ React.lazy(()=>loading().then((module)=>({
                            default: module.default || module
                        })));
            }
            const loadingsMap = transformResult.loadings;
            // 判断 loading 是否为 string 且不是空字符串
            if (typeof loading === 'string' && loading !== '') {
                // 使用 loading 作为 key 获取 transformResult.loadings 的值
                const loadingResolver = loadingsMap.get(loading);
                // 如果获取不到，使用默认加载组件
                if (!loadingResolver) {
                    return getDefaultLoadingComponent();
                }
                // 如果获取到，使用 React.lazy 包装动态导入函数
                // loadingResolver 是一个返回 Promise 的函数，Promise resolve 后的值是组件模块
                if (typeof loadingResolver === 'function') {
                    return /*#__PURE__*/ React.lazy(()=>loadingResolver().then((module)=>({
                                default: module.default || module
                            })));
                }
                // 如果 loadingResolver 不是函数，使用默认加载组件
                return getDefaultLoadingComponent();
            }
            // 如果 loading 为空，使用默认加载组件
            return getDefaultLoadingComponent();
        }
        // 获取转换配置
        function convertConfig(m) {
            if (!m) {
                return null;
            }
            const { action, loader, shouldRevalidate, default: Component } = m;
            // 如果 Component 不存在，记录警告
            if (!Component) {
                console.warn(`路由组件未找到 default 导出: ${name}`, m);
            }
            return {
                action,
                loader,
                shouldRevalidate,
                Component
            };
        }
        // 获取配置
        async function getConfig(index = false) {
            // 如果有layout和不是index,返回布局配置
            if (layout && !index) {
                // 如果 layout 是函数，直接使用
                if (typeof layout === 'function') {
                    const config = await layout();
                    return convertConfig(config);
                }
                // 如果 layout 是字符串，从 Map 中获取
                if (typeof layout === 'string') {
                    const layoutResolver = transformResult.layouts.get(layout);
                    if (!layoutResolver) {
                        throw new Error(`未找到名为 ${layout} 的布局组件`);
                    }
                    const config = await layoutResolver();
                    return convertConfig(config);
                }
            }
            let pageName = name;
            // 如果是notFound则转成404
            if (pageName === 'notFound') {
                pageName = '404';
            }
            if (page && (!children?.length || index)) {
                // 如果 page 是函数，直接使用
                if (typeof page === 'function') {
                    const config = await page();
                    return convertConfig(config);
                }
                // 如果 page 是字符串，从 Map 中获取
                if (typeof page === 'string') {
                    const viewResolver = transformResult.pages.get(page);
                    if (!viewResolver) {
                        throw new Error(`未找到名为 ${page} 的页面组件`);
                    }
                    const config = await viewResolver();
                    return convertConfig(config);
                }
            }
            return null;
        }
        // 获取处理信息，即额外的配置信息
        function getHandle(index = false) {
            if ((layout || isGroup) && !index) {
                return null;
            }
            return {
                ...handle,
                name,
                path
            };
        }
        const reactRoute = {
            children: [],
            HydrateFallback: getLoadingComponent(),
            id: name,
            handle: getHandle(),
            lazy: async ()=>{
                const ErrorBoundary = await getErrorComponent();
                const config = await getConfig();
                // 如果配置为空，确保至少返回一个空对象，避免展开 undefined
                if (!config) {
                    return {
                        ErrorBoundary: ErrorBoundary?.default
                    };
                }
                return {
                    ErrorBoundary: ErrorBoundary?.default,
                    ...config
                };
            },
            path
        };
        // 处理子路由
        if (children?.length) {
            reactRoute.children = children.flatMap((child)=>transformRouteToReactRoute(child)).sort((a, b)=>{
                const orderA = a.handle?.order ?? 99;
                const orderB = b.handle?.order ?? 99;
                return orderA - orderB;
            });
            if (page && !isGroup) {
                reactRoute.children.unshift({
                    handle: getHandle(true),
                    index: true,
                    lazy: async ()=>{
                        const ErrorBoundary = await getErrorComponent();
                        return {
                            ErrorBoundary: ErrorBoundary?.default,
                            ...await getConfig(true)
                        };
                    }
                });
            }
            if (enableRedirection && isGroup) {
                const [firstChild] = reactRoute.children;
                if (firstChild?.path) {
                    reactRoute.children.unshift({
                        index: true,
                        handle: getHandle(true),
                        element: /*#__PURE__*/ _jsx(Navigate, {
                            to: firstChild.path,
                            replace: true
                        })
                    });
                }
            }
        }
        // 若存在 layout 且没有子路由，但同时声明了 page，则自动生成 index 子路由以渲染页面
        // 场景：/test 使用自定义 layout，且没有 children 时仍应渲染 page
        if ((!children || children.length === 0) && layout && page && !isGroup) {
            reactRoute.children = [
                {
                    handle: getHandle(true),
                    index: true,
                    lazy: async ()=>{
                        const ErrorBoundary = await getErrorComponent();
                        return {
                            ErrorBoundary: ErrorBoundary?.default,
                            ...await getConfig(true)
                        };
                    }
                }
            ];
        }
        return reactRoute;
    }
    return transformRouteToReactRoutes(routes);
};

//# sourceMappingURL=transform.js.map