@modern-js/app-tools 2.58.2 → 2.59.0

package/dist/esm-node/plugins/deploy/platforms/node.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { DEFAULT_SERVER_CONFIG, ROUTE_SPEC_FILE, chalk, fs as fse } from "@modern-js/utils";
+import { handleDependencies } from "../dependencies";
+import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
+const createNodePreset = (appContext, config) => {
+  const { appDirectory, distDirectory, serverPlugins, moduleType } = appContext;
+  const isEsmProject = moduleType === "module";
+  const plugins = serverPlugins.map((plugin) => plugin.name);
+  const outputDirectory = path.join(appDirectory, ".output");
+  const staticDirectory = path.join(outputDirectory, "static");
+  const entryFilePath = path.join(outputDirectory, "index.js");
+  return {
+    async prepare() {
+      await fse.remove(outputDirectory);
+    },
+    async writeOutput() {
+      await fse.copy(distDirectory, outputDirectory);
+    },
+    async genEntry() {
+      var _config_bff;
+      const serverConfig = {
+        server: {
+          port: 8080
+        },
+        bff: {
+          prefix: config === null || config === void 0 ? void 0 : (_config_bff = config.bff) === null || _config_bff === void 0 ? void 0 : _config_bff.prefix
+        },
+        output: {
+          distPath: {
+            root: "."
+          }
+        }
+      };
+      const pluginImportCode = genPluginImportsCode(plugins || []);
+      const dynamicProdOptions = {
+        config: serverConfig,
+        serverConfigFile: DEFAULT_SERVER_CONFIG
+      };
+      const pluginsCode = `[${plugins.map((plugin, index) => {
+        return `plugin_${index}()`;
+      }).join(",")}]`;
+      let entryCode = (await fse.readFile(path.join(__dirname, "./node-entry.js"))).toString();
+      const serverAppContext = serverAppContenxtTemplate(appContext);
+      entryCode = entryCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_plugins", pluginsCode).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      if (isEsmProject) {
+        const cjsEntryFilePath = path.join(outputDirectory, "index.cjs");
+        await fse.writeFile(cjsEntryFilePath, entryCode);
+        await fse.writeFile(entryFilePath, `import('./index.cjs');`);
+      } else {
+        await fse.writeFile(entryFilePath, entryCode);
+      }
+    },
+    async end() {
+      console.log("Static directory:", chalk.blue(path.relative(appDirectory, staticDirectory)));
+      console.log(`You can preview this build by`, chalk.blue(`node .output/index`));
+      const filter = (filePath) => {
+        return !filePath.startsWith(staticDirectory);
+      };
+      await handleDependencies({
+        appDir: appDirectory,
+        serverRootDir: outputDirectory,
+        includeEntries: [
+          require.resolve("@modern-js/prod-server")
+        ],
+        entryFilter: filter
+      });
+    }
+  };
+};
+export {
+  createNodePreset
+};

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

@@ -0,0 +1,11 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var require_vercel_entry = __commonJS({
+  "src/plugins/deploy/platforms/vercel-entry.js"(exports, module) {
+    const { handler } = require("./vercel-handler.cjs");
+    module.exports = handler;
+  }
+});
+export default require_vercel_entry();

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

@@ -0,0 +1,3 @@
+import { handler } from './vercel-handler.cjs';
+
+export default handler;

package/dist/esm-node/plugins/deploy/platforms/vercel-handler.js

@@ -0,0 +1,72 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var require_vercel_handler = __commonJS({
+  "src/plugins/deploy/platforms/vercel-handler.cjs"(exports, module) {
+    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,
+        ...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
+    };
+  }
+});
+export default require_vercel_handler();

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

@@ -0,0 +1,129 @@
+import path from "node:path";
+import { DEFAULT_SERVER_CONFIG, ROUTE_SPEC_FILE, fs as fse } from "@modern-js/utils";
+import { isMainEntry } from "../../../utils/routes";
+import { handleDependencies } from "../dependencies";
+import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
+const createVercelPreset = (appContext, modernConfig, needModernServer) => {
+  const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType } = appContext;
+  const isEsmProject = moduleType === "module";
+  const plugins = serverPlugins.map((plugin) => plugin.name);
+  const vercelOutput = path.join(appDirectory, ".vercel");
+  const outputDirectory = path.join(vercelOutput, "output");
+  const funcsDirectory = path.join(outputDirectory, "functions", "index.func");
+  const entryFilePath = path.join(funcsDirectory, "index.js");
+  const handlerFilePath = path.join(funcsDirectory, "vercel-handler.cjs");
+  return {
+    async prepare() {
+      await fse.remove(vercelOutput);
+    },
+    async writeOutput() {
+      const config = {
+        version: 3,
+        routes: [
+          {
+            src: "/static/(.*)",
+            headers: {
+              "cache-control": "s-maxage=31536000, immutable"
+            },
+            continue: true
+          },
+          {
+            handle: "filesystem"
+          }
+        ]
+      };
+      if (!needModernServer) {
+        const { source: { mainEntryName } } = modernConfig;
+        entrypoints.forEach((entry) => {
+          const isMain = isMainEntry(entry.entryName, mainEntryName);
+          config.routes.push({
+            src: `/${isMain ? "" : entry.entryName}(?:/.*)?`,
+            headers: {
+              "cache-control": "s-maxage=0"
+            },
+            dest: `/html/${entry.entryName}/index.html`
+          });
+        });
+      } else {
+        config.routes.push({
+          src: "/(.*)",
+          dest: `/index`
+        });
+      }
+      await fse.ensureDir(outputDirectory);
+      await fse.writeJSON(path.join(outputDirectory, "config.json"), config, {
+        spaces: 2
+      });
+      const staticDirectory = path.join(outputDirectory, "static/static");
+      await fse.copy(path.join(distDirectory, "static"), staticDirectory);
+      if (!needModernServer) {
+        const destHtmlDirectory = path.join(distDirectory, "html");
+        const outputHtmlDirectory = path.join(path.join(outputDirectory, "static"), "html");
+        await fse.copy(destHtmlDirectory, outputHtmlDirectory);
+      } else {
+        await fse.ensureDir(funcsDirectory);
+        await fse.copy(distDirectory, funcsDirectory, {
+          filter: (src) => {
+            const distStaticDirectory = path.join(distDirectory, "static");
+            return !src.includes(distStaticDirectory);
+          }
+        });
+        await fse.writeJSON(path.join(funcsDirectory, ".vc-config.json"), {
+          runtime: "nodejs16.x",
+          handler: "index.js",
+          launcherType: "Nodejs",
+          shouldAddHelpers: false,
+          supportsResponseStreaming: true
+        });
+      }
+    },
+    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: {
+          distPath: {
+            root: "."
+          }
+        }
+      };
+      const pluginImportCode = genPluginImportsCode(plugins || []);
+      const dynamicProdOptions = {
+        config: serverConfig,
+        serverConfigFile: DEFAULT_SERVER_CONFIG
+      };
+      const pluginsCode = `[${plugins.map((plugin, index) => {
+        return `plugin_${index}()`;
+      }).join(",")}]`;
+      const serverAppContext = serverAppContenxtTemplate(appContext);
+      let handlerCode = (await fse.readFile(path.join(__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_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      await fse.writeFile(handlerFilePath, handlerCode);
+      if (isEsmProject) {
+        await fse.copy(path.join(__dirname, "./vercel-entry.mjs"), entryFilePath);
+      } else {
+        await fse.copy(path.join(__dirname, "./vercel-entry.js"), entryFilePath);
+      }
+    },
+    async end() {
+      if (!needModernServer) {
+        return;
+      }
+      await handleDependencies({
+        appDir: appDirectory,
+        serverRootDir: funcsDirectory,
+        includeEntries: [
+          require.resolve("@modern-js/prod-server")
+        ]
+      });
+    }
+  };
+};
+export {
+  createVercelPreset
+};

package/dist/esm-node/plugins/deploy/utils.js

@@ -0,0 +1,44 @@
+import path from "path";
+import { ROUTE_SPEC_FILE, fs as fse, isDepExists } from "@modern-js/utils";
+const serverAppContenxtTemplate = (appContext) => {
+  const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName } = appContext;
+  return {
+    sharedDirectory: `path.join(__dirname, "${path.relative(appDirectory, sharedDirectory)}")`,
+    apiDirectory: `path.join(__dirname, "${path.relative(appDirectory, apiDirectory)}")`,
+    lambdaDirectory: `path.join(__dirname, "${path.relative(appDirectory, lambdaDirectory)}")`,
+    metaName
+  };
+};
+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 = path.join(distDirectory, ROUTE_SPEC_FILE);
+  const { routes } = fse.readJSONSync(routeJSON);
+  let useSSR = false;
+  let useAPI = false;
+  routes.forEach((route) => {
+    if (route.isSSR) {
+      useSSR = true;
+    }
+    if (route.isApi) {
+      useAPI = true;
+    }
+  });
+  const useWebServer = isDepExists(appDirectory, "@modern-js/plugin-server");
+  return {
+    useSSR,
+    useAPI,
+    useWebServer
+  };
+};
+export {
+  genPluginImportsCode,
+  getPluginsCode,
+  getProjectUsage,
+  serverAppContenxtTemplate
+};

package/dist/esm-node/plugins/initialize/index.js

@@ -0,0 +1,84 @@
+import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
+import { checkIsLegacyConfig, createDefaultConfig, createLegacyDefaultConfig, transformNormalizedConfig } from "../../config";
+var initialize_default = ({ bundler }) => ({
+  name: "@modern-js/plugin-initialize",
+  post: [
+    "@modern-js/plugin-ssr",
+    "@modern-js/plugin-document",
+    "@modern-js/plugin-state",
+    "@modern-js/plugin-router",
+    "@modern-js/plugin-router-v5",
+    "@modern-js/plugin-polyfill"
+  ],
+  setup(api) {
+    const config = () => {
+      const appContext = api.useAppContext();
+      const userConfig = api.useConfigContext();
+      api.setAppContext({
+        ...appContext,
+        bundlerType: bundler
+      });
+      return checkIsLegacyConfig(userConfig) ? createLegacyDefaultConfig(appContext) : createDefaultConfig(appContext);
+    };
+    return {
+      config,
+      async resolvedConfig({ resolved }) {
+        var _resolved_output_distPath;
+        let appContext = api.useAppContext();
+        const userConfig = api.useConfigContext();
+        const port = await getServerPort(resolved);
+        appContext = {
+          ...appContext,
+          port,
+          distDirectory: ensureAbsolutePath(appContext.distDirectory, ((_resolved_output_distPath = resolved.output.distPath) === null || _resolved_output_distPath === void 0 ? void 0 : _resolved_output_distPath.root) || "dist")
+        };
+        api.setAppContext(appContext);
+        const normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
+        resolved._raw = userConfig;
+        resolved.server = {
+          ...normalizedConfig.server || {},
+          port
+        };
+        var _normalizedConfig_autoLoadPlugins;
+        resolved.autoLoadPlugins = (_normalizedConfig_autoLoadPlugins = normalizedConfig.autoLoadPlugins) !== null && _normalizedConfig_autoLoadPlugins !== void 0 ? _normalizedConfig_autoLoadPlugins : false;
+        stabilizeConfig(resolved, normalizedConfig, [
+          "source",
+          "bff",
+          "dev",
+          "html",
+          "output",
+          "tools",
+          "testing",
+          "plugins",
+          "builderPlugins",
+          "runtime",
+          "runtimeByEntries",
+          "deploy",
+          "performance"
+        ]);
+        if (bundler === "webpack") {
+          resolved.security = normalizedConfig.security || {};
+          resolved.experiments = normalizedConfig.experiments;
+        }
+        return {
+          resolved
+        };
+      }
+    };
+  }
+});
+function stabilizeConfig(resolve, config, keys) {
+  keys.forEach((key) => {
+    resolve[key] = config[key] || {};
+  });
+}
+async function getServerPort(config) {
+  const prodPort = Number(process.env.PORT) || config.server.port || 8080;
+  if (isDev() && isDevCommand()) {
+    return getPort(Number(process.env.PORT) || config.dev.port || prodPort);
+  }
+  return prodPort;
+}
+export {
+  initialize_default as default
+};

package/dist/esm-node/plugins/serverBuild.js

@@ -0,0 +1,58 @@
+import fs from "fs";
+import path from "path";
+import { compile } from "@modern-js/server-utils";
+import { SERVER_DIR, SHARED_DIR, getMeta } from "@modern-js/utils";
+const TS_CONFIG_FILENAME = "tsconfig.json";
+function checkHasCache(appDir) {
+  const tsFilepath = path.resolve(appDir, SERVER_DIR, "cache.ts");
+  const jsfilepath = path.resolve(appDir, SERVER_DIR, "cache.js");
+  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+function checkHasConfig(appDir, metaName = "modern-js") {
+  const meta = getMeta(metaName);
+  const tsFilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.ts`);
+  const jsfilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.js`);
+  return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+var serverBuild_default = () => ({
+  name: "@modern-js/server-build",
+  setup(api) {
+    return {
+      async afterBuild() {
+        const { appDirectory, distDirectory, metaName } = api.useAppContext();
+        if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) {
+          return;
+        }
+        const modernConfig = api.useResolvedConfigContext();
+        const distDir = path.resolve(distDirectory);
+        const serverDir = path.resolve(appDirectory, SERVER_DIR);
+        const sharedDir = path.resolve(appDirectory, SHARED_DIR);
+        const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
+        const sourceDirs = [];
+        if (fs.existsSync(serverDir)) {
+          sourceDirs.push(serverDir);
+          if (fs.existsSync(sharedDir)) {
+            sourceDirs.push(sharedDir);
+          }
+        }
+        const { server } = modernConfig;
+        const { alias } = modernConfig.source;
+        const { babel } = modernConfig.tools;
+        if (sourceDirs.length > 0) {
+          await compile(appDirectory, {
+            server,
+            alias,
+            babelConfig: babel
+          }, {
+            sourceDirs,
+            distDir,
+            tsconfigPath
+          });
+        }
+      }
+    };
+  }
+});
+export {
+  serverBuild_default as default
+};

package/dist/esm-node/types/config/index.js

@@ -0,0 +1 @@
+export * from "./output";

package/dist/esm-node/types/index.js

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./config";
+export * from "./legacyConfig";

package/dist/esm-node/utils/config.js

@@ -0,0 +1,49 @@
+import * as path from "path";
+import { bundle } from "@modern-js/node-bundle-require";
+import { fs, CONFIG_FILE_EXTENSIONS, OUTPUT_CONFIG_FILE, ensureAbsolutePath, getServerConfig } from "@modern-js/utils";
+import { stringify } from "flatted";
+const defineServerConfig = (config) => config;
+const buildServerConfig = async ({ appDirectory, distDirectory, configFile, options, watch }) => {
+  const configFilePath = await getServerConfig(appDirectory, configFile);
+  const getOutputFile = async (filepath) => path.resolve(distDirectory, `${filepath.replace(new RegExp(CONFIG_FILE_EXTENSIONS.join("|")), "")}.cjs`);
+  if (configFilePath) {
+    const configHelperFilePath = path.normalize(path.join(distDirectory, "./config-helper.js"));
+    const helperCode = `
+      export const defineConfig = (config) => config;
+    `;
+    await fs.ensureDir(distDirectory);
+    await fs.writeFile(configHelperFilePath, helperCode);
+    await bundle(configFilePath, {
+      ...options,
+      watch,
+      getOutputFile,
+      esbuildPlugins: [
+        {
+          name: "native-build-config",
+          setup(ctx) {
+            ctx.onResolve({
+              filter: /app-tools\/server/
+            }, () => {
+              return {
+                path: configHelperFilePath
+              };
+            });
+          }
+        }
+      ]
+    });
+  }
+};
+const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
+  var _resolvedConfig_output_distPath;
+  const outputPath = ensureAbsolutePath(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", OUTPUT_CONFIG_FILE));
+  const output = stringify(resolvedConfig);
+  await fs.writeFile(outputPath, output, {
+    encoding: "utf-8"
+  });
+};
+export {
+  buildServerConfig,
+  defineServerConfig,
+  emitResolvedConfig
+};

package/dist/esm-node/utils/createServer.js

@@ -0,0 +1,26 @@
+import { applyPlugins } from "@modern-js/prod-server";
+import { createDevServer } from "@modern-js/server";
+let server = null;
+const getServer = () => server;
+const setServer = (newServer) => {
+  server = newServer;
+};
+const closeServer = async () => {
+  if (server) {
+    server.close();
+    server = null;
+  }
+};
+const createServer = async (options) => {
+  if (server) {
+    server.close();
+  }
+  server = (await createDevServer(options, applyPlugins)).server;
+  return server;
+};
+export {
+  closeServer,
+  createServer,
+  getServer,
+  setServer
+};

package/dist/esm-node/utils/env.js

@@ -0,0 +1,16 @@
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+function getAutoInjectEnv(appContext) {
+  const { metaName } = appContext;
+  const prefix = `${cutNameByHyphen(metaName)}_`.toUpperCase();
+  const envReg = new RegExp(`^${prefix}`);
+  return Object.keys(process.env).reduce((prev, key) => {
+    const value = process.env[key];
+    if (envReg.test(key) && typeof value !== "undefined") {
+      prev[`process.env.${key}`] = value;
+    }
+    return prev;
+  }, {});
+}
+export {
+  getAutoInjectEnv
+};

package/dist/esm-node/utils/generateWatchFiles.js

@@ -0,0 +1,30 @@
+import path from "path";
+import { fs, getServerConfig } from "@modern-js/utils";
+const getPackageConfig = (appDirectory, packageJsonConfig) => {
+  const PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+  const json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
+  return json[packageJsonConfig !== null && packageJsonConfig !== void 0 ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
+};
+const addServerConfigToDeps = async (dependencies, appDirectory, serverConfigFile) => {
+  const serverConfig = await getServerConfig(appDirectory, serverConfigFile);
+  if (serverConfig) {
+    dependencies.push(serverConfig);
+  }
+};
+async function generateWatchFiles(appContext, configDir) {
+  const { appDirectory, configFile } = appContext;
+  const configPath = path.join(appDirectory, configDir || "");
+  const dependencies = getPackageConfig(appContext.appDirectory, appContext.packageName) ? [
+    path.resolve(appDirectory, "./package.json")
+  ] : [];
+  await addServerConfigToDeps(dependencies, appContext.appDirectory, appContext.serverConfigFile);
+  return [
+    `${configPath}/html`,
+    configFile || "./config",
+    ...dependencies
+  ];
+}
+export {
+  addServerConfigToDeps,
+  generateWatchFiles
+};