@modern-js/app-tools 3.0.5 → 3.1.0

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

@@ -0,0 +1,46 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createProdServer } from '@modern-js/prod-server';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+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 main() {
+    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 app = await createProdServer(prodServerOptions);
+    const port = process.env.PORT || 8080;
+    app.listen({
+        host: '::',
+        port
+    }, ()=>{
+        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+    });
+}
+main();

package/dist/esm-node/plugins/deploy/platforms/templates/vercel-entry.cjs

@@ -0,0 +1,56 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createProdServer } = require('@modern-js/prod-server');
+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
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
+}
+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();
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
+};
+module.exports = handler;

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

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createProdServer } from '@modern-js/prod-server';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+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
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
+}
+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();
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
+};
+export default handler;

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

@@ -1,25 +1,18 @@
 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 node_path from "node:path";
+import { fs, 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 vercel_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-const createVercelPreset = (appContext, modernConfig, needModernServer)=>{
-    const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType, metaName } = appContext;
+import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
+import { generateHandler } from "../utils/generator.mjs";
+const createVercelPreset = ({ appContext, modernConfig, needModernServer })=>{
+    const { appDirectory, distDirectory, entrypoints, moduleType } = appContext;
     const isEsmProject = 'module' === moduleType;
-    const plugins = serverPlugins.map((plugin)=>[
-            plugin.name,
-            plugin.options
-        ]);
-    const vercelOutput = __rspack_external_node_path_c5b9b54f["default"].join(appDirectory, '.vercel');
-    const outputDirectory = __rspack_external_node_path_c5b9b54f["default"].join(vercelOutput, 'output');
-    const funcsDirectory = __rspack_external_node_path_c5b9b54f["default"].join(outputDirectory, 'functions', 'index.func');
-    const entryFilePath = __rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, 'index.js');
-    const handlerFilePath = __rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, 'vercel-handler.cjs');
+    const vercelOutput = node_path.join(appDirectory, '.vercel');
+    const outputDirectory = node_path.join(vercelOutput, 'output');
+    const funcsDirectory = node_path.join(outputDirectory, 'functions', 'index.func');
+    const entryFilePath = node_path.join(funcsDirectory, 'index.js');
     return {
         async prepare () {
             await fs.remove(vercelOutput);
@@ -59,21 +52,21 @@ const createVercelPreset = (appContext, modernConfig, needModernServer)=>{
                 });
             }
             await fs.ensureDir(outputDirectory);
-            await fs.writeJSON(__rspack_external_node_path_c5b9b54f["default"].join(outputDirectory, 'config.json'), config, {
+            await fs.writeJSON(node_path.join(outputDirectory, 'config.json'), config, {
                 spaces: 2
             });
-            const staticDirectory = __rspack_external_node_path_c5b9b54f["default"].join(outputDirectory, 'static/static');
-            await fs.copy(__rspack_external_node_path_c5b9b54f["default"].join(distDirectory, 'static'), staticDirectory);
+            const staticDirectory = node_path.join(outputDirectory, 'static/static');
+            await fs.copy(node_path.join(distDirectory, 'static'), staticDirectory);
             if (needModernServer) {
                 await fs.ensureDir(funcsDirectory);
                 await fs.copy(distDirectory, funcsDirectory, {
                     filter: (src)=>{
-                        const distStaticDirectory = __rspack_external_node_path_c5b9b54f["default"].join(distDirectory, 'static');
+                        const distStaticDirectory = node_path.join(distDirectory, 'static');
                         return !src.includes(distStaticDirectory);
                     }
                 });
                 const nodeVersion = process.versions.node.split('.')[0];
-                await fs.writeJSON(__rspack_external_node_path_c5b9b54f["default"].join(funcsDirectory, '.vc-config.json'), {
+                await fs.writeJSON(node_path.join(funcsDirectory, '.vc-config.json'), {
                     runtime: `nodejs${nodeVersion}.x`,
                     handler: 'index.js',
                     launcherType: 'Nodejs',
@@ -81,44 +74,31 @@ const createVercelPreset = (appContext, modernConfig, needModernServer)=>{
                     supportsResponseStreaming: true
                 });
             } else {
-                const destHtmlDirectory = __rspack_external_node_path_c5b9b54f["default"].join(distDirectory, 'html');
-                const outputHtmlDirectory = __rspack_external_node_path_c5b9b54f["default"].join(__rspack_external_node_path_c5b9b54f["default"].join(outputDirectory, 'static'), 'html');
+                const destHtmlDirectory = node_path.join(distDirectory, 'html');
+                const outputHtmlDirectory = node_path.join(node_path.join(outputDirectory, 'static'), 'html');
                 await fs.copy(destHtmlDirectory, outputHtmlDirectory);
             }
         },
         async genEntry () {
             if (!needModernServer) return;
-            const serverConfig = {
-                bff: {
-                    prefix: modernConfig?.bff?.prefix
-                },
-                output: {
-                    distPath: {
-                        root: '.'
-                    }
-                }
-            };
-            const pluginImportCode = genPluginImportsCode(plugins || []);
-            const dynamicProdOptions = {
-                config: serverConfig
-            };
-            const meta = getMeta(metaName);
-            const serverConfigPath = `path.join(__dirname, "${SERVER_DIR}", "${meta}.server")`;
-            const pluginsCode = getPluginsCode(plugins || []);
-            const serverAppContext = serverAppContenxtTemplate(appContext);
-            let handlerCode = (await fs.readFile(__rspack_external_node_path_c5b9b54f["default"].join(vercel_dirname, './vercel-handler.js'))).toString();
-            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_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.writeFile(entryFilePath, "import { handler } from './vercel-handler.cjs';\nexport default handler;\n");
-            else await fs.writeFile(entryFilePath, "const { handler } = require('./vercel-handler.cjs');\nmodule.exports = handler;\n");
+            const template = await readTemplate(`vercel-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
+            const code = await generateHandler({
+                template,
+                appContext,
+                config: modernConfig,
+                isESM: isEsmProject
+            });
+            await fs.writeFile(entryFilePath, code);
         },
         async end () {
             if (!needModernServer) return;
+            const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
+            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
             await nodeDepEmit({
                 appDir: appDirectory,
                 sourceDir: funcsDirectory,
                 includeEntries: [
-                    require.resolve('@modern-js/prod-server')
+                    entry
                 ],
                 copyWholePackage (pkgName) {
                     return '@modern-js/utils' === pkgName;

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

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/plugins/deploy/utils/generator.mjs

@@ -0,0 +1,48 @@
+import "node:module";
+import node_path from "node:path";
+import { ROUTE_SPEC_FILE, SERVER_DIR, getMeta } from "@modern-js/utils";
+import { merge } from "@modern-js/utils/lodash";
+import { normalizePath } from "./index.mjs";
+const serverAppContextTemplate = (appContext)=>{
+    const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    return {
+        sharedDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, sharedDirectory))}")`,
+        apiDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, apiDirectory))}")`,
+        lambdaDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, lambdaDirectory))}")`,
+        metaName,
+        bffRuntimeFramework: bffRuntimeFramework || 'hono'
+    };
+};
+const genPluginImportsCode = (plugins, isESM = false)=>plugins.map(([name, options], index)=>{
+        const im = isESM ? `import * as plugin_${index}_ns from '${name}'` : `const plugin_${index}_ns = require('${name}')`;
+        return `${im};const plugin_${index} = plugin_${index}_ns.default || plugin_${index}_ns`;
+    }).join(';\n');
+const getPluginsCode = (plugins)=>`[${plugins.map(([, options], index)=>`plugin_${index}(${options ? JSON.stringify(options) : ''})`).join(',')}]`;
+const getServerConfigPath = (meta)=>`"${normalizePath(node_path.join(SERVER_DIR, `${meta}.server`))}"`;
+const generateHandler = async ({ template, appContext, config, serverConfig: modifyServerConfig, genAppContextTemplate = serverAppContextTemplate, genPluginImports = genPluginImportsCode, isESM })=>{
+    const { serverPlugins, metaName } = appContext;
+    const plugins = serverPlugins.map((plugin)=>[
+            plugin.name,
+            plugin.options
+        ]);
+    const serverConfig = merge({
+        bff: {
+            prefix: config?.bff?.prefix
+        },
+        output: {
+            distPath: {
+                root: '.'
+            }
+        }
+    }, modifyServerConfig || {});
+    const meta = getMeta(metaName);
+    const pluginImportCode = genPluginImports(plugins || [], Boolean(isESM));
+    const dynamicProdOptions = {
+        config: serverConfig
+    };
+    const serverConfigPath = getServerConfigPath(meta);
+    const pluginsCode = getPluginsCode(plugins);
+    const serverAppContext = genAppContextTemplate(appContext);
+    return template.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);
+};
+export { genPluginImportsCode, generateHandler, getPluginsCode, getServerConfigPath, serverAppContextTemplate };

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

@@ -0,0 +1,44 @@
+import "node:module";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import path from "path";
+import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta } from "@modern-js/utils";
+var utils_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
+const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
+    const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+    const { routes } = fs.readJSONSync(routeJSON);
+    let useSSR = false;
+    let useAPI = false;
+    routes.forEach((route)=>{
+        if (route.isSSR) useSSR = true;
+        if (route.isApi) useAPI = true;
+    });
+    const meta = getMeta(metaName);
+    const serverConfigPath = path.resolve(appDirectory, SERVER_DIR, `${meta}.server`);
+    const isServerConfigExists = [
+        '.ts',
+        '.js'
+    ].some((ex)=>fs.existsSync(`${serverConfigPath}${ex}`));
+    return {
+        useSSR,
+        useAPI,
+        useWebServer: isServerConfigExists
+    };
+};
+const getTemplatePath = (file)=>path.join(utils_dirname, '../platforms/templates', file);
+const readTemplate = async (file)=>(await fs.readFile(getTemplatePath(file))).toString();
+const resolveESMDependency = async (entry)=>{
+    const conditions = new Set([
+        'node',
+        'import',
+        'module',
+        'default'
+    ]);
+    try {
+        const { moduleResolve } = await import("import-meta-resolve");
+        return normalizePath(moduleResolve(entry, pathToFileURL(`${utils_dirname}/`), conditions, false).pathname.replace(/^\/(\w)\:/, '$1:'));
+    } catch (err) {}
+};
+export { getProjectUsage, getTemplatePath, normalizePath, readTemplate, resolveESMDependency };

package/dist/esm-node/utils/loadPlugins.mjs

@@ -1,6 +1,6 @@
 import "node:module";
+import { loadServerPlugins } from "@modern-js/prod-server";
 import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
-import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
 const debug = createDebugger('load-plugins');
 async function getServerPlugins(api, metaName = 'modern-js') {
     const hooks = api.getHooks();
@@ -13,9 +13,9 @@ async function getServerPlugins(api, metaName = 'modern-js') {
     });
     return filtedPlugins;
 }
-async function loadServerPlugins(api, appDirectory, metaName) {
+async function loadPlugins_loadServerPlugins(api, appDirectory, metaName) {
     const plugins = await getServerPlugins(api, metaName);
-    const instances = await (0, __rspack_external__modern_js_prod_server_057184e2.loadServerPlugins)(plugins, appDirectory);
+    const instances = await loadServerPlugins(plugins, appDirectory);
     return instances;
 }
 const resolveCliPlugin = async (p, appDirectory)=>{
@@ -43,4 +43,4 @@ const loadInternalPlugins = async (appDirectory, internalPlugins)=>{
     }));
     return loadedPlugins;
 };
-export { getServerPlugins, loadInternalPlugins, loadServerPlugins };
+export { getServerPlugins, loadInternalPlugins, loadPlugins_loadServerPlugins as loadServerPlugins };

package/dist/esm-node/utils/register.mjs

@@ -1,20 +1,12 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { fs, getAliasConfig, loadFromProject, readTsConfigByFile, tryResolve } from "@modern-js/utils";
-import * as __rspack_external_node_path_c5b9b54f from "node:path";
-const checkDepExist = (dep, appDir)=>{
-    try {
-        tryResolve(dep, appDir, process.cwd());
-        return true;
-    } catch  {
-        return false;
-    }
-};
+import node_path from "node:path";
+import { fs, getAliasConfig, isDepExists, loadFromProject, readTsConfigByFile } from "@modern-js/utils";
 const setupTsRuntime = async (appDir, distDir, alias)=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
-    const tsconfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDir, TS_CONFIG_FILENAME);
+    const tsconfigPath = node_path.resolve(appDir, TS_CONFIG_FILENAME);
     const isTsProject = await fs.pathExists(tsconfigPath);
-    const hasTsNode = checkDepExist('ts-node', appDir);
+    const hasTsNode = isDepExists(appDir, 'ts-node');
     if (!isTsProject || !hasTsNode) return;
     const aliasConfig = getAliasConfig(alias, {
         appDirectory: appDir,
@@ -31,7 +23,7 @@ const setupTsRuntime = async (appDir, distDir, alias)=>{
                 ]
             });
         } catch  {}
-        if ('string' == typeof tsPath && __rspack_external_node_path_c5b9b54f["default"].isAbsolute(tsPath)) tsPath = __rspack_external_node_path_c5b9b54f["default"].relative(absoluteBaseUrl, tsPath);
+        if ('string' == typeof tsPath && node_path.isAbsolute(tsPath)) tsPath = node_path.relative(absoluteBaseUrl, tsPath);
         if ('string' == typeof tsPath) tsPath = [
             tsPath
         ];
@@ -50,7 +42,7 @@ const setupTsRuntime = async (appDir, distDir, alias)=>{
         transpileOnly: true,
         ignore: [
             '(?:^|/)node_modules/',
-            `(?:^|/)${__rspack_external_node_path_c5b9b54f["default"].relative(appDir, distDir)}/`
+            `(?:^|/)${node_path.relative(appDir, distDir)}/`
         ],
         ...tsNodeOptions
     });

package/dist/types/plugins/analyze/utils.d.ts

@@ -4,7 +4,7 @@ export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;
 }) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean]>;
-export declare const getServerCombinedModueFile: (internalDirectory: string, entryName: string) => string;
+export declare const getServerCombinedModuleFile: (internalDirectory: string, entryName: string) => string;
 export declare const checkIsBuildCommands: () => boolean;
 export declare const checkIsServeCommand: () => boolean;
 export declare const isSubDirOrEqual: (parent: string, child: string) => boolean;

package/dist/types/plugins/deploy/platforms/platform.d.ts

@@ -1,6 +1,13 @@
 import type { AppToolsNormalizedConfig } from '../../../types';
 import type { AppToolsContext } from '../../../types/plugin';
-export type CreatePreset = (appContext: AppToolsContext, config: AppToolsNormalizedConfig, needModernServer?: boolean) => DeployPreset;
+import type { PluginAPI } from '../types';
+interface CreatePresetParams {
+    appContext: AppToolsContext;
+    modernConfig: AppToolsNormalizedConfig;
+    api: PluginAPI;
+    needModernServer?: boolean;
+}
+export type CreatePreset = (params: CreatePresetParams) => DeployPreset;
 type DeployPreset = {
     prepare?: () => Promise<void>;
     writeOutput?: () => Promise<void>;

package/dist/types/plugins/deploy/platforms/templates/netlify-entry.d.mts

@@ -0,0 +1,2 @@
+export default handler;
+declare function handler(request: any, context: any): Promise<any>;

package/dist/types/plugins/deploy/platforms/templates/node-entry.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/deploy/platforms/templates/vercel-entry.d.cts

@@ -0,0 +1,2 @@
+export = handler;
+declare function handler(req: any, res: any): Promise<any>;

package/dist/types/plugins/deploy/platforms/templates/vercel-entry.d.mts

@@ -0,0 +1,2 @@
+export default handler;
+declare function handler(req: any, res: any): Promise<any>;

package/dist/types/plugins/deploy/types.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '../../types';
+export type Setup = NonNullable<CliPlugin<AppTools>['setup']>;
+export type PluginAPI = Parameters<Setup>[0];

package/dist/types/plugins/deploy/utils/generator.d.ts

@@ -0,0 +1,24 @@
+import type { ProdServerOptions } from '@modern-js/prod-server';
+import type { AppToolsNormalizedConfig } from '../../../types';
+import type { AppToolsContext } from '../../../types/plugin';
+export declare const serverAppContextTemplate: (appContext: AppToolsContext) => {
+    sharedDirectory: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    metaName: string;
+    bffRuntimeFramework: string;
+};
+export type PluginItem = [string, Record<string, any> | undefined];
+export declare const genPluginImportsCode: (plugins: PluginItem[], isESM?: boolean) => string;
+export declare const getPluginsCode: (plugins: PluginItem[]) => string;
+export declare const getServerConfigPath: (meta: string) => string;
+export interface GenerateHandlerOptions {
+    template: string;
+    appContext: AppToolsContext;
+    config: AppToolsNormalizedConfig;
+    serverConfig?: Partial<ProdServerOptions>;
+    genAppContextTemplate?: typeof serverAppContextTemplate;
+    genPluginImports?: typeof genPluginImportsCode;
+    isESM?: boolean;
+}
+export declare const generateHandler: ({ template, appContext, config, serverConfig: modifyServerConfig, genAppContextTemplate, genPluginImports, isESM, }: GenerateHandlerOptions) => Promise<string>;

package/dist/types/plugins/deploy/utils/index.d.ts

@@ -0,0 +1,16 @@
+export type ServerAppContext = {
+    sharedDirectory: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    metaName: string;
+    bffRuntimeFramework: string;
+};
+export declare const normalizePath: (filePath: string) => string;
+export declare const getProjectUsage: (appDirectory: string, distDirectory: string, metaName: string) => {
+    useSSR: boolean;
+    useAPI: boolean;
+    useWebServer: boolean;
+};
+export declare const getTemplatePath: (file: string) => string;
+export declare const readTemplate: (file: string) => Promise<string>;
+export declare const resolveESMDependency: (entry: string) => Promise<string | undefined>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.0.5",
+  "version": "3.1.0",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -88,21 +88,22 @@
     "es-module-lexer": "^1.7.0",
     "esbuild": "0.25.5",
     "esbuild-register": "^3.6.0",
+    "import-meta-resolve": "^4.2.0",
     "flatted": "^3.4.0",
     "mlly": "^1.8.0",
     "ndepe": "^0.1.13",
     "pkg-types": "^1.3.1",
     "std-env": "^3.10.0",
-    "@modern-js/builder": "3.0.5",
-    "@modern-js/i18n-utils": "3.0.5",
-    "@modern-js/plugin": "3.0.5",
-    "@modern-js/plugin-data-loader": "3.0.5",
-    "@modern-js/prod-server": "3.0.5",
-    "@modern-js/server": "3.0.5",
-    "@modern-js/server-core": "3.0.5",
-    "@modern-js/server-utils": "3.0.5",
-    "@modern-js/types": "3.0.5",
-    "@modern-js/utils": "3.0.5"
+    "@modern-js/builder": "3.1.0",
+    "@modern-js/i18n-utils": "3.1.0",
+    "@modern-js/plugin": "3.1.0",
+    "@modern-js/plugin-data-loader": "3.1.0",
+    "@modern-js/prod-server": "3.1.0",
+    "@modern-js/server": "3.1.0",
+    "@modern-js/server-utils": "3.1.0",
+    "@modern-js/server-core": "3.1.0",
+    "@modern-js/types": "3.1.0",
+    "@modern-js/utils": "3.1.0"
   },
   "devDependencies": {
     "@rslib/core": "0.19.6",

package/rslib.config.mts

@@ -1,3 +1,4 @@
+import path from 'path';
 import { rslibConfig } from '@modern-js/rslib';
 import { defineConfig } from '@rslib/core';
 
@@ -6,6 +7,16 @@ export default defineConfig({
   lib: rslibConfig.lib?.map(libConfig => {
     return {
       ...libConfig,
+      source: {
+        ...libConfig.source,
+        entry: {
+          index: [
+            './src/**',
+            '!src/plugins/deploy/platforms/templates/*.mjs',
+            '!src/plugins/deploy/platforms/templates/*.cjs',
+          ],
+        },
+      },
       output: {
         ...libConfig.output,
         copy: [
@@ -13,6 +24,14 @@ export default defineConfig({
             from: './src/esm',
             to: './esm',
           },
+          {
+            from: 'plugins/deploy/platforms/templates/*.cjs',
+            context: path.join(__dirname, 'src'),
+          },
+          {
+            from: 'plugins/deploy/platforms/templates/*.mjs',
+            context: path.join(__dirname, 'src'),
+          },
         ],
       },
     };