@modern-js/app-tools 2.49.2 → 2.49.3-alpha.1

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

@@ -0,0 +1,186 @@
+"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_std_env = require("std-env");
+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) => {
+    const deployTarget = process.env.MODERNJS_DEPLOY || import_std_env.provider || "node";
+    return {
+      async beforeDeploy() {
+        const appContext = api.useAppContext();
+        const { appDirectory, distDirectory, serverInternalPlugins, sharedDirectory, apiDirectory, lambdaDirectory, metaName, entrypoints } = appContext;
+        const { useSSR, useAPI, useWebServer } = (0, import_utils2.getProjectUsage)(appDirectory, distDirectory);
+        const needModernServer = useSSR || useAPI || useWebServer;
+        const configContext = api.useResolvedConfigContext();
+        let outputDirectory = import_path.default.join(appDirectory, ".output");
+        let funcsDirectory = outputDirectory;
+        let staticDirectory = import_path.default.join(outputDirectory, "static");
+        if (deployTarget === "node") {
+          await import_utils.fs.remove(outputDirectory);
+          await import_utils.fs.copy(distDirectory, outputDirectory);
+        }
+        if (deployTarget === "vercel") {
+          const vercelOutput = import_path.default.join(appDirectory, ".vercel");
+          await import_utils.fs.remove(vercelOutput);
+          outputDirectory = import_path.default.join(vercelOutput, "output");
+          const config2 = {
+            version: 3,
+            routes: [
+              {
+                src: "/static/(.*)",
+                headers: {
+                  "cache-control": "s-maxage=31536000, immutable"
+                },
+                continue: true
+              },
+              {
+                handle: "filesystem"
+              }
+            ]
+          };
+          if (!needModernServer) {
+            entrypoints.forEach((entry) => {
+              config2.routes.push({
+                src: `/${entry.entryName}(?:/.*)?`,
+                headers: {
+                  "cache-control": "s-maxage=0"
+                },
+                dest: `/html/${entry.entryName}/index.html`
+              });
+            });
+          } else {
+            config2.routes.push({
+              src: "/(.*)",
+              dest: `/index`
+            });
+          }
+          await import_utils.fs.ensureDir(outputDirectory);
+          await import_utils.fs.writeJSON(import_path.default.join(outputDirectory, "config.json"), config2, {
+            spaces: 2
+          });
+          staticDirectory = import_path.default.join(outputDirectory, "static/static");
+          await import_utils.fs.copy(import_path.default.join(distDirectory, "static"), staticDirectory);
+          if (!needModernServer) {
+            const destHtmlDirectory = import_path.default.join(distDirectory, "html");
+            const outputHtmlDirectory = import_path.default.join(import_path.default.join(outputDirectory, "static"), "html");
+            await import_utils.fs.copy(destHtmlDirectory, outputHtmlDirectory);
+          } else {
+            funcsDirectory = import_path.default.join(outputDirectory, "functions", "index.func");
+            await import_utils.fs.ensureDir(funcsDirectory);
+            await import_utils.fs.copy(distDirectory, funcsDirectory, {
+              filter: (src) => {
+                const distStaticDirectory = import_path.default.join(distDirectory, "static");
+                return !src.includes(distStaticDirectory);
+              }
+            });
+            const apiDirectory2 = import_path.default.join(funcsDirectory, "api");
+            if (await import_utils.fs.pathExists(apiDirectory2)) {
+              await import_utils.fs.rename(apiDirectory2, import_path.default.join(funcsDirectory, "_api"));
+            }
+            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 entryFilePath = import_path.default.join(funcsDirectory, "index.js");
+        if (needModernServer) {
+          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/cjs/utils/register.js

@@ -73,7 +73,7 @@ const registerCompiler = async (appDir = process.cwd(), distDir, alias) => {
         transpileOnly: true,
         ignore: [
           "(?:^|/)node_modules/",
-          `(?:^|/)${distDir}/`
+          `(?:^|/)${import_node_path.default.relative(appDir, distDir)}/`
         ],
         ...tsNodeOptions
       });

package/dist/esm/builder/shared/builderPlugins/adapterSSR.js

@@ -3,7 +3,7 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import * as path from "path";
 import { isHtmlDisabled } from "@rsbuild/shared";
 import { mergeRsbuildConfig } from "@rsbuild/core";
-import { isSSR, fs } from "@modern-js/utils";
+import { fs, isUseSSRBundle } from "@modern-js/utils";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
 import { getServerCombinedModueFile } from "../../../analyze/utils";
 var builderPluginAdapterSSR = function(options) {
@@ -33,7 +33,7 @@ var builderPluginAdapterSSR = function(options) {
                 builderConfig = api.getNormalizedConfig();
                 normalizedConfig2 = options.normalizedConfig;
                 applyRouterPlugin(chain, "route-plugin", options, HtmlBundlerPlugin);
-                if (!isSSR(normalizedConfig2))
+                if (!isUseSSRBundle(normalizedConfig2))
                   return [
                     3,
                     2

package/dist/esm/config/default.js

@@ -70,7 +70,17 @@ function createDefaultConfig(appContext) {
     server,
     dev,
     html,
-    tools: {},
+    tools: {
+      tsChecker: {
+        issue: {
+          exclude: [
+            {
+              file: "**/api/lambda/**/*"
+            }
+          ]
+        }
+      }
+    },
     plugins: [],
     builderPlugins: [],
     runtime: {},

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();