@modern-js/app-tools 2.50.0 → 2.50.1-alpha.0

package/dist/cjs/analyze/getServerRoutes.js

@@ -34,6 +34,7 @@ module.exports = __toCommonJS(getServerRoutes_exports);
 var import_path = __toESM(require("path"));
 var import_fs = __toESM(require("fs"));
 var import_utils = require("@modern-js/utils");
+var import_routes = require("../utils/routes");
 var import_utils2 = require("./utils");
 const applyBaseUrl = (baseUrl, routes) => {
   if (baseUrl) {
@@ -106,14 +107,14 @@ const collectHtmlRoutes = (entrypoints, appContext, config) => {
   const { packageName } = appContext;
   const workerSSR = deploy === null || deploy === void 0 ? void 0 : (_deploy_worker = deploy.worker) === null || _deploy_worker === void 0 ? void 0 : _deploy_worker.ssr;
   let htmlRoutes = entrypoints.reduce((previous, { entryName }) => {
-    const isMainEntry = entryName === (mainEntryName || import_utils.MAIN_ENTRY_NAME);
-    const entryOptions = (0, import_utils.getEntryOptions)(entryName, isMainEntry, ssr, ssrByEntries, packageName);
+    const isMain = (0, import_routes.isMainEntry)(entryName, mainEntryName);
+    const entryOptions = (0, import_utils.getEntryOptions)(entryName, isMain, ssr, ssrByEntries, packageName);
     const isSSR = Boolean(entryOptions);
     const isWorker = Boolean(workerSSR);
     const isStream = typeof entryOptions === "object" && (entryOptions.mode === "stream" || Boolean(entryOptions.preload));
     const { resHeaders } = (routes === null || routes === void 0 ? void 0 : routes[entryName]) || {};
     let route = {
-      urlPath: `/${isMainEntry ? "" : entryName}`,
+      urlPath: `/${isMain ? "" : entryName}`,
       entryName,
       entryPath: (0, import_utils.removeLeadingSlash)(import_path.default.posix.normalize(`${htmlPath}/${entryName}${disableHtmlFolder ? ".html" : "/index.html"}`)),
       isSPA: true,

package/dist/cjs/commands/deploy.js

@@ -26,6 +26,7 @@ const deploy = async (api, options) => {
   const hookRunners = api.useHookRunners();
   await (0, import_getServerInternalPlugins.getServerInternalPlugins)(api);
   await hookRunners.beforeDeploy(options);
+  await hookRunners.deploy(options);
   await hookRunners.afterDeploy(options);
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/hooks.js

@@ -42,6 +42,7 @@ const hooks = {
   beforeBuild: (0, import_plugin.createAsyncWorkflow)(),
   afterBuild: (0, import_plugin.createAsyncWorkflow)(),
   beforeDeploy: (0, import_plugin.createAsyncWorkflow)(),
+  deploy: (0, import_plugin.createAsyncWorkflow)(),
   afterDeploy: (0, import_plugin.createAsyncWorkflow)(),
   beforeRestart: (0, import_plugin.createAsyncWorkflow)(),
   registerDev: (0, import_plugin.createParallelWorkflow)(),

package/dist/cjs/index.js

@@ -47,6 +47,7 @@ var import_initialize = __toESM(require("./initialize"));
 var import_hooks = require("./hooks");
 var import_locale = require("./locale");
 var import_serverBuild = __toESM(require("./plugins/serverBuild"));
+var import_deploy = __toESM(require("./plugins/deploy"));
 var import_restart = require("./utils/restart");
 var import_generateWatchFiles = require("./utils/generateWatchFiles");
 var import_core = require("@modern-js/core");
@@ -120,7 +121,8 @@ const appTools = (options = {
       bundler: (options === null || options === void 0 ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
     }),
     (0, import_serverBuild.default)(),
-    (0, import_plugin_lint.lintPlugin)()
+    (0, import_plugin_lint.lintPlugin)(),
+    (0, import_deploy.default)()
   ],
   setup: (api) => {
     const appContext = api.useAppContext();

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

@@ -0,0 +1,217 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dependencies_exports = {};
+__export(dependencies_exports, {
+  handleDependencies: () => handleDependencies
+});
+module.exports = __toCommonJS(dependencies_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_utils = require("@modern-js/utils");
+var import_pkg_types = require("pkg-types");
+var import_mlly = require("mlly");
+var import_utils2 = require("./utils");
+const handleDependencies = async (appDir, serverRootDir, include, entryFilter) => {
+  const base = "/";
+  const entryFiles = await (0, import_utils2.findEntryFiles)(serverRootDir, entryFilter);
+  const includeEntries = include.map((item) => {
+    if ((0, import_node_path.isAbsolute)(item)) {
+      return item;
+    }
+    try {
+      return require.resolve(item);
+    } catch (error) {
+    }
+    return item;
+  });
+  const fileTrace = await (0, import_utils2.traceFiles)(entryFiles.concat(includeEntries), serverRootDir, base);
+  const currentProjectModules = import_node_path.default.join(appDir, "node_modules");
+  const tracedFiles = Object.fromEntries(await Promise.all([
+    ...fileTrace.reasons.entries()
+  ].map(async ([_path, reasons]) => {
+    if (reasons.ignored) {
+      return;
+    }
+    const filePath = await (0, import_utils2.resolveTracedPath)(base, _path);
+    if (filePath.startsWith(serverRootDir) || filePath.startsWith(appDir) && !filePath.startsWith(currentProjectModules)) {
+      return;
+    }
+    if (!await (0, import_utils2.isFile)(filePath)) {
+      return;
+    }
+    let baseDir;
+    let pkgName;
+    let subpath;
+    let pkgPath;
+    if (filePath.includes("node_modules")) {
+      const parsed = (0, import_mlly.parseNodeModulePath)(filePath);
+      baseDir = parsed.dir;
+      pkgName = parsed.name;
+      subpath = parsed.subpath;
+      pkgPath = import_node_path.default.join(baseDir, pkgName);
+    } else {
+      const MODERN_UTILS_PATH = "packages/toolkit/utils";
+      const MODERN_UTILS_PATH_REGEX = new RegExp(`(.*${MODERN_UTILS_PATH})`);
+      const match = filePath.match(MODERN_UTILS_PATH_REGEX);
+      const packageJsonPath = match ? import_node_path.default.join(match[0], "package.json") : await (0, import_utils.pkgUp)({
+        cwd: import_node_path.default.dirname(filePath)
+      });
+      if (packageJsonPath) {
+        const packageJson = await import_utils.fs.readJSON(packageJsonPath);
+        pkgPath = baseDir = import_node_path.default.dirname(packageJsonPath);
+        subpath = import_node_path.default.relative(baseDir, filePath);
+        pkgName = packageJson.name;
+      }
+    }
+    if (!baseDir) {
+      return;
+    }
+    const parents = await Promise.all([
+      ...reasons.parents
+    ].map((p) => (0, import_utils2.resolveTracedPath)(base, p)));
+    const tracedFile = {
+      path: filePath,
+      parents,
+      isDirectDep: parents.some((parent) => {
+        return parent.startsWith(appDir) && !parent.startsWith(currentProjectModules);
+      }),
+      subpath,
+      pkgName,
+      pkgPath
+    };
+    return [
+      filePath,
+      tracedFile
+    ];
+  })).then((r) => r.filter(Boolean)));
+  const tracedPackages = {};
+  for (const tracedFile of Object.values(tracedFiles)) {
+    const { pkgName } = tracedFile;
+    let tracedPackage = tracedPackages[pkgName];
+    let pkgJSON = await (0, import_pkg_types.readPackageJSON)(tracedFile.pkgPath, {
+      cache: true
+    }).catch(() => {
+    });
+    if (!pkgJSON) {
+      pkgJSON = {
+        name: pkgName,
+        version: "0.0.0"
+      };
+    }
+    if (!tracedPackage) {
+      tracedPackage = {
+        name: pkgName,
+        versions: {}
+      };
+      tracedPackages[pkgName] = tracedPackage;
+    }
+    let tracedPackageVersion = tracedPackage.versions[pkgJSON.version];
+    if (!tracedPackageVersion) {
+      tracedPackageVersion = {
+        path: tracedFile.pkgPath,
+        files: [],
+        isDirectDep: false,
+        pkgJSON
+      };
+      if (tracedFile.isDirectDep) {
+        tracedPackageVersion.isDirectDep = tracedFile.isDirectDep;
+      }
+      tracedPackage.versions[pkgJSON.version] = tracedPackageVersion;
+    }
+    tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.path === tracedFile.pkgPath && tracedPackageVersion.files.push(tracedFile.path);
+    tracedFile.pkgName = pkgName;
+    tracedFile.pkgVersion = pkgJSON.version;
+  }
+  const multiVersionPkgs = {};
+  const singleVersionPackages = [];
+  for (const tracedPackage of Object.values(tracedPackages)) {
+    const versions = Object.keys(tracedPackage.versions);
+    if (versions.length === 1) {
+      singleVersionPackages.push(tracedPackage.name);
+      continue;
+    }
+    multiVersionPkgs[tracedPackage.name] = {};
+    for (const version of versions) {
+      multiVersionPkgs[tracedPackage.name][version] = (0, import_utils2.findPackageParents)(tracedPackage, version, tracedFiles);
+    }
+  }
+  await Promise.all(singleVersionPackages.map((pkgName) => {
+    const pkg = tracedPackages[pkgName];
+    const version = Object.keys(pkg.versions)[0];
+    return (0, import_utils2.writePackage)(pkg, version, serverRootDir);
+  }));
+  const projectPkgJson = await (0, import_pkg_types.readPackageJSON)(serverRootDir).catch(() => ({}));
+  for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
+    const versionEntires = Object.entries(pkgVersions).sort(([v1, p1], [v2, p2]) => {
+      var _tracedPackages_pkgName_versions_v1, _tracedPackages_pkgName_versions, _tracedPackages_pkgName, _tracedPackages_pkgName_versions_v2, _tracedPackages_pkgName_versions1, _tracedPackages_pkgName1;
+      const shouldHoist1 = (_tracedPackages_pkgName = tracedPackages[pkgName]) === null || _tracedPackages_pkgName === void 0 ? void 0 : (_tracedPackages_pkgName_versions = _tracedPackages_pkgName.versions) === null || _tracedPackages_pkgName_versions === void 0 ? void 0 : (_tracedPackages_pkgName_versions_v1 = _tracedPackages_pkgName_versions[v1]) === null || _tracedPackages_pkgName_versions_v1 === void 0 ? void 0 : _tracedPackages_pkgName_versions_v1.isDirectDep;
+      const shouldHoist2 = (_tracedPackages_pkgName1 = tracedPackages[pkgName]) === null || _tracedPackages_pkgName1 === void 0 ? void 0 : (_tracedPackages_pkgName_versions1 = _tracedPackages_pkgName1.versions) === null || _tracedPackages_pkgName_versions1 === void 0 ? void 0 : (_tracedPackages_pkgName_versions_v2 = _tracedPackages_pkgName_versions1[v2]) === null || _tracedPackages_pkgName_versions_v2 === void 0 ? void 0 : _tracedPackages_pkgName_versions_v2.isDirectDep;
+      if (shouldHoist1 && !shouldHoist2) {
+        return -1;
+      }
+      if (!shouldHoist1 && shouldHoist2) {
+        return 1;
+      }
+      if (p1.length === 0) {
+        return -1;
+      }
+      if (p2.length === 0) {
+        return 1;
+      }
+      return import_utils.semver.lt(v1, v2, {
+        loose: true
+      }) ? 1 : -1;
+    });
+    for (const [version, parentPkgs] of versionEntires) {
+      const pkg = tracedPackages[pkgName];
+      const pkgDestPath = `.modernjs/${pkgName}@${version}/node_modules/${pkgName}`;
+      await (0, import_utils2.writePackage)(pkg, version, serverRootDir, pkgDestPath);
+      await (0, import_utils2.linkPackage)(pkgDestPath, `${pkgName}`, serverRootDir);
+      for (const parentPkg of parentPkgs) {
+        const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
+        await (multiVersionPkgs[parentPkgName] ? (0, import_utils2.linkPackage)(pkgDestPath, `.modernjs/${parentPkg}/node_modules/${pkgName}`, serverRootDir) : (0, import_utils2.linkPackage)(pkgDestPath, `${parentPkgName}/node_modules/${pkgName}`, serverRootDir));
+      }
+    }
+  }
+  const outputPkgPath = import_node_path.default.join(serverRootDir, "package.json");
+  await import_utils.fs.writeJSON(outputPkgPath, {
+    name: `${projectPkgJson.name || "modernjs-project"}-prod`,
+    version: projectPkgJson.version || "0.0.0",
+    private: true,
+    dependencies: Object.fromEntries([
+      ...Object.values(tracedPackages).map((pkg) => [
+        pkg.name,
+        Object.keys(pkg.versions)[0]
+      ])
+    ].sort(([a], [b]) => a.localeCompare(b)))
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleDependencies
+});

package/dist/cjs/plugins/deploy/dependencies/utils.js

@@ -0,0 +1,165 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  findEntryFiles: () => findEntryFiles,
+  findPackageParents: () => findPackageParents,
+  isFile: () => isFile,
+  linkPackage: () => linkPackage,
+  readDirRecursive: () => readDirRecursive,
+  resolveTracedPath: () => resolveTracedPath,
+  traceFiles: () => traceFiles,
+  writePackage: () => writePackage
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_node_os = __toESM(require("node:os"));
+var import_utils = require("@modern-js/utils");
+var import_mlly = require("mlly");
+var import_nft = require("@vercel/nft");
+function applyPublicCondition(pkg) {
+  var _pkg_publishConfig;
+  if (pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig = pkg.publishConfig) === null || _pkg_publishConfig === void 0 ? void 0 : _pkg_publishConfig.exports) {
+    var _pkg_publishConfig1;
+    pkg.exports = pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig1 = pkg.publishConfig) === null || _pkg_publishConfig1 === void 0 ? void 0 : _pkg_publishConfig1.exports;
+  }
+}
+const writePackage = async (pkg, version, projectDir, _pkgPath) => {
+  const pkgPath = _pkgPath || pkg.name;
+  for (const src of pkg.versions[version].files) {
+    if (src.includes("node_modules")) {
+      const { subpath } = (0, import_mlly.parseNodeModulePath)(src);
+      const dest = import_path.default.join(projectDir, "node_modules", pkgPath, subpath);
+      const dirname = import_path.default.dirname(dest);
+      await import_utils.fs.ensureDir(dirname);
+      await import_utils.fs.copyFile(src, dest);
+    } else {
+      const subpath = import_path.default.relative(pkg.versions[version].path, src);
+      const dest = import_path.default.join(projectDir, "node_modules", pkgPath, subpath);
+      const dirname = import_path.default.dirname(dest);
+      await import_utils.fs.ensureDir(dirname);
+      await import_utils.fs.copyFile(src, dest);
+    }
+  }
+  const { pkgJSON } = pkg.versions[version];
+  applyPublicCondition(pkgJSON);
+  const packageJsonPath = import_path.default.join(projectDir, "node_modules", pkgPath, "package.json");
+  await import_utils.fs.ensureDir(import_path.default.dirname(packageJsonPath));
+  await import_utils.fs.writeFile(packageJsonPath, JSON.stringify(pkgJSON, null, 2));
+};
+const isWindows = import_node_os.default.platform() === "win32";
+const linkPackage = async (from, to, projectRootDir) => {
+  const src = import_path.default.join(projectRootDir, "node_modules", from);
+  const dest = import_path.default.join(projectRootDir, "node_modules", to);
+  const dstStat = await import_utils.fs.lstat(dest).catch(() => null);
+  const exists = dstStat === null || dstStat === void 0 ? void 0 : dstStat.isSymbolicLink();
+  if (exists) {
+    return;
+  }
+  await import_utils.fs.mkdir(import_path.default.dirname(dest), {
+    recursive: true
+  });
+  await import_utils.fs.symlink(import_path.default.relative(import_path.default.dirname(dest), src), dest, isWindows ? "junction" : "dir").catch((error) => {
+    console.error("Cannot link", from, "to", to, error);
+  });
+};
+const readDirRecursive = async (dir, options = {}) => {
+  const { filter } = options;
+  const files = await import_utils.fs.readdir(dir, {
+    withFileTypes: true
+  });
+  const filesAndDirs = await Promise.all(files.map(async (file) => {
+    const resolvedPath = import_path.default.resolve(dir, file.name);
+    if (file.isDirectory()) {
+      return readDirRecursive(resolvedPath, options);
+    } else {
+      return filter && !filter(resolvedPath) ? [] : resolvedPath;
+    }
+  }));
+  return filesAndDirs.flat();
+};
+const isFile = async (file) => {
+  try {
+    const stat = await import_utils.fs.stat(file);
+    return stat.isFile();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+const findEntryFiles = async (rootDir, entryFilter) => {
+  const files = await readDirRecursive(rootDir, {
+    filter: entryFilter
+  });
+  return files.filter((file) => file.endsWith(".mjs") || file.endsWith(".cjs") || file.endsWith(".js"));
+};
+const findPackageParents = (pkg, version, tracedFiles) => {
+  const versionFiles = pkg.versions[version].files.map((path2) => tracedFiles[path2]);
+  const parentPkgs = [
+    ...new Set(versionFiles.flatMap((file) => file.parents.map((parentPath) => {
+      const parentFile = tracedFiles[parentPath];
+      if (!parentFile || parentFile.pkgName === pkg.name) {
+        return null;
+      }
+      return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
+    }).filter(Boolean)))
+  ];
+  return parentPkgs;
+};
+const traceFiles = async (entryFiles, serverRootDir, base = "/") => {
+  return await (0, import_nft.nodeFileTrace)(entryFiles, {
+    base,
+    processCwd: serverRootDir,
+    resolve: async (id, parent, job, isCjs) => {
+      if (id.startsWith("@modern-js/prod-server")) {
+        return require.resolve(id, {
+          paths: [
+            require.resolve("@modern-js/app-tools")
+          ]
+        });
+      } else {
+        return (0, import_nft.resolve)(id, parent, job, isCjs);
+      }
+    }
+  });
+};
+const resolveTracedPath = async (base, p) => import_utils.fs.realpath(import_path.default.resolve(base, p));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findEntryFiles,
+  findPackageParents,
+  isFile,
+  linkPackage,
+  readDirRecursive,
+  resolveTracedPath,
+  traceFiles,
+  writePackage
+});

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

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deploy_exports = {};
+__export(deploy_exports, {
+  default: () => deploy_default
+});
+module.exports = __toCommonJS(deploy_exports);
+var import_std_env = require("std-env");
+var import_utils = require("./utils");
+var import_node = require("./platforms/node");
+var import_vercel = require("./platforms/vercel");
+var import_netlify = require("./platforms/netlify");
+const deployPresets = {
+  node: import_node.createNodePreset,
+  vercel: import_vercel.createVercelPreset,
+  netlify: import_netlify.createNetlifyPreset
+};
+async function getDeployPreset(appContext, modernConfig, deployTarget) {
+  const { appDirectory, distDirectory } = appContext;
+  const { useSSR, useAPI, useWebServer } = (0, import_utils.getProjectUsage)(appDirectory, distDirectory);
+  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);
+}
+var deploy_default = () => ({
+  name: "@modern-js/plugin-deploy",
+  setup: (api) => {
+    const deployTarget = process.env.MODERNJS_DEPLOY || import_std_env.provider || "node";
+    return {
+      async deploy() {
+        const appContext = api.useAppContext();
+        const { metaName } = appContext;
+        if (metaName !== "modern-js" && !process.env.MODERNJS_DEPLOY) {
+          return;
+        }
+        const modernConfig = api.useResolvedConfigContext();
+        const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget);
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare());
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput());
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry());
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end());
+      }
+    };
+  }
+});

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

@@ -0,0 +1,136 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var netlify_exports = {};
+__export(netlify_exports, {
+  createNetlifyPreset: () => createNetlifyPreset
+});
+module.exports = __toCommonJS(netlify_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_utils = require("@modern-js/utils");
+var import_routes = require("../../../utils/routes");
+var import_utils2 = require("../utils");
+var import_dependencies = require("../dependencies");
+async function cleanDistDirectory(dir) {
+  try {
+    const items = await import_utils.fs.readdir(dir);
+    for (const item of items) {
+      const fullPath = import_node_path.default.join(dir, item);
+      if (item !== "static" && item !== "_redirects") {
+        await import_utils.fs.remove(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error("Error cleaning directory:", error);
+  }
+}
+const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
+  const { appDirectory, distDirectory, serverInternalPlugins, entrypoints } = appContext;
+  const plugins = (0, import_utils.getInternalPlugins)(appDirectory, serverInternalPlugins);
+  const netlifyOutput = import_node_path.default.join(appDirectory, ".netlify");
+  const funcsDirectory = import_node_path.default.join(netlifyOutput, "functions");
+  const entryFilePath = import_node_path.default.join(funcsDirectory, "index.js");
+  return {
+    async prepare() {
+      await import_utils.fs.remove(netlifyOutput);
+    },
+    async writeOutput() {
+      const routes = [];
+      const { source: { mainEntryName } } = modernConfig;
+      if (!needModernServer) {
+        entrypoints.forEach((entry) => {
+          const isMain = (0, import_routes.isMainEntry)(entry.entryName, mainEntryName);
+          routes.push({
+            src: `/${isMain ? "" : `${entry.entryName}/`}*`,
+            dest: `/html/${entry.entryName}/index.html`,
+            status: 200
+          });
+        });
+      } else {
+        routes.push({
+          src: "/*",
+          dest: `/.netlify/functions/index`,
+          status: 200
+        });
+      }
+      const redirectContent = routes.map((route) => {
+        return `${route.src} ${route.dest} ${route.status}`;
+      }).join("\n");
+      if (needModernServer) {
+        await import_utils.fs.ensureDir(funcsDirectory);
+        await import_utils.fs.copy(distDirectory, funcsDirectory, {
+          filter: (src) => {
+            const distStaticDirectory = import_node_path.default.join(distDirectory, `static`);
+            return !src.includes(distStaticDirectory);
+          }
+        });
+      }
+      const redirectFilePath = import_node_path.default.join(distDirectory, "_redirects");
+      await import_utils.fs.writeFile(redirectFilePath, redirectContent);
+    },
+    async genEntry() {
+      var _modernConfig_bff;
+      if (!needModernServer) {
+        return;
+      }
+      const serverConfig = {
+        bff: {
+          prefix: modernConfig === null || modernConfig === void 0 ? void 0 : (_modernConfig_bff = modernConfig.bff) === null || _modernConfig_bff === void 0 ? void 0 : _modernConfig_bff.prefix
+        },
+        output: {
+          path: "."
+        }
+      };
+      const pluginImportCode = (0, import_utils2.genPluginImportsCode)(plugins || []);
+      const dynamicProdOptions = {
+        config: serverConfig,
+        serverConfigFile: import_utils.DEFAULT_SERVER_CONFIG,
+        plugins
+      };
+      let entryCode = (await import_utils.fs.readFile(import_node_path.default.join(__dirname, "./netlifyEntry.js"))).toString();
+      const serverAppContext = (0, import_utils2.serverAppContenxtTemplate)(appContext);
+      entryCode = entryCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${import_utils.ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      await import_utils.fs.writeFile(entryFilePath, entryCode);
+    },
+    async end() {
+      if (process.env.NODE_ENV !== "test" && process.env.NODE_ENV !== "development") {
+        await cleanDistDirectory(distDirectory);
+      }
+      if (!needModernServer) {
+        return;
+      }
+      await (0, import_dependencies.handleDependencies)(appDirectory, funcsDirectory, [
+        "@modern-js/prod-server"
+      ]);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNetlifyPreset
+});