@modern-js/app-tools 2.58.3 → 2.59.0

package/dist/cjs/builder/generator/index.js

@@ -50,12 +50,11 @@ async function generateBuilder(options, bundlerType) {
   return builder;
 }
 async function applyBuilderPlugins(builder, options) {
-  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR, builderPluginAdapterWorker } = await import("../shared/builderPlugins/index.js");
+  const { builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR } = await import("../shared/builderPlugins/index.js");
   builder.addPlugins([
     builderPluginAdapterBasic(),
     builderPluginAdapterSSR(options),
-    builderPluginAdapterHtml(options),
-    builderPluginAdapterWorker()
+    builderPluginAdapterHtml(options)
   ]);
   const { normalizedConfig } = options;
   if (!normalizedConfig.output.disableNodePolyfill) {

package/dist/cjs/builder/shared/builderPlugins/index.js

@@ -18,11 +18,9 @@ module.exports = __toCommonJS(builderPlugins_exports);
 __reExport(builderPlugins_exports, require("./adapterBasic"), module.exports);
 __reExport(builderPlugins_exports, require("./adapterHtml"), module.exports);
 __reExport(builderPlugins_exports, require("./adapterSSR"), module.exports);
-__reExport(builderPlugins_exports, require("./adapterWorker"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./adapterBasic"),
   ...require("./adapterHtml"),
-  ...require("./adapterSSR"),
-  ...require("./adapterWorker")
+  ...require("./adapterSSR")
 });

package/dist/cjs/commands/dev.js

@@ -90,7 +90,7 @@ const dev = async (api, options, devServerOptions) => {
     },
     appContext: {
       appDirectory,
-      internalDirecory: appContext.internalDirectory,
+      internalDirectory: appContext.internalDirectory,
       apiDirectory: appContext.apiDirectory,
       lambdaDirectory: appContext.lambdaDirectory,
       sharedDirectory: appContext.sharedDirectory

package/dist/cjs/index.js

@@ -53,6 +53,7 @@ var import_core = require("@modern-js/core");
 __reExport(src_exports, require("./defineConfig"), module.exports);
 __reExport(src_exports, require("./types"), module.exports);
 const appTools = (options = {
+  // default webpack to be compatible with original projects
   bundler: "webpack"
 }) => ({
   name: "@modern-js/app-tools",
@@ -69,10 +70,16 @@ const appTools = (options = {
   registerHook: import_hooks.hooks,
   usePlugins: [
     (0, import_initialize.default)({
-      bundler: (options === null || options === void 0 ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
     }),
     (0, import_analyze.default)({
-      bundler: (options === null || options === void 0 ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
+      bundler: (options === null || options === void 0 ? void 0 : options.bundler) && [
+        "rspack",
+        "experimental-rspack"
+      ].includes(options.bundler) ? "rspack" : "webpack"
     }),
     (0, import_serverBuild.default)(),
     (0, import_plugin_lint.lintPlugin)(),
@@ -139,7 +146,7 @@ const appTools = (options = {
       async fileChange(e) {
         const { filename, eventType, isPrivate } = e;
         if (!isPrivate && (eventType === "change" || eventType === "unlink")) {
-          const { closeServer } = await import("./utils/createServer");
+          const { closeServer } = await import("./utils/createServer.js");
           await closeServer();
           await (0, import_restart.restart)(api.useHookRunners(), filename);
         }

package/dist/cjs/plugins/analyze/getFileSystemEntry.js

@@ -53,51 +53,57 @@ const isBundleEntry = async (hookRunners, dir, enableCustomEntry) => {
   }
   return hasIndex(dir);
 };
-const scanDir = (hookRunners, dirs, enableCustomEntry) => Promise.all(dirs.map(async (dir) => {
-  const indexFile = hasIndex(dir);
-  const customBootstrap = (0, import_isDefaultExportFunction.isDefaultExportFunction)(indexFile) ? indexFile : false;
-  const entryName = import_path.default.basename(dir);
-  const customEntryFile = hasEntry(dir);
-  const customServerEntry = hasServerEntry(dir);
-  if (indexFile && !customBootstrap) {
-    return {
-      entryName,
-      isMainEntry: false,
-      entry: indexFile,
-      absoluteEntryDir: import_path.default.resolve(dir),
-      isAutoMount: false,
-      customBootstrap
-    };
-  }
-  const entryFile = (await hookRunners.checkEntryPoint({
-    path: dir,
-    entry: false
-  })).entry;
-  if (entryFile) {
-    return {
-      entryName,
-      isMainEntry: false,
-      entry: enableCustomEntry ? customEntryFile || entryFile : entryFile,
-      customServerEntry,
-      absoluteEntryDir: import_path.default.resolve(dir),
-      isAutoMount: true,
-      customBootstrap,
-      customEntry: enableCustomEntry ? Boolean(customEntryFile) : false
-    };
-  }
-  if (enableCustomEntry && customEntryFile) {
-    return {
-      entryName,
-      isMainEntry: false,
-      entry: customEntryFile,
-      customServerEntry,
-      absoluteEntryDir: import_path.default.resolve(dir),
-      isAutoMount: false,
-      customEntry: Boolean(customEntryFile)
-    };
+const scanDir = async (hookRunners, dirs, enableCustomEntry) => {
+  const entries = await Promise.all(dirs.map(async (dir) => {
+    const indexFile = hasIndex(dir);
+    const customBootstrap = (0, import_isDefaultExportFunction.isDefaultExportFunction)(indexFile) ? indexFile : false;
+    const entryName = import_path.default.basename(dir);
+    const customEntryFile = hasEntry(dir);
+    const customServerEntry = hasServerEntry(dir);
+    if (indexFile && !customBootstrap) {
+      return {
+        entryName,
+        isMainEntry: false,
+        entry: indexFile,
+        absoluteEntryDir: import_path.default.resolve(dir),
+        isAutoMount: false,
+        customBootstrap
+      };
+    }
+    const entryFile = (await hookRunners.checkEntryPoint({
+      path: dir,
+      entry: false
+    })).entry;
+    if (entryFile) {
+      return {
+        entryName,
+        isMainEntry: false,
+        entry: enableCustomEntry ? customEntryFile || entryFile : entryFile,
+        customServerEntry,
+        absoluteEntryDir: import_path.default.resolve(dir),
+        isAutoMount: true,
+        customBootstrap,
+        customEntry: enableCustomEntry ? Boolean(customEntryFile) : false
+      };
+    }
+    if (enableCustomEntry && customEntryFile) {
+      return {
+        entryName,
+        isMainEntry: false,
+        entry: customEntryFile,
+        customServerEntry,
+        absoluteEntryDir: import_path.default.resolve(dir),
+        isAutoMount: false,
+        customEntry: Boolean(customEntryFile)
+      };
+    }
+    return false;
+  })).then((entries2) => entries2.filter(Boolean));
+  if (entries.length === 0) {
+    throw Error("There is no valid entry point in the current project!");
   }
-  throw Error("There is no valid entry point in the current project!");
-}));
+  return entries;
+};
 const getFileSystemEntry = async (hookRunners, appContext, config) => {
   const { appDirectory } = appContext;
   const { source: { entriesDir, disableEntryDirs, enableCustomEntry } } = config;

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

@@ -0,0 +1,166 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { logger, removeTailSlash } from "@modern-js/utils";
+import fs from "@modern-js/utils/fs-extra";
+import { createCopyInfo } from "../shared";
+var builderPluginAdpaterCopy = function(options) {
+  return {
+    name: "builder-plugin-adapter-rspack-copy",
+    setup: function setup(api) {
+      var publicPath;
+      api.modifyBundlerChain(function(chain, param) {
+        var CHAIN_ID = param.CHAIN_ID;
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).tap(function(args) {
+          var _args_;
+          return [
+            {
+              patterns: _to_consumable_array(((_args_ = args[0]) === null || _args_ === void 0 ? void 0 : _args_.patterns) || []).concat(_to_consumable_array(createConfigBuiltinCopy(options)))
+            }
+          ];
+        });
+      });
+      api.modifyRspackConfig(function(config) {
+        var _config_output;
+        publicPath = (_config_output = config.output) === null || _config_output === void 0 ? void 0 : _config_output.publicPath;
+      });
+      api.onDevCompileDone(/* @__PURE__ */ _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return [
+                4,
+                transformHtmlFiles()
+              ];
+            case 1:
+              _state.sent();
+              return [
+                2
+              ];
+          }
+        });
+      }));
+      api.onAfterBuild(/* @__PURE__ */ _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return [
+                4,
+                transformHtmlFiles()
+              ];
+            case 1:
+              _state.sent();
+              return [
+                2
+              ];
+          }
+        });
+      }));
+      function transformHtmlFiles() {
+        return _transformHtmlFiles.apply(this, arguments);
+      }
+      function _transformHtmlFiles() {
+        _transformHtmlFiles = /** transform public/*.html manaully */
+        _async_to_generator(function() {
+          var _normalizedConfig_output_distPath, normalizedConfig, publicDir, HTML_REGEXP, filepaths;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                normalizedConfig = options.normalizedConfig;
+                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 [
+                    2
+                  ];
+                }
+                HTML_REGEXP = /\.html?$/;
+                return [
+                  4,
+                  fs.readdir(publicDir)
+                ];
+              case 1:
+                filepaths = _state.sent().map(function(file) {
+                  return path.resolve(publicDir, file);
+                });
+                return [
+                  4,
+                  Promise.all(filepaths.filter(function(file) {
+                    return HTML_REGEXP.test(file);
+                  }).map(function() {
+                    var _ref = _async_to_generator(function(file) {
+                      var content;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            return [
+                              4,
+                              fs.readFile(file, "utf-8")
+                            ];
+                          case 1:
+                            content = _state2.sent();
+                            if (!(publicPath && typeof publicPath === "string"))
+                              return [
+                                3,
+                                3
+                              ];
+                            return [
+                              4,
+                              fs.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(publicPath)))
+                            ];
+                          case 2:
+                            _state2.sent();
+                            return [
+                              3,
+                              5
+                            ];
+                          case 3:
+                            logger.warn("Expect get a string from `publicPath`, but receive `".concat(typeof publicPath === "undefined" ? "undefined" : _type_of(publicPath), "`."));
+                            return [
+                              4,
+                              fs.writeFile(file, content.replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash("/")))
+                            ];
+                          case 4:
+                            _state2.sent();
+                            _state2.label = 5;
+                          case 5:
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    });
+                    return function(file) {
+                      return _ref.apply(this, arguments);
+                    };
+                  }()))
+                ];
+              case 2:
+                _state.sent();
+                return [
+                  2
+                ];
+            }
+          });
+        });
+        return _transformHtmlFiles.apply(this, arguments);
+      }
+    }
+  };
+};
+function createConfigBuiltinCopy(options) {
+  var normalizedConfig = options.normalizedConfig, appContext = options.appContext;
+  var publicDir = createCopyInfo(appContext, normalizedConfig).publicDir;
+  return [
+    {
+      from: "**/*",
+      to: "public",
+      context: publicDir,
+      noErrorOnMissing: true
+    }
+  ];
+}
+export {
+  builderPluginAdpaterCopy
+};

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

@@ -0,0 +1,34 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { generateBuilder } from "../generator";
+import { builderPluginAdpaterCopy } from "./adapterCopy";
+function createRspackBuilderForModern(options) {
+  return _createRspackBuilderForModern.apply(this, arguments);
+}
+function _createRspackBuilderForModern() {
+  _createRspackBuilderForModern = _async_to_generator(function(options) {
+    var builder;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            generateBuilder(options, "rspack")
+          ];
+        case 1:
+          builder = _state.sent();
+          builder.addPlugins([
+            builderPluginAdpaterCopy(options)
+          ]);
+          return [
+            2,
+            builder
+          ];
+      }
+    });
+  });
+  return _createRspackBuilderForModern.apply(this, arguments);
+}
+export {
+  createRspackBuilderForModern
+};

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

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

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

@@ -0,0 +1,43 @@
+import { removeTailSlash } from "@modern-js/utils";
+import { createCopyInfo } from "../shared";
+var minifiedJsRexExp = /\.min\.js/;
+var info = function(file) {
+  return {
+    // 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) {
+  var publicDir = createCopyInfo(appContext, config).publicDir;
+  return {
+    info,
+    from: "**/*",
+    to: "public",
+    context: publicDir,
+    noErrorOnMissing: true,
+    transform: function(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) {
+  var uploadDir = createCopyInfo(appContext, config).uploadDir;
+  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/builder/builder-webpack/index.js

@@ -0,0 +1,52 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { generateBuilder } from "../generator";
+import { builderPluginAdapterModern } from "./adapterModern";
+function createWebpackBuilderForModern(options) {
+  return _createWebpackBuilderForModern.apply(this, arguments);
+}
+function _createWebpackBuilderForModern() {
+  _createWebpackBuilderForModern = _async_to_generator(function(options) {
+    var builder, normalizedConfig, _normalizedConfig_tools, esbuildOptions, pluginEsbuild;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            generateBuilder(options, "webpack")
+          ];
+        case 1:
+          builder = _state.sent();
+          normalizedConfig = options.normalizedConfig;
+          if (!normalizedConfig.tools.esbuild)
+            return [
+              3,
+              3
+            ];
+          _normalizedConfig_tools = normalizedConfig.tools, esbuildOptions = _normalizedConfig_tools.esbuild;
+          return [
+            4,
+            import("@modern-js/rsbuild-plugin-esbuild")
+          ];
+        case 2:
+          pluginEsbuild = _state.sent().pluginEsbuild;
+          builder.addPlugins([
+            pluginEsbuild(esbuildOptions)
+          ]);
+          _state.label = 3;
+        case 3:
+          builder.addPlugins([
+            builderPluginAdapterModern(options)
+          ]);
+          return [
+            2,
+            builder
+          ];
+      }
+    });
+  });
+  return _createWebpackBuilderForModern.apply(this, arguments);
+}
+export {
+  createWebpackBuilderForModern
+};

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

@@ -0,0 +1,37 @@
+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 { createUploadPattern } from "../builder-webpack/createCopyPattern";
+function modifyOutputConfig(config, appContext) {
+  var defaultCopyPattern = createUploadPattern(appContext, config);
+  var copy = config.output.copy;
+  var copyOptions = Array.isArray(copy) ? copy : copy === null || copy === void 0 ? void 0 : copy.patterns;
+  var builderCopy = _to_consumable_array(copyOptions || []).concat([
+    defaultCopyPattern
+  ]);
+  config.output = _object_spread_props(_object_spread({}, config.output), {
+    copy: builderCopy
+  });
+}
+function createBuilderProviderConfig(resolveConfig, appContext) {
+  var htmlConfig = _object_spread({}, resolveConfig.html);
+  if (!htmlConfig.template) {
+    htmlConfig.templateByEntries = _object_spread({}, appContext.htmlTemplates, htmlConfig.templateByEntries);
+  }
+  var config = _object_spread_props(_object_spread({}, resolveConfig), {
+    plugins: [],
+    dev: _object_spread_props(_object_spread({}, resolveConfig.dev), {
+      port: appContext.port
+    }),
+    html: htmlConfig,
+    output: _object_spread_props(_object_spread({}, 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/builder/generator/getBuilderEnvironments.js

@@ -0,0 +1,81 @@
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/uni-builder";
+import { isProd, isSSR, isServiceWorker, isUseSSRBundle } from "@modern-js/utils";
+function getBuilderEnvironments(normalizedConfig, appContext) {
+  var entries = {};
+  var _appContext_entrypoints = appContext.entrypoints, entrypoints = _appContext_entrypoints === void 0 ? [] : _appContext_entrypoints, checkedEntries = appContext.checkedEntries;
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = entrypoints[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var _step_value = _step.value, entryName = _step_value.entryName, internalEntry = _step_value.internalEntry, entry = _step_value.entry;
+      if (checkedEntries && !checkedEntries.includes(entryName)) {
+        continue;
+      }
+      var finalEntry = internalEntry || entry;
+      if (entryName in entries) {
+        entries[entryName].push(finalEntry);
+      } else {
+        entries[entryName] = [
+          finalEntry
+        ];
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var serverEntries = {};
+  for (var entry1 in entries) {
+    var v = entries[entry1];
+    serverEntries[entry1] = v.map(function(entry2) {
+      return entry2.replace("index.jsx", "index.server.jsx");
+    }).map(function(entry2) {
+      return entry2.replace("bootstrap.jsx", "bootstrap.server.jsx");
+    });
+  }
+  var environments = {
+    web: {
+      output: {
+        target: "web"
+      },
+      source: {
+        entry: entries
+      }
+    }
+  };
+  var useNodeTarget = isProd() ? isUseSSRBundle(normalizedConfig) : isSSR(normalizedConfig);
+  if (useNodeTarget) {
+    environments.node = {
+      output: {
+        target: "node"
+      },
+      source: {
+        entry: serverEntries
+      }
+    };
+  }
+  var useWorkerTarget = isServiceWorker(normalizedConfig);
+  if (useWorkerTarget) {
+    environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+      output: {
+        target: "web-worker"
+      },
+      source: {
+        entry: serverEntries
+      }
+    };
+  }
+  return environments;
+}
+export {
+  getBuilderEnvironments
+};