@modern-js/app-tools 2.58.2 → 2.59.0

package/dist/esm/utils/printInstructions.js

@@ -0,0 +1,32 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { logger, prettyInstructions } from "@modern-js/utils";
+var printInstructions = function() {
+  var _ref = _async_to_generator(function(hookRunners, appContext, config) {
+    var message, instructions;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          message = prettyInstructions(appContext, config);
+          return [
+            4,
+            hookRunners.beforePrintInstructions({
+              instructions: message
+            })
+          ];
+        case 1:
+          instructions = _state.sent().instructions;
+          logger.log(instructions);
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function printInstructions2(hookRunners, appContext, config) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  printInstructions
+};

package/dist/esm/utils/register.js

@@ -0,0 +1,188 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "node:path";
+import { fs, getAliasConfig, readTsConfigByFile } from "@modern-js/utils";
+var registerEsbuild = function() {
+  var _ref = _async_to_generator(function(param) {
+    var isTsProject, tsConfig, distDir, esbuildRegister;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          isTsProject = param.isTsProject, tsConfig = param.tsConfig, distDir = param.distDir;
+          return [
+            4,
+            import("esbuild-register/dist/node")
+          ];
+        case 1:
+          esbuildRegister = _state.sent();
+          esbuildRegister.register({
+            tsconfigRaw: isTsProject ? tsConfig : void 0,
+            hookIgnoreNodeModules: true,
+            hookMatcher: function(fileName) {
+              return !fileName.startsWith(distDir);
+            }
+          });
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function registerEsbuild2(_) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var registerCompiler = function() {
+  var _ref = _async_to_generator(function(appDir, distDir, alias) {
+    var TS_CONFIG_FILENAME, tsconfigPath, isTsProject, aliasConfig, _aliasConfig_paths, paths, _aliasConfig_absoluteBaseUrl, absoluteBaseUrl, tsPaths, tsConfig, MODERN_NODE_LOADER, tsNode, tsNodeOptions, error, tsConfigPaths, loaderRes;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          TS_CONFIG_FILENAME = "tsconfig.json";
+          tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
+          return [
+            4,
+            fs.pathExists(tsconfigPath)
+          ];
+        case 1:
+          isTsProject = _state.sent();
+          aliasConfig = getAliasConfig(alias, {
+            appDirectory: appDir,
+            tsconfigPath
+          });
+          _aliasConfig_paths = aliasConfig.paths, paths = _aliasConfig_paths === void 0 ? {} : _aliasConfig_paths, _aliasConfig_absoluteBaseUrl = aliasConfig.absoluteBaseUrl, absoluteBaseUrl = _aliasConfig_absoluteBaseUrl === void 0 ? "./" : _aliasConfig_absoluteBaseUrl;
+          tsPaths = Object.keys(paths).reduce(function(o, key) {
+            var tsPath = paths[key];
+            if (typeof tsPath === "string" && key.startsWith("@") && tsPath.startsWith("@")) {
+              try {
+                tsPath = require.resolve(tsPath, {
+                  paths: [
+                    process.cwd()
+                  ].concat(_to_consumable_array(module.paths))
+                });
+              } catch (e) {
+              }
+            }
+            if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
+              tsPath = path.relative(absoluteBaseUrl, tsPath);
+            }
+            if (typeof tsPath === "string") {
+              tsPath = [
+                tsPath
+              ];
+            }
+            return _object_spread_props(_object_spread({}, o), _define_property({}, "".concat(key), tsPath));
+          }, {});
+          tsConfig = {};
+          if (isTsProject) {
+            tsConfig = readTsConfigByFile(tsconfigPath);
+          }
+          MODERN_NODE_LOADER = process.env.MODERN_NODE_LOADER;
+          if (!(MODERN_NODE_LOADER !== "esbuild"))
+            return [
+              3,
+              7
+            ];
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            6
+          ]);
+          return [
+            4,
+            import("ts-node")
+          ];
+        case 3:
+          tsNode = _state.sent();
+          tsNodeOptions = tsConfig["ts-node"];
+          if (isTsProject) {
+            tsNode.register(_object_spread({
+              project: tsconfigPath,
+              scope: true,
+              // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
+              files: true,
+              transpileOnly: true,
+              ignore: [
+                "(?:^|/)node_modules/",
+                "(?:^|/)".concat(path.relative(appDir, distDir), "/")
+              ]
+            }, tsNodeOptions));
+          }
+          return [
+            3,
+            6
+          ];
+        case 4:
+          error = _state.sent();
+          return [
+            4,
+            registerEsbuild({
+              isTsProject,
+              tsConfig,
+              distDir
+            })
+          ];
+        case 5:
+          _state.sent();
+          return [
+            3,
+            6
+          ];
+        case 6:
+          return [
+            3,
+            9
+          ];
+        case 7:
+          return [
+            4,
+            registerEsbuild({
+              isTsProject,
+              tsConfig,
+              distDir
+            })
+          ];
+        case 8:
+          _state.sent();
+          _state.label = 9;
+        case 9:
+          return [
+            4,
+            import("@modern-js/utils/tsconfig-paths")
+          ];
+        case 10:
+          tsConfigPaths = _state.sent().default;
+          return [
+            4,
+            fs.pathExists(appDir)
+          ];
+        case 11:
+          if (_state.sent()) {
+            loaderRes = tsConfigPaths.loadConfig(appDir);
+            if (loaderRes.resultType === "success") {
+              tsConfigPaths.register({
+                baseUrl: absoluteBaseUrl || "./",
+                paths: tsPaths
+              });
+            }
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function registerCompiler2(appDir, distDir, alias) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  registerCompiler
+};

package/dist/esm/utils/restart.js

@@ -0,0 +1,67 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { cli } from "@modern-js/core";
+import { chalk, clearConsole, getFullArgv, logger, program } from "@modern-js/utils";
+function restart(hooksRunner, filename) {
+  return _restart.apply(this, arguments);
+}
+function _restart() {
+  _restart = _async_to_generator(function(hooksRunner, filename) {
+    var hasGetError, err;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          clearConsole();
+          logger.info("Restart because ".concat(chalk.yellow(filename), " is changed...\n"));
+          hasGetError = false;
+          return [
+            4,
+            hooksRunner.beforeRestart()
+          ];
+        case 1:
+          _state.sent();
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            5,
+            6
+          ]);
+          return [
+            4,
+            cli.init(cli.getPrevInitOptions())
+          ];
+        case 3:
+          _state.sent();
+          return [
+            3,
+            6
+          ];
+        case 4:
+          err = _state.sent();
+          console.error(err);
+          hasGetError = true;
+          return [
+            3,
+            6
+          ];
+        case 5:
+          if (!hasGetError) {
+            program.parse(getFullArgv());
+          }
+          return [
+            7
+          ];
+        case 6:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _restart.apply(this, arguments);
+}
+export {
+  restart
+};

package/dist/esm/utils/routes.js

@@ -0,0 +1,42 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { fs, MAIN_ENTRY_NAME, ROUTE_SPEC_FILE } from "@modern-js/utils";
+var generateRoutes = function() {
+  var _ref = _async_to_generator(function(appContext) {
+    var serverRoutes, distDirectory, output;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverRoutes = appContext.serverRoutes, distDirectory = appContext.distDirectory;
+          output = JSON.stringify({
+            routes: serverRoutes
+          }, null, 2);
+          return [
+            4,
+            fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function generateRoutes2(appContext) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getPathWithoutExt = function(filename) {
+  var extname = path.extname(filename);
+  return filename.slice(0, -extname.length);
+};
+var isMainEntry = function(entryName, mainEntryName) {
+  return entryName === (mainEntryName || MAIN_ENTRY_NAME);
+};
+export {
+  generateRoutes,
+  getPathWithoutExt,
+  isMainEntry
+};

package/dist/esm-node/builder/builder-rspack/adapterCopy.js

@@ -0,0 +1,67 @@
+import path from "path";
+import { logger, removeTailSlash } from "@modern-js/utils";
+import fs from "@modern-js/utils/fs-extra";
+import { createCopyInfo } from "../shared";
+const builderPluginAdpaterCopy = (options) => ({
+  name: "builder-plugin-adapter-rspack-copy",
+  setup(api) {
+    let publicPath;
+    api.modifyBundlerChain((chain, { CHAIN_ID }) => {
+      chain.plugin(CHAIN_ID.PLUGIN.COPY).tap((args) => {
+        var _args_;
+        return [
+          {
+            patterns: [
+              ...((_args_ = args[0]) === null || _args_ === void 0 ? void 0 : _args_.patterns) || [],
+              ...createConfigBuiltinCopy(options)
+            ]
+          }
+        ];
+      });
+    });
+    api.modifyRspackConfig((config) => {
+      var _config_output;
+      publicPath = (_config_output = config.output) === null || _config_output === void 0 ? void 0 : _config_output.publicPath;
+    });
+    api.onDevCompileDone(async () => {
+      await transformHtmlFiles();
+    });
+    api.onAfterBuild(async () => {
+      await transformHtmlFiles();
+    });
+    async function transformHtmlFiles() {
+      var _normalizedConfig_output_distPath;
+      const { normalizedConfig } = options;
+      const publicDir = path.resolve(((_normalizedConfig_output_distPath = normalizedConfig.output.distPath) === null || _normalizedConfig_output_distPath === void 0 ? void 0 : _normalizedConfig_output_distPath.root) || "./dist", "./public");
+      if (!fs.existsSync(publicDir) || !fs.statSync(publicDir).isDirectory()) {
+        return;
+      }
+      const HTML_REGEXP = /\.html?$/;
+      const filepaths = (await fs.readdir(publicDir)).map((file) => path.resolve(publicDir, file));
+      await Promise.all(filepaths.filter((file) => HTML_REGEXP.test(file)).map(async (file) => {
+        const content = await fs.readFile(file, "utf-8");
+        if (publicPath && typeof publicPath === "string") {
+          await fs.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(publicPath)));
+        } else {
+          logger.warn(`Expect get a string from \`publicPath\`, but receive \`${typeof publicPath}\`.`);
+          await fs.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash("/")));
+        }
+      }));
+    }
+  }
+});
+function createConfigBuiltinCopy(options) {
+  const { normalizedConfig, appContext } = options;
+  const { publicDir } = createCopyInfo(appContext, normalizedConfig);
+  return [
+    {
+      from: "**/*",
+      to: "public",
+      context: publicDir,
+      noErrorOnMissing: true
+    }
+  ];
+}
+export {
+  builderPluginAdpaterCopy
+};

package/dist/esm-node/builder/builder-rspack/index.js

@@ -0,0 +1,12 @@
+import { generateBuilder } from "../generator";
+import { builderPluginAdpaterCopy } from "./adapterCopy";
+async function createRspackBuilderForModern(options) {
+  const builder = await generateBuilder(options, "rspack");
+  builder.addPlugins([
+    builderPluginAdpaterCopy(options)
+  ]);
+  return builder;
+}
+export {
+  createRspackBuilderForModern
+};

package/dist/esm-node/builder/builder-webpack/adapterModern.js

@@ -0,0 +1,26 @@
+import { createPublicPattern } from "./createCopyPattern";
+const builderPluginAdapterModern = (options) => ({
+  name: "builder-plugin-adapter-modern",
+  setup(api) {
+    const { normalizedConfig: modernConfig, appContext } = options;
+    api.modifyWebpackChain((chain, { CHAIN_ID }) => {
+      if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+        const defaultCopyPattern = createPublicPattern(appContext, modernConfig, chain);
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).tap((args) => {
+          var _args_;
+          return [
+            {
+              patterns: [
+                ...((_args_ = args[0]) === null || _args_ === void 0 ? void 0 : _args_.patterns) || [],
+                defaultCopyPattern
+              ]
+            }
+          ];
+        });
+      }
+    });
+  }
+});
+export {
+  builderPluginAdapterModern
+};

package/dist/esm-node/builder/builder-webpack/createCopyPattern.js

@@ -0,0 +1,41 @@
+import { removeTailSlash } from "@modern-js/utils";
+import { createCopyInfo } from "../shared";
+const minifiedJsRexExp = /\.min\.js/;
+const info = (file) => ({
+  // If the file name ends with `.min.js`, we assume it's a compressed file.
+  // So we don't want copy-webpack-plugin to minify it.
+  // ref: https://github.com/webpack-contrib/copy-webpack-plugin#info
+  minimized: minifiedJsRexExp.test(file.sourceFilename)
+});
+function createPublicPattern(appContext, config, chain) {
+  const { publicDir } = createCopyInfo(appContext, config);
+  return {
+    info,
+    from: "**/*",
+    to: "public",
+    context: publicDir,
+    noErrorOnMissing: true,
+    transform: (content, absoluteFrom) => {
+      if (!/\.html?$/.test(absoluteFrom)) {
+        return content;
+      }
+      return content.toString("utf8").replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(chain.output.get("publicPath")));
+    }
+  };
+}
+function createUploadPattern(appContext, config) {
+  const { uploadDir } = createCopyInfo(appContext, config);
+  return {
+    // rspack copy info structure is inconsistent with webpack, it only used in webpack mode
+    // @ts-expect-error
+    info,
+    from: "**/*",
+    to: "upload",
+    context: uploadDir,
+    noErrorOnMissing: true
+  };
+}
+export {
+  createPublicPattern,
+  createUploadPattern
+};

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

@@ -0,0 +1,20 @@
+import { generateBuilder } from "../generator";
+import { builderPluginAdapterModern } from "./adapterModern";
+async function createWebpackBuilderForModern(options) {
+  const builder = await generateBuilder(options, "webpack");
+  const { normalizedConfig } = options;
+  if (normalizedConfig.tools.esbuild) {
+    const { esbuild: esbuildOptions } = normalizedConfig.tools;
+    const { pluginEsbuild } = await import("@modern-js/rsbuild-plugin-esbuild");
+    builder.addPlugins([
+      pluginEsbuild(esbuildOptions)
+    ]);
+  }
+  builder.addPlugins([
+    builderPluginAdapterModern(options)
+  ]);
+  return builder;
+}
+export {
+  createWebpackBuilderForModern
+};

package/dist/esm-node/builder/generator/createBuilderProviderConfig.js

@@ -0,0 +1,44 @@
+import { createUploadPattern } from "../builder-webpack/createCopyPattern";
+function modifyOutputConfig(config, appContext) {
+  const defaultCopyPattern = createUploadPattern(appContext, config);
+  const { copy } = config.output;
+  const copyOptions = Array.isArray(copy) ? copy : copy === null || copy === void 0 ? void 0 : copy.patterns;
+  const builderCopy = [
+    ...copyOptions || [],
+    defaultCopyPattern
+  ];
+  config.output = {
+    ...config.output,
+    copy: builderCopy
+  };
+}
+function createBuilderProviderConfig(resolveConfig, appContext) {
+  const htmlConfig = {
+    ...resolveConfig.html
+  };
+  if (!htmlConfig.template) {
+    htmlConfig.templateByEntries = {
+      ...appContext.htmlTemplates,
+      ...htmlConfig.templateByEntries
+    };
+  }
+  const config = {
+    ...resolveConfig,
+    plugins: [],
+    dev: {
+      ...resolveConfig.dev,
+      port: appContext.port
+    },
+    html: htmlConfig,
+    output: {
+      ...resolveConfig.output,
+      // We need to do this in the app-tools prepare hook because some files will be generated into the dist directory in the analyze process
+      cleanDistPath: false
+    }
+  };
+  modifyOutputConfig(config, appContext);
+  return config;
+}
+export {
+  createBuilderProviderConfig
+};

package/dist/esm-node/builder/generator/getBuilderEnvironments.js

@@ -0,0 +1,60 @@
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/uni-builder";
+import { isProd, isSSR, isServiceWorker, isUseSSRBundle } from "@modern-js/utils";
+function getBuilderEnvironments(normalizedConfig, appContext) {
+  const entries = {};
+  const { entrypoints = [], checkedEntries } = appContext;
+  for (const { entryName, internalEntry, entry } of entrypoints) {
+    if (checkedEntries && !checkedEntries.includes(entryName)) {
+      continue;
+    }
+    const finalEntry = internalEntry || entry;
+    if (entryName in entries) {
+      entries[entryName].push(finalEntry);
+    } else {
+      entries[entryName] = [
+        finalEntry
+      ];
+    }
+  }
+  const serverEntries = {};
+  for (const entry in entries) {
+    const v = entries[entry];
+    serverEntries[entry] = v.map((entry2) => entry2.replace("index.jsx", "index.server.jsx")).map((entry2) => entry2.replace("bootstrap.jsx", "bootstrap.server.jsx"));
+  }
+  const environments = {
+    web: {
+      output: {
+        target: "web"
+      },
+      source: {
+        entry: entries
+      }
+    }
+  };
+  const useNodeTarget = isProd() ? isUseSSRBundle(normalizedConfig) : isSSR(normalizedConfig);
+  if (useNodeTarget) {
+    environments.node = {
+      output: {
+        target: "node"
+      },
+      source: {
+        entry: serverEntries
+      }
+    };
+  }
+  const useWorkerTarget = isServiceWorker(normalizedConfig);
+  if (useWorkerTarget) {
+    environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+      output: {
+        target: "web-worker"
+      },
+      source: {
+        entry: serverEntries
+      }
+    };
+  }
+  return environments;
+}
+export {
+  getBuilderEnvironments
+};

package/dist/esm-node/builder/generator/index.js

@@ -0,0 +1,36 @@
+import { createUniBuilder } from "@modern-js/uni-builder";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { createBuilderProviderConfig } from "./createBuilderProviderConfig";
+import { getBuilderEnvironments } from "./getBuilderEnvironments";
+async function generateBuilder(options, bundlerType) {
+  const { normalizedConfig, appContext } = options;
+  const builderConfig = createBuilderProviderConfig(normalizedConfig, appContext);
+  const environments = getBuilderEnvironments(normalizedConfig, appContext);
+  builderConfig.environments = builderConfig.environments ? mergeRsbuildConfig(environments, builderConfig.environments) : environments;
+  const builder = await createUniBuilder({
+    cwd: appContext.appDirectory,
+    frameworkConfigPath: appContext.configFile || void 0,
+    bundlerType,
+    config: builderConfig
+  });
+  await applyBuilderPlugins(builder, options);
+  return builder;
+}
+async function applyBuilderPlugins(builder, options) {
+  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR } = await import("../shared/builderPlugins/index.js");
+  builder.addPlugins([
+    builderPluginAdapterBasic(),
+    builderPluginAdapterSSR(options),
+    builderPluginAdapterHtml(options)
+  ]);
+  const { normalizedConfig } = options;
+  if (!normalizedConfig.output.disableNodePolyfill) {
+    const { pluginNodePolyfill } = await import("@rsbuild/plugin-node-polyfill");
+    builder.addPlugins([
+      pluginNodePolyfill()
+    ]);
+  }
+}
+export {
+  generateBuilder
+};

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

@@ -0,0 +1,11 @@
+async function createBuilderGenerator(bundler) {
+  if (bundler === "rspack") {
+    const { createRspackBuilderForModern } = await import("./builder-rspack/index.js");
+    return createRspackBuilderForModern;
+  }
+  const { createWebpackBuilderForModern } = await import("./builder-webpack/index.js");
+  return createWebpackBuilderForModern;
+}
+export {
+  createBuilderGenerator
+};