@modern-js/app-tools 2.49.0 → 2.49.1-alpha.1

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

@@ -0,0 +1,140 @@
+"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 deploy_exports = {};
+__export(deploy_exports, {
+  default: () => deploy_default
+});
+module.exports = __toCommonJS(deploy_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("./utils");
+var import_dependencies = require("./dependencies");
+var deploy_default = () => ({
+  name: "@modern-js/plugin-deploy",
+  pre: [
+    "@modern-js/plugin-bff",
+    "@modern-js/plugin-server"
+  ],
+  setup: (api) => {
+    return {
+      async beforeDeploy() {
+        const deployTarget = process.env.MODERNJS_DEPLOY || "node";
+        const appContext = api.useAppContext();
+        const { appDirectory, distDirectory, serverInternalPlugins, sharedDirectory, apiDirectory, lambdaDirectory, metaName } = appContext;
+        const configContext = api.useResolvedConfigContext();
+        const outputDirectory = import_path.default.join(appDirectory, ".output");
+        let funcsDirectory = outputDirectory;
+        let staticDirectory = import_path.default.join(outputDirectory, "static");
+        await import_utils.fs.remove(outputDirectory);
+        if (deployTarget === "node") {
+          await import_utils.fs.copy(distDirectory, outputDirectory, {
+            filter: (src) => {
+              const distStaticDirectory = import_path.default.join(distDirectory, "static");
+              return !src.includes(distStaticDirectory);
+            }
+          });
+        }
+        if (deployTarget === "vercel") {
+          funcsDirectory = import_path.default.join(outputDirectory, "functions");
+          staticDirectory = import_path.default.join(outputDirectory, "static");
+          await import_utils.fs.copy(distDirectory, funcsDirectory, {
+            filter: (src) => {
+              const distStaticDirectory = import_path.default.join(distDirectory, "static");
+              return !src.includes(distStaticDirectory);
+            }
+          });
+          await import_utils.fs.copy(import_path.default.join(distDirectory, "static"), staticDirectory);
+          await import_utils.fs.writeJSON(import_path.default.join(funcsDirectory, ".vc-config.json"), {
+            runtime: "nodejs16.x",
+            handler: "index.js",
+            launcherType: "Nodejs",
+            shouldAddHelpers: false,
+            supportsResponseStreaming: true
+          });
+        }
+        const { bff } = configContext;
+        const config = {
+          output: {
+            path: "."
+          },
+          bff
+        };
+        const plugins = (0, import_utils.getInternalPlugins)(appDirectory, serverInternalPlugins);
+        const serverAppContext = {
+          sharedDirectory: `path.join(__dirname, "${import_path.default.relative(appDirectory, sharedDirectory)}")`,
+          apiDirectory: `path.join(__dirname, "${import_path.default.relative(appDirectory, apiDirectory)}")`,
+          lambdaDirectory: `path.join(__dirname, "${import_path.default.relative(appDirectory, lambdaDirectory)}")`,
+          metaName
+        };
+        let code = ``;
+        console.log("deployTarget111111111", deployTarget);
+        switch (deployTarget) {
+          case "node": {
+            const { genNodeEntry } = await Promise.resolve().then(() => __toESM(require("./entrys/node")));
+            code = genNodeEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          case "vercel": {
+            const { genVercelEntry } = await Promise.resolve().then(() => __toESM(require("./entrys/vercel")));
+            code = genVercelEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          case "netlify": {
+            const { genNetlifyEntry } = await Promise.resolve().then(() => __toESM(require("./entrys/netlify")));
+            code = genNetlifyEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          default: {
+            code = `throw new Error("unknown deploy target, MODERNJS_DEPLOY should be set");`;
+          }
+        }
+        const { useSSR, useAPI, useWebServer } = (0, import_utils2.getProjectUsage)(appDirectory, distDirectory);
+        const entryFilePath = import_path.default.join(funcsDirectory, "index.js");
+        if (useSSR || useAPI || useWebServer) {
+          await import_utils.fs.writeFile(entryFilePath, code);
+        }
+        await (0, import_dependencies.handleDependencies)(appDirectory, funcsDirectory, [
+          "@modern-js/prod-server"
+        ]);
+      }
+    };
+  }
+});

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

@@ -0,0 +1,150 @@
+"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, {
+  applyProductionCondition: () => applyProductionCondition,
+  applyPublicCondition: () => applyPublicCondition,
+  genPluginImportsCode: () => genPluginImportsCode,
+  getPluginsCode: () => getPluginsCode,
+  getProjectUsage: () => getProjectUsage,
+  linkPackage: () => linkPackage,
+  severAppContextTemplate: () => severAppContextTemplate,
+  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");
+const severAppContextTemplate = (serverAppContext) => {
+  return `{
+    sharedDirectory: ${serverAppContext.sharedDirectory},
+    apiDirectory: ${serverAppContext.apiDirectory},
+    lambdaDirectory: ${serverAppContext.lambdaDirectory},
+  }`;
+};
+const getPluginsCode = (plugins) => `[${plugins.map((_, index) => `plugin_${index}()`).join(",")}]`;
+const genPluginImportsCode = (plugins) => {
+  return plugins.map((plugin, index) => `
+      let plugin_${index} = require('${plugin}')
+      plugin_${index} = plugin_${index}.default || plugin_${index}
+      `).join(";\n");
+};
+const getProjectUsage = (appDirectory, distDirectory) => {
+  const routeJSON = import_path.default.join(distDirectory, import_utils.ROUTE_SPEC_FILE);
+  const { routes } = import_utils.fs.readJSONSync(routeJSON);
+  let useSSR = false;
+  let useAPI = false;
+  routes.forEach((route) => {
+    if (route.isSSR) {
+      useSSR = true;
+    }
+    if (route.isApi) {
+      useAPI = true;
+    }
+  });
+  const useWebServer = (0, import_utils.isDepExists)(appDirectory, "@modern-js/plugin-server");
+  return {
+    useSSR,
+    useAPI,
+    useWebServer
+  };
+};
+function applyProductionCondition(exports) {
+  if (!exports || typeof exports === "string") {
+    return;
+  }
+  if (exports.production) {
+    if (typeof exports.production === "string") {
+      exports.default = exports.production;
+    } else {
+      Object.assign(exports, exports.production);
+    }
+  }
+  for (const key in exports) {
+    applyProductionCondition(exports[key]);
+  }
+}
+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);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyProductionCondition,
+  applyPublicCondition,
+  genPluginImportsCode,
+  getPluginsCode,
+  getProjectUsage,
+  linkPackage,
+  severAppContextTemplate,
+  writePackage
+});

package/dist/esm/builder/builder-webpack/index.js

@@ -26,7 +26,7 @@ function _createWebpackBuilderForModern() {
           _normalizedConfig_tools = normalizedConfig.tools, esbuildOptions = _normalizedConfig_tools.esbuild;
           return [
             4,
-            import("@rsbuild/plugin-esbuild")
+            import("@modern-js/rsbuild-plugin-esbuild")
           ];
         case 2:
           pluginEsbuild = _state.sent().pluginEsbuild;

package/dist/esm/index.js

@@ -12,6 +12,7 @@ import initializePlugin from "./initialize";
 import { hooks } from "./hooks";
 import { i18n, localeKeys } from "./locale";
 import serverBuildPlugin from "./plugins/serverBuild";
+import deployPlugin from "./plugins/deploy";
 import { restart } from "./utils/restart";
 import { generateWatchFiles } from "./utils/generateWatchFiles";
 import { mergeConfig } from "@modern-js/core";
@@ -295,7 +296,8 @@ var appTools = function() {
         bundler: (options === null || options === void 0 ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
       }),
       serverBuildPlugin(),
-      lintPlugin()
+      lintPlugin(),
+      deployPlugin()
     ],
     setup: function(api) {
       var appContext = api.useAppContext();