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

package/dist/esm-node/plugins/analyze/index.mjs

@@ -0,0 +1,194 @@
+import "node:module";
+import { extname, resolve } from "path";
+import { createDebugger, fs, getArgv, getMeta, isApiOnly, isDevCommand, minimist } from "@modern-js/utils";
+import { createBuilderGenerator } from "../../builder/index.mjs";
+import { initialNormalizedConfig } from "../../config/index.mjs";
+import { emitResolvedConfig } from "../../utils/config.mjs";
+import { getSelectedEntries } from "../../utils/getSelectedEntries.mjs";
+import { printInstructions } from "../../utils/printInstructions.mjs";
+import { generateRoutes } from "../../utils/routes.mjs";
+import { checkIsBuildCommands, checkIsServeCommand } from "./utils.mjs";
+const debug = 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 (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
+                } catch  {}
+                const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
+                const [{ getProdServerRoutes }] = await Promise.all([
+                    import("./getServerRoutes.mjs")
+                ]);
+                if (apiOnly) {
+                    const routes = [];
+                    if (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.mjs"),
+                    import("./getServerRoutes.mjs"),
+                    import("./getHtmlTemplate.mjs")
+                ]);
+                const { entrypoints } = await hooks.modifyEntrypoints.call({
+                    entrypoints: await getBundleEntry(hooks, appContext, resolvedConfig)
+                });
+                debug("entrypoints: %o", entrypoints);
+                const routes = [];
+                if (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 && !extname(entry)).concat(nestedRouteEntries);
+                const meta = 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 = resolve(absoluteEntryDir, filename);
+                        if (await fs.pathExists(filePath)) {
+                            const stats = await 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 (isDevCommand()) {
+                    const { entry } = minimist(getArgv());
+                    checkedEntries = await getSelectedEntries('string' == typeof entry ? entry.split(',') : entry, entrypoints);
+                }
+                appContext = {
+                    ...api.getAppContext(),
+                    entrypoints,
+                    checkedEntries,
+                    apiOnly,
+                    serverRoutes: routes,
+                    htmlTemplates
+                };
+                api.updateAppContext(appContext);
+                if (checkIsBuildCommands()) {
+                    await hooks.generateEntryCode.call({
+                        entrypoints
+                    });
+                    const normalizedConfig = api.getNormalizedConfig();
+                    const createBuilderForModern = await createBuilderGenerator();
+                    const builder = await createBuilderForModern({
+                        normalizedConfig: normalizedConfig,
+                        appContext: appContext
+                    });
+                    builder.onBeforeBuild(async ({ bundlerConfigs, isFirstCompile, environments, isWatch })=>{
+                        if (!isFirstCompile) return;
+                        await 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 emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+                    });
+                    builder.onDevCompileDone(async ({ isFirstCompile, stats, environments })=>{
+                        hooks.onDevCompileDone.call({
+                            isFirstCompile,
+                            stats,
+                            environments
+                        });
+                        if (isFirstCompile) 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 = initialNormalizedConfig(resolved, appContext);
+                return config;
+            });
+        }
+    });
+export { analyze as default };

package/dist/esm-node/plugins/analyze/isDefaultExportFunction.mjs

@@ -0,0 +1,42 @@
+import "node:module";
+import fs from "fs";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import { isArrowFunctionExpression, isFunctionDeclaration, isFunctionExpression } from "@babel/types";
+const isFunction = (node)=>isFunctionDeclaration(node) || isFunctionExpression(node) || isArrowFunctionExpression(node);
+const isDefaultExportFunction = (file)=>{
+    if (!file || !fs.existsSync(file)) return false;
+    const ast = parse(fs.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(ast, {
+        ExportDefaultDeclaration: (path)=>{
+            const { declaration } = path.node;
+            if (isFunction(declaration)) isExportFunction = true;
+        }
+    });
+    return isExportFunction;
+};
+export { isDefaultExportFunction };

package/dist/esm-node/plugins/analyze/templates.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+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>
+`;
+export { html };

package/dist/esm-node/plugins/analyze/utils.mjs

@@ -0,0 +1,56 @@
+import "node:module";
+import fs from "fs";
+import path from "path";
+import { JS_EXTENSIONS, getCommand, normalizeToPosixPath } from "@modern-js/utils";
+import { parse } from "es-module-lexer";
+import { transform } from "esbuild";
+const walkDirectory = (dir)=>fs.readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = path.join(dir, filename);
+        if (fs.statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+    return filePath;
+};
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const result = await transform(content, {
+            loader: path.extname(filename).slice(1),
+            format: 'esm'
+        });
+        content = result.code;
+    }
+    return await parse(content);
+};
+const getServerCombinedModueFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
+const checkIsBuildCommands = ()=>{
+    const buildCommands = [
+        'dev',
+        'start',
+        'build',
+        'inspect',
+        'deploy',
+        'dev-worker'
+    ];
+    const command = getCommand();
+    return buildCommands.includes(command);
+};
+const checkIsServeCommand = ()=>{
+    const command = getCommand();
+    return 'serve' === command;
+};
+const isSubDirOrEqual = (parent, child)=>{
+    if (parent === child) return true;
+    const relative = path.relative(parent, child);
+    const isSubdir = relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+    return Boolean(isSubdir);
+};
+export { checkIsBuildCommands, checkIsServeCommand, getServerCombinedModueFile, isSubDirOrEqual, parseModule, replaceWithAlias, walkDirectory };

package/dist/esm-node/plugins/deploy/index.mjs

@@ -0,0 +1,39 @@
+import "node:module";
+import { provider } from "std-env";
+import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
+import { createNetlifyPreset } from "./platforms/netlify.mjs";
+import { createNodePreset } from "./platforms/node.mjs";
+import { createVercelPreset } from "./platforms/vercel.mjs";
+import { getProjectUsage } from "./utils.mjs";
+const deployPresets = {
+    node: createNodePreset,
+    vercel: createVercelPreset,
+    netlify: createNetlifyPreset,
+    ghPages: createGhPagesPreset
+};
+async function getDeployPreset(appContext, modernConfig, deployTarget) {
+    const { appDirectory, distDirectory, metaName } = appContext;
+    const { useSSR, useAPI, useWebServer } = 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 || 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();
+            });
+        }
+    });
+export { deploy as default };

package/dist/esm-node/plugins/deploy/platforms/gh-pages.mjs

@@ -0,0 +1,44 @@
+import "node:module";
+import path from "path";
+import { fs, logger } from "@modern-js/utils";
+async function reorganizeHtmlFiles(routes, baseDir, baseUrl = '/') {
+    if (!routes || !Array.isArray(routes)) return void logger.error('Invalid server routes');
+    await 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 logger.warn(`Route ${urlPath} does not specify entryPath, skipping`);
+        if (collectedEntryPaths.has(entryPath)) return;
+        collectedEntryPaths.add(entryPath);
+        const sourceHtmlPath = path.join(baseDir, entryPath);
+        if (!await fs.pathExists(sourceHtmlPath)) return void logger.error(`Source HTML file does not exist: ${sourceHtmlPath}`);
+        const targetDir = urlPath.replace(baseUrlRegexp, '');
+        await fs.ensureDir(path.dirname(targetDir));
+        const targetHtmlPath = path.join(baseDir, targetDir, 'index.html');
+        try {
+            await fs.move(sourceHtmlPath, targetHtmlPath);
+        } catch (error) {
+            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 = path.join(appDirectory, '.output');
+    return {
+        name: 'gh-pages',
+        async prepare () {
+            await fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await fs.copy(distDirectory, outputDirectory);
+        },
+        async end () {
+            await reorganizeHtmlFiles(serverRoutes, outputDirectory, Array.isArray(baseUrl) ? baseUrl[0] : baseUrl);
+        }
+    };
+};
+export { createGhPagesPreset };

package/dist/esm-node/plugins/deploy/platforms/netlify-entry.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+import { handler } from "./netlify-handler.mjs";
+export { handler as default };

package/dist/esm-node/plugins/deploy/platforms/netlify-handler.mjs

@@ -0,0 +1,89 @@
+import "node:module";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+import * as __rspack_external__modern_js_prod_server_netlify_bf7df0a0 from "@modern-js/prod-server/netlify";
+import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+var __webpack_modules__ = {
+    "@modern-js/prod-server/netlify" (module) {
+        module.exports = __rspack_external__modern_js_prod_server_netlify_bf7df0a0;
+    },
+    "node:fs/promises" (module) {
+        module.exports = __rspack_external_node_fs_promises_153e37e0;
+    },
+    "node:path" (module) {
+        module.exports = __rspack_external_node_path_c5b9b54f;
+    },
+    "./src/plugins/deploy/platforms/netlify-handler.cjs" (module, __unused_rspack_exports, __webpack_require__) {
+        var __dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+        const fs = __webpack_require__("node:fs/promises");
+        const path = __webpack_require__("node:path");
+        const { createNetlifyFunction } = __webpack_require__("@modern-js/prod-server/netlify");
+        p_genPluginImportsCode;
+        if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+        let requestHandler = null;
+        let handlerCreationPromise = null;
+        async function loadRoutes(routeFilepath) {
+            try {
+                await fs.access(routeFilepath);
+                const content = await fs.readFile(routeFilepath, 'utf-8');
+                const routeSpec = JSON.parse(content);
+                return routeSpec.routes || [];
+            } catch (error) {
+                console.warn('route.json not found or invalid, continuing with empty routes.');
+                return [];
+            }
+        }
+        async function initServer() {
+            const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+            const routes = await loadRoutes(routeFilepath);
+            const dynamicProdOptions = p_dynamicProdOptions;
+            const prodServerOptions = {
+                pwd: __dirname,
+                routes,
+                disableCustomHook: true,
+                appContext: {
+                    sharedDirectory: p_sharedDirectory,
+                    apiDirectory: p_apiDirectory,
+                    lambdaDirectory: p_lambdaDirectory,
+                    bffRuntimeFramework: p_bffRuntimeFramework
+                },
+                plugins: p_plugins,
+                serverConfigPath: p_serverDirectory,
+                ...dynamicProdOptions
+            };
+            const requestHandler = await createNetlifyFunction(prodServerOptions);
+            return requestHandler;
+        }
+        async function createHandler() {
+            if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+                try {
+                    requestHandler = await initServer();
+                } catch (error) {
+                    console.error('Error creating server:', error);
+                    process.exit(1);
+                }
+            })();
+            await handlerCreationPromise;
+            return requestHandler;
+        }
+        createHandler();
+        module.exports = {
+            handler: async (request, context)=>{
+                if (!requestHandler) await createHandler();
+                return requestHandler(request, context);
+            }
+        };
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__("./src/plugins/deploy/platforms/netlify-handler.cjs");

package/dist/esm-node/plugins/deploy/platforms/netlify.mjs

@@ -0,0 +1,117 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta, removeModuleSyncFromExports } from "@modern-js/utils";
+import { nodeDepEmit } from "ndepe";
+import { isMainEntry } from "../../../utils/routes.mjs";
+import { genPluginImportsCode, getPluginsCode, serverAppContenxtTemplate } from "../utils.mjs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+var netlify_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+async function cleanDistDirectory(dir) {
+    try {
+        const items = await fs.readdir(dir);
+        for (const item of items){
+            const fullPath = __rspack_external_node_path_c5b9b54f["default"].join(dir, item);
+            if ('static' !== item && '_redirects' !== item && 'html' !== item) await fs.remove(fullPath);
+        }
+    } catch (error) {
+        console.error('Error cleaning directory:', error);
+    }
+}
+const createNetlifyPreset = (appContext, modernConfig, needModernServer)=>{
+    const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType, metaName } = appContext;
+    const isEsmProject = 'module' === moduleType;
+    const plugins = serverPlugins.map((plugin)=>[
+            plugin.name,
+            plugin.options
+        ]);
+    const netlifyOutput = __rspack_external_node_path_c5b9b54f["default"].join(appDirectory, '.netlify');
+    const funcsDirectory = __rspack_external_node_path_c5b9b54f["default"].join(netlifyOutput, 'functions');
+    const entryFilePath = __rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, 'index.js');
+    const handlerFilePath = __rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, 'netlify-handler.cjs');
+    return {
+        async prepare () {
+            await fs.remove(netlifyOutput);
+        },
+        async writeOutput () {
+            const routes = [];
+            const { source: { mainEntryName }, html: { outputStructure } } = modernConfig;
+            if (needModernServer) routes.push({
+                src: '/*',
+                dest: "/.netlify/functions/index",
+                status: 200
+            });
+            else entrypoints.forEach((entry)=>{
+                const isMain = isMainEntry(entry.entryName, mainEntryName);
+                const htmlPath = 'flat' === outputStructure ? `/html/${entry.entryName}.html` : `/html/${entry.entryName}/index.html`;
+                routes.push({
+                    src: `/${isMain ? '' : `${entry.entryName}/`}*`,
+                    dest: htmlPath,
+                    status: 200
+                });
+            });
+            const redirectContent = routes.map((route)=>`${route.src} ${route.dest} ${route.status}`).join('\n');
+            if (needModernServer) {
+                await fs.ensureDir(funcsDirectory);
+                await fs.copy(distDirectory, funcsDirectory, {
+                    filter: (src)=>{
+                        const distStaticDirectory = __rspack_external_node_path_c5b9b54f["default"].join(distDirectory, "static");
+                        return !src.includes(distStaticDirectory);
+                    }
+                });
+            }
+            const redirectFilePath = __rspack_external_node_path_c5b9b54f["default"].join(distDirectory, '_redirects');
+            await fs.writeFile(redirectFilePath, redirectContent);
+        },
+        async genEntry () {
+            if (!needModernServer) return;
+            const serverConfig = {
+                bff: {
+                    prefix: modernConfig?.bff?.prefix
+                },
+                output: {
+                    distPath: {
+                        root: '.'
+                    }
+                }
+            };
+            const meta = getMeta(metaName);
+            const pluginImportCode = genPluginImportsCode(plugins || []);
+            const dynamicProdOptions = {
+                config: serverConfig
+            };
+            const serverConfigPath = `path.join(__dirname, "${SERVER_DIR}", "${meta}.server")`;
+            const pluginsCode = getPluginsCode(plugins);
+            let handlerCode = (await fs.readFile(__rspack_external_node_path_c5b9b54f["default"].join(netlify_dirname, './netlify-handler.js'))).toString();
+            const serverAppContext = serverAppContenxtTemplate(appContext);
+            handlerCode = handlerCode.replace('p_genPluginImportsCode', pluginImportCode).replace('p_ROUTE_SPEC_FILE', `"${ROUTE_SPEC_FILE}"`).replace('p_dynamicProdOptions', JSON.stringify(dynamicProdOptions)).replace('p_plugins', pluginsCode).replace('p_bffRuntimeFramework', `"${serverAppContext.bffRuntimeFramework}"`).replace('p_serverDirectory', serverConfigPath).replace('p_sharedDirectory', serverAppContext.sharedDirectory).replace('p_apiDirectory', serverAppContext.apiDirectory).replace('p_lambdaDirectory', serverAppContext.lambdaDirectory);
+            await fs.writeFile(handlerFilePath, handlerCode);
+            if (isEsmProject) await fs.copy(__rspack_external_node_path_c5b9b54f["default"].join(netlify_dirname, './netlify-entry.mjs'), entryFilePath);
+            else await fs.copy(__rspack_external_node_path_c5b9b54f["default"].join(netlify_dirname, './netlify-entry.js'), entryFilePath);
+        },
+        async end () {
+            if ('development' !== process.env.NODE_ENV) await cleanDistDirectory(distDirectory);
+            if (!needModernServer) return;
+            await nodeDepEmit({
+                appDir: appDirectory,
+                sourceDir: funcsDirectory,
+                includeEntries: [
+                    require.resolve('@modern-js/prod-server'),
+                    require.resolve('@modern-js/prod-server/netlify')
+                ],
+                copyWholePackage (pkgName) {
+                    return '@modern-js/utils' === pkgName;
+                },
+                transformPackageJson: ({ pkgJSON })=>{
+                    if (!pkgJSON.exports || 'object' != typeof pkgJSON.exports) return pkgJSON;
+                    return {
+                        ...pkgJSON,
+                        exports: removeModuleSyncFromExports(pkgJSON.exports)
+                    };
+                }
+            });
+        }
+    };
+};
+export { createNetlifyPreset };