@modern-js/app-tools 3.0.0-beta.0 → 3.0.0

package/dist/cjs/plugins/analyze/index.js

@@ -0,0 +1,227 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>analyze
+});
+const external_path_namespaceObject = require("path");
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../../builder/index.js");
+const external_config_index_js_namespaceObject = require("../../config/index.js");
+const config_js_namespaceObject = require("../../utils/config.js");
+const getSelectedEntries_js_namespaceObject = require("../../utils/getSelectedEntries.js");
+const printInstructions_js_namespaceObject = require("../../utils/printInstructions.js");
+const routes_js_namespaceObject = require("../../utils/routes.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const debug = (0, utils_namespaceObject.createDebugger)('plugin-analyze');
+const analyze = ()=>({
+        name: '@modern-js/plugin-analyze',
+        post: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            let pagesDir = [];
+            let nestedRouteEntries = [];
+            const routesConfigFiles = [];
+            api.onPrepare(async ()=>{
+                let appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                try {
+                    if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)()) utils_namespaceObject.fs.emptydirSync(appContext.internalDirectory);
+                } catch  {}
+                const apiOnly = await (0, utils_namespaceObject.isApiOnly)(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
+                const [{ getProdServerRoutes }] = await Promise.all([
+                    import("./getServerRoutes.js")
+                ]);
+                if (apiOnly) {
+                    const routes = [];
+                    if ((0, external_utils_js_namespaceObject.checkIsServeCommand)()) routes.push(...getProdServerRoutes(appContext.distDirectory));
+                    else {
+                        const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                            routes: []
+                        });
+                        routes.push(...modifiedRoutes);
+                    }
+                    debug("server routes: %o", routes);
+                    api.updateAppContext({
+                        apiOnly,
+                        serverRoutes: routes
+                    });
+                    return;
+                }
+                const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
+                    import("./getBundleEntry.js"),
+                    import("./getServerRoutes.js"),
+                    import("./getHtmlTemplate.js")
+                ]);
+                const { entrypoints } = await hooks.modifyEntrypoints.call({
+                    entrypoints: await getBundleEntry(hooks, appContext, resolvedConfig)
+                });
+                debug("entrypoints: %o", entrypoints);
+                const routes = [];
+                if ((0, external_utils_js_namespaceObject.checkIsServeCommand)()) routes.push(...getProdServerRoutes(appContext.distDirectory));
+                else {
+                    const initialRoutes = getServerRoutes(entrypoints, {
+                        appContext,
+                        config: resolvedConfig
+                    });
+                    const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                        routes: initialRoutes
+                    });
+                    routes.push(...modifiedRoutes);
+                }
+                debug("server routes: %o", routes);
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    serverRoutes: routes
+                };
+                api.updateAppContext(appContext);
+                nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !external_path_namespaceObject.extname(entry)).concat(nestedRouteEntries);
+                const meta = (0, utils_namespaceObject.getMeta)(api.getAppContext().metaName);
+                const possibleNames = [
+                    `${meta}.routes.ts`,
+                    `${meta}.routes.mts`,
+                    `${meta}.routes.tsx`,
+                    `${meta}.routes.js`,
+                    `${meta}.routes.mjs`,
+                    `${meta}.routes.jsx`
+                ];
+                await Promise.all(entrypoints.map(async (entrypoint)=>{
+                    const { absoluteEntryDir } = entrypoint;
+                    if (!absoluteEntryDir) return;
+                    for (const filename of possibleNames){
+                        const filePath = external_path_namespaceObject.resolve(absoluteEntryDir, filename);
+                        if (await utils_namespaceObject.fs.pathExists(filePath)) {
+                            const stats = await utils_namespaceObject.fs.stat(filePath);
+                            if (stats.isFile()) routesConfigFiles.push(filePath);
+                        }
+                    }
+                }));
+                const { partialsByEntrypoint, htmlTemplates } = await getHtmlTemplate(entrypoints, hooks, {
+                    appContext,
+                    config: resolvedConfig
+                });
+                debug("html templates: %o", htmlTemplates);
+                api.updateAppContext({
+                    partialsByEntrypoint
+                });
+                let checkedEntries = entrypoints.map((point)=>point.entryName);
+                if ((0, utils_namespaceObject.isDevCommand)()) {
+                    const { entry } = (0, utils_namespaceObject.minimist)((0, utils_namespaceObject.getArgv)());
+                    checkedEntries = await (0, getSelectedEntries_js_namespaceObject.getSelectedEntries)('string' == typeof entry ? entry.split(',') : entry, entrypoints);
+                }
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    checkedEntries,
+                    apiOnly,
+                    serverRoutes: routes,
+                    htmlTemplates
+                };
+                api.updateAppContext(appContext);
+                if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)()) {
+                    await hooks.generateEntryCode.call({
+                        entrypoints
+                    });
+                    const normalizedConfig = api.getNormalizedConfig();
+                    const createBuilderForModern = await (0, index_js_namespaceObject.createBuilderGenerator)();
+                    const builder = await createBuilderForModern({
+                        normalizedConfig: normalizedConfig,
+                        appContext: appContext
+                    });
+                    builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
+                        if (!isFirstCompile) return;
+                        await (0, routes_js_namespaceObject.generateRoutes)(appContext);
+                        await hooks.onBeforeBuild.call({
+                            isFirstCompile,
+                            isWatch,
+                            environments,
+                            bundlerConfigs
+                        });
+                    });
+                    builder.onAfterBuild(async ({ stats, environments, isFirstCompile, isWatch })=>{
+                        await hooks.onAfterBuild.call({
+                            stats,
+                            environments,
+                            isFirstCompile,
+                            isWatch
+                        });
+                        await (0, config_js_namespaceObject.emitResolvedConfig)(appContext.appDirectory, normalizedConfig);
+                    });
+                    builder.onDevCompileDone(async ({ isFirstCompile, stats, environments })=>{
+                        hooks.onDevCompileDone.call({
+                            isFirstCompile,
+                            stats,
+                            environments
+                        });
+                        if (isFirstCompile) (0, printInstructions_js_namespaceObject.printInstructions)(hooks, appContext, normalizedConfig);
+                    });
+                    builder.onBeforeCreateCompiler(async ({ bundlerConfigs, environments })=>{
+                        await hooks.onBeforeCreateCompiler.call({
+                            environments,
+                            bundlerConfigs
+                        });
+                    });
+                    builder.onAfterCreateCompiler(async ({ compiler, environments })=>{
+                        await hooks.onAfterCreateCompiler.call({
+                            environments,
+                            compiler
+                        });
+                    });
+                    builder.onAfterStartDevServer(async ({ port })=>{
+                        await hooks.onAfterDev.call({
+                            port
+                        });
+                    });
+                    builder.addPlugins(resolvedConfig.builderPlugins);
+                    api.updateAppContext({
+                        builder
+                    });
+                }
+            });
+            api.addWatchFiles(()=>({
+                    files: [
+                        ...pagesDir,
+                        ...routesConfigFiles
+                    ],
+                    isPrivate: true
+                }));
+            api.modifyResolvedConfig((resolved)=>{
+                const appContext = api.getAppContext();
+                const config = (0, external_config_index_js_namespaceObject.initialNormalizedConfig)(resolved, appContext);
+                return config;
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/analyze/isDefaultExportFunction.js

@@ -0,0 +1,86 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isDefaultExportFunction: ()=>isDefaultExportFunction
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const parser_namespaceObject = require("@babel/parser");
+const traverse_namespaceObject = require("@babel/traverse");
+var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
+const types_namespaceObject = require("@babel/types");
+const isFunction = (node)=>types_namespaceObject.isFunctionDeclaration(node) || types_namespaceObject.isFunctionExpression(node) || types_namespaceObject.isArrowFunctionExpression(node);
+const isDefaultExportFunction = (file)=>{
+    if (!file || !external_fs_default().existsSync(file)) return false;
+    const ast = (0, parser_namespaceObject.parse)(external_fs_default().readFileSync(file, 'utf8'), {
+        sourceType: 'unambiguous',
+        plugins: [
+            'jsx',
+            "typescript",
+            'classProperties',
+            'dynamicImport',
+            'exportDefaultFrom',
+            'exportNamespaceFrom',
+            'decorators-legacy',
+            'functionBind',
+            'classPrivateMethods',
+            [
+                'pipelineOperator',
+                {
+                    proposal: 'minimal'
+                }
+            ],
+            'optionalChaining',
+            'optionalCatchBinding',
+            'objectRestSpread',
+            'numericSeparator'
+        ]
+    });
+    let isExportFunction = false;
+    traverse_default()(ast, {
+        ExportDefaultDeclaration: (path)=>{
+            const { declaration } = path.node;
+            if (isFunction(declaration)) isExportFunction = true;
+        }
+    });
+    return isExportFunction;
+};
+exports.isDefaultExportFunction = __webpack_exports__.isDefaultExportFunction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isDefaultExportFunction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/analyze/templates.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    html: ()=>html
+});
+const html = (partials)=>`
+<!DOCTYPE html>
+<html>
+<head>
+
+  ${partials.top.join('\n')}
+
+  ${partials.head.join('\n')}
+
+</head>
+
+<body>
+  <div id="<%= mountId %>"><!--<?- html ?>--></div>
+  ${partials.body.join('\n')}
+  <!--<?- chunksMap.js ?>-->
+  <!--<?- SSRDataScript ?>-->
+  <!--<?- bottomTemplate ?>-->
+</body>
+
+</html>
+`;
+exports.html = __webpack_exports__.html;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "html"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/analyze/utils.js

@@ -0,0 +1,118 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    checkIsBuildCommands: ()=>checkIsBuildCommands,
+    checkIsServeCommand: ()=>checkIsServeCommand,
+    parseModule: ()=>parseModule,
+    replaceWithAlias: ()=>replaceWithAlias,
+    walkDirectory: ()=>walkDirectory,
+    isSubDirOrEqual: ()=>isSubDirOrEqual,
+    getServerCombinedModueFile: ()=>getServerCombinedModueFile
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_es_module_lexer_namespaceObject = require("es-module-lexer");
+const external_esbuild_namespaceObject = require("esbuild");
+const walkDirectory = (dir)=>external_fs_default().readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = external_path_default().join(dir, filename);
+        if (external_fs_default().statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return (0, utils_namespaceObject.normalizeToPosixPath)(external_path_default().join(alias, external_path_default().relative(base, filePath)));
+    return filePath;
+};
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (utils_namespaceObject.JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const result = await (0, external_esbuild_namespaceObject.transform)(content, {
+            loader: external_path_default().extname(filename).slice(1),
+            format: 'esm'
+        });
+        content = result.code;
+    }
+    return await (0, external_es_module_lexer_namespaceObject.parse)(content);
+};
+const getServerCombinedModueFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'server-loader-combined.js');
+const checkIsBuildCommands = ()=>{
+    const buildCommands = [
+        'dev',
+        'start',
+        'build',
+        'inspect',
+        'deploy',
+        'dev-worker'
+    ];
+    const command = (0, utils_namespaceObject.getCommand)();
+    return buildCommands.includes(command);
+};
+const checkIsServeCommand = ()=>{
+    const command = (0, utils_namespaceObject.getCommand)();
+    return 'serve' === command;
+};
+const isSubDirOrEqual = (parent, child)=>{
+    if (parent === child) return true;
+    const relative = external_path_default().relative(parent, child);
+    const isSubdir = relative && !relative.startsWith('..') && !external_path_default().isAbsolute(relative);
+    return Boolean(isSubdir);
+};
+exports.checkIsBuildCommands = __webpack_exports__.checkIsBuildCommands;
+exports.checkIsServeCommand = __webpack_exports__.checkIsServeCommand;
+exports.getServerCombinedModueFile = __webpack_exports__.getServerCombinedModueFile;
+exports.isSubDirOrEqual = __webpack_exports__.isSubDirOrEqual;
+exports.parseModule = __webpack_exports__.parseModule;
+exports.replaceWithAlias = __webpack_exports__.replaceWithAlias;
+exports.walkDirectory = __webpack_exports__.walkDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "checkIsBuildCommands",
+    "checkIsServeCommand",
+    "getServerCombinedModueFile",
+    "isSubDirOrEqual",
+    "parseModule",
+    "replaceWithAlias",
+    "walkDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>deploy
+});
+const external_std_env_namespaceObject = require("std-env");
+const gh_pages_js_namespaceObject = require("./platforms/gh-pages.js");
+const netlify_js_namespaceObject = require("./platforms/netlify.js");
+const node_js_namespaceObject = require("./platforms/node.js");
+const vercel_js_namespaceObject = require("./platforms/vercel.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const deployPresets = {
+    node: node_js_namespaceObject.createNodePreset,
+    vercel: vercel_js_namespaceObject.createVercelPreset,
+    netlify: netlify_js_namespaceObject.createNetlifyPreset,
+    ghPages: gh_pages_js_namespaceObject.createGhPagesPreset
+};
+async function getDeployPreset(appContext, modernConfig, deployTarget) {
+    const { appDirectory, distDirectory, metaName } = appContext;
+    const { useSSR, useAPI, useWebServer } = (0, external_utils_js_namespaceObject.getProjectUsage)(appDirectory, distDirectory, metaName);
+    const needModernServer = useSSR || useAPI || useWebServer;
+    const createPreset = deployPresets[deployTarget];
+    if (!createPreset) throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
+    return createPreset(appContext, modernConfig, needModernServer);
+}
+const deploy = ()=>({
+        name: '@modern-js/plugin-deploy',
+        setup: (api)=>{
+            const deployTarget = process.env.MODERNJS_DEPLOY || external_std_env_namespaceObject.provider || 'node';
+            api.deploy(async ()=>{
+                const appContext = api.getAppContext();
+                const { metaName } = appContext;
+                if ('modern-js' !== metaName && !process.env.MODERNJS_DEPLOY) return;
+                const modernConfig = api.getNormalizedConfig();
+                const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget);
+                deployPreset?.prepare && await deployPreset?.prepare();
+                deployPreset?.writeOutput && await deployPreset?.writeOutput();
+                deployPreset?.genEntry && await deployPreset?.genEntry();
+                deployPreset?.end && await deployPreset?.end();
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/gh-pages.js

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createGhPagesPreset: ()=>createGhPagesPreset
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+async function reorganizeHtmlFiles(routes, baseDir, baseUrl = '/') {
+    if (!routes || !Array.isArray(routes)) return void utils_namespaceObject.logger.error('Invalid server routes');
+    await utils_namespaceObject.fs.ensureDir(baseDir);
+    const baseUrlRegexp = new RegExp(`^${baseUrl}\\/?`);
+    const collectedEntryPaths = new Set();
+    const copyPromises = routes.map(async (route)=>{
+        const { urlPath, entryPath } = route;
+        if (!entryPath) return void utils_namespaceObject.logger.warn(`Route ${urlPath} does not specify entryPath, skipping`);
+        if (collectedEntryPaths.has(entryPath)) return;
+        collectedEntryPaths.add(entryPath);
+        const sourceHtmlPath = external_path_default().join(baseDir, entryPath);
+        if (!await utils_namespaceObject.fs.pathExists(sourceHtmlPath)) return void utils_namespaceObject.logger.error(`Source HTML file does not exist: ${sourceHtmlPath}`);
+        const targetDir = urlPath.replace(baseUrlRegexp, '');
+        await utils_namespaceObject.fs.ensureDir(external_path_default().dirname(targetDir));
+        const targetHtmlPath = external_path_default().join(baseDir, targetDir, 'index.html');
+        try {
+            await utils_namespaceObject.fs.move(sourceHtmlPath, targetHtmlPath);
+        } catch (error) {
+            utils_namespaceObject.logger.error(`Failed to copy HTML file: ${error.message}`);
+        }
+    });
+    await Promise.all(copyPromises);
+}
+const createGhPagesPreset = (appContext, modernConfig)=>{
+    const { serverRoutes, appDirectory, distDirectory } = appContext;
+    const { server: { baseUrl } } = modernConfig;
+    const outputDirectory = external_path_default().join(appDirectory, '.output');
+    return {
+        name: 'gh-pages',
+        async prepare () {
+            await utils_namespaceObject.fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await utils_namespaceObject.fs.copy(distDirectory, outputDirectory);
+        },
+        async end () {
+            await reorganizeHtmlFiles(serverRoutes, outputDirectory, Array.isArray(baseUrl) ? baseUrl[0] : baseUrl);
+        }
+    };
+};
+exports.createGhPagesPreset = __webpack_exports__.createGhPagesPreset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createGhPagesPreset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/netlify-entry.js

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>external_netlify_handler_js_namespaceObject.handler
+});
+const external_netlify_handler_js_namespaceObject = require("./netlify-handler.js");
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});