@modern-js/app-tools 2.58.2 → 2.59.0

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
+};

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

@@ -0,0 +1,93 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createUniBuilder } from "@modern-js/uni-builder";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { createBuilderProviderConfig } from "./createBuilderProviderConfig";
+import { getBuilderEnvironments } from "./getBuilderEnvironments";
+function generateBuilder(options, bundlerType) {
+  return _generateBuilder.apply(this, arguments);
+}
+function _generateBuilder() {
+  _generateBuilder = _async_to_generator(function(options, bundlerType) {
+    var normalizedConfig, appContext, builderConfig, environments, builder;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          normalizedConfig = options.normalizedConfig, appContext = options.appContext;
+          builderConfig = createBuilderProviderConfig(normalizedConfig, appContext);
+          environments = getBuilderEnvironments(normalizedConfig, appContext);
+          builderConfig.environments = builderConfig.environments ? mergeRsbuildConfig(environments, builderConfig.environments) : environments;
+          return [
+            4,
+            createUniBuilder({
+              cwd: appContext.appDirectory,
+              frameworkConfigPath: appContext.configFile || void 0,
+              bundlerType,
+              config: builderConfig
+            })
+          ];
+        case 1:
+          builder = _state.sent();
+          return [
+            4,
+            applyBuilderPlugins(builder, options)
+          ];
+        case 2:
+          _state.sent();
+          return [
+            2,
+            builder
+          ];
+      }
+    });
+  });
+  return _generateBuilder.apply(this, arguments);
+}
+function applyBuilderPlugins(builder, options) {
+  return _applyBuilderPlugins.apply(this, arguments);
+}
+function _applyBuilderPlugins() {
+  _applyBuilderPlugins = _async_to_generator(function(builder, options) {
+    var _ref, builderPluginAdapterBasic, builderPluginAdapterHtml, builderPluginAdapterSSR, normalizedConfig, pluginNodePolyfill;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            import("../shared/builderPlugins/index.js")
+          ];
+        case 1:
+          _ref = _state.sent(), builderPluginAdapterBasic = _ref.builderPluginAdapterBasic, builderPluginAdapterHtml = _ref.builderPluginAdapterHtml, builderPluginAdapterSSR = _ref.builderPluginAdapterSSR;
+          builder.addPlugins([
+            builderPluginAdapterBasic(),
+            builderPluginAdapterSSR(options),
+            builderPluginAdapterHtml(options)
+          ]);
+          normalizedConfig = options.normalizedConfig;
+          if (!!normalizedConfig.output.disableNodePolyfill)
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            import("@rsbuild/plugin-node-polyfill")
+          ];
+        case 2:
+          pluginNodePolyfill = _state.sent().pluginNodePolyfill;
+          builder.addPlugins([
+            pluginNodePolyfill()
+          ]);
+          _state.label = 3;
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _applyBuilderPlugins.apply(this, arguments);
+}
+export {
+  generateBuilder
+};

package/dist/esm/builder/index.js

@@ -0,0 +1,45 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+function createBuilderGenerator(bundler) {
+  return _createBuilderGenerator.apply(this, arguments);
+}
+function _createBuilderGenerator() {
+  _createBuilderGenerator = _async_to_generator(function(bundler) {
+    var createRspackBuilderForModern, createWebpackBuilderForModern;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          if (!(bundler === "rspack"))
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            import("./builder-rspack/index.js")
+          ];
+        case 1:
+          createRspackBuilderForModern = _state.sent().createRspackBuilderForModern;
+          return [
+            2,
+            createRspackBuilderForModern
+          ];
+        case 2:
+          return [
+            4,
+            import("./builder-webpack/index.js")
+          ];
+        case 3:
+          createWebpackBuilderForModern = _state.sent().createWebpackBuilderForModern;
+          return [
+            2,
+            createWebpackBuilderForModern
+          ];
+      }
+    });
+  });
+  return _createBuilderGenerator.apply(this, arguments);
+}
+export {
+  createBuilderGenerator
+};

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

@@ -0,0 +1,85 @@
+import path from "path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/uni-builder";
+var builderPluginAdapterBasic = function() {
+  return {
+    name: "builder-plugin-adapter-modern-basic",
+    setup: function setup(api) {
+      api.modifyBundlerChain(function(chain, param) {
+        var target = param.target, CHAIN_ID = param.CHAIN_ID, environment = param.environment;
+        var isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+        if (target === "node" || isServiceWorker) {
+          applyNodeCompat(isServiceWorker, chain);
+        }
+        if (target === "web") {
+          var bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
+          chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
+          chain.module.rule("bare-server-module").test(bareServerModuleReg).use("server-module-loader").loader(require.resolve("../loaders/serverModuleLoader"));
+        }
+        chain.resolve.modules.add("node_modules").add(path.join(api.context.rootPath, "node_modules"));
+      });
+    }
+  };
+};
+function applyNodeCompat(isServiceWorker, chain) {
+  var nodeExts = [
+    ".node.js",
+    ".node.jsx",
+    ".node.ts",
+    ".node.tsx",
+    ".server.js",
+    ".server.jsx",
+    ".server.ts",
+    ".server.tsx"
+  ];
+  var webWorkerExts = [
+    ".worker.js",
+    ".worker.jsx",
+    ".worker.ts",
+    ".worker.tsx"
+  ];
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = nodeExts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var ext = _step.value;
+      chain.resolve.extensions.prepend(ext);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  if (isServiceWorker) {
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = webWorkerExts[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+        var ext1 = _step1.value;
+        chain.resolve.extensions.prepend(ext1);
+      }
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+  }
+}
+export {
+  builderPluginAdapterBasic
+};