@modern-js/app-tools 2.58.3 → 2.59.0

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

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

@@ -0,0 +1,126 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { isHtmlDisabled } from "@modern-js/uni-builder";
+import { MAIN_ENTRY_NAME, getEntryOptions, removeTailSlash } from "@modern-js/utils";
+import { template as lodashTemplate } from "@modern-js/utils/lodash";
+import { BottomTemplatePlugin } from "../bundlerPlugins";
+var createVirtualModule = function(content) {
+  return "data:text/javascript,".concat(content);
+};
+var builderPluginAdapterHtml = function(options) {
+  return {
+    name: "builder-plugin-adapter-modern-html",
+    setup: function setup(api) {
+      api.modifyBundlerChain(function() {
+        var _ref = _async_to_generator(function(chain, param) {
+          var CHAIN_ID, target, HtmlBundlerPlugin, environment, builderConfig;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                CHAIN_ID = param.CHAIN_ID, target = param.target, HtmlBundlerPlugin = param.HtmlPlugin, environment = param.environment;
+                builderConfig = environment.config;
+                if (!!isHtmlDisabled(builderConfig, target))
+                  return [
+                    3,
+                    2
+                  ];
+                applyBottomHtmlPlugin({
+                  options,
+                  chain,
+                  CHAIN_ID,
+                  HtmlBundlerPlugin,
+                  htmlPaths: environment.htmlPaths
+                });
+                return [
+                  4,
+                  injectAssetPrefix({
+                    chain
+                  })
+                ];
+              case 1:
+                _state.sent();
+                _state.label = 2;
+              case 2:
+                return [
+                  2
+                ];
+            }
+          });
+        });
+        return function(chain, _) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    }
+  };
+};
+function injectAssetPrefix(_) {
+  return _injectAssetPrefix.apply(this, arguments);
+}
+function _injectAssetPrefix() {
+  _injectAssetPrefix = _async_to_generator(function(param) {
+    var chain, entries, entryNames, assetPrefix, code;
+    return _ts_generator(this, function(_state) {
+      chain = param.chain;
+      entries = chain.entryPoints.entries() || {};
+      entryNames = Object.keys(entries);
+      assetPrefix = removeTailSlash(chain.output.get("publicPath") || "");
+      code = "window.__assetPrefix__ = '".concat(assetPrefix, "';");
+      entryNames.forEach(function(entryName) {
+        entries[entryName].prepend(createVirtualModule(code));
+      });
+      return [
+        2
+      ];
+    });
+  });
+  return _injectAssetPrefix.apply(this, arguments);
+}
+function applyBottomHtmlPlugin(param) {
+  var chain = param.chain, options = param.options, CHAIN_ID = param.CHAIN_ID, HtmlBundlerPlugin = param.HtmlBundlerPlugin, htmlPaths = param.htmlPaths;
+  var modernConfig = options.normalizedConfig, appContext = options.appContext;
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    var _loop = function() {
+      var entryName = _step.value;
+      var mainEntryName = modernConfig.source.mainEntryName;
+      var isMainEntry = entryName === (mainEntryName || MAIN_ENTRY_NAME);
+      var baseTemplateParams = _object_spread({
+        entryName,
+        title: getEntryOptions(entryName, isMainEntry, modernConfig.html.title, modernConfig.html.titleByEntries, appContext.packageName),
+        mountId: modernConfig.html.mountId
+      }, getEntryOptions(entryName, isMainEntry, modernConfig.html.templateParameters, modernConfig.html.templateParametersByEntries, appContext.packageName));
+      chain.plugin("".concat(CHAIN_ID.PLUGIN.HTML, "-").concat(entryName)).tap(function(args) {
+        return [
+          _object_spread_props(_object_spread({}, args[0] || {}), {
+            __internal__: true,
+            bottomTemplate: appContext.htmlTemplates["__".concat(entryName, "-bottom__")] && lodashTemplate(appContext.htmlTemplates["__".concat(entryName, "-bottom__")])(baseTemplateParams)
+          })
+        ];
+      });
+    };
+    for (var _iterator = Object.keys(htmlPaths)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)
+      _loop();
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  chain.plugin("bottom-template").use(BottomTemplatePlugin, [
+    HtmlBundlerPlugin
+  ]);
+}
+export {
+  builderPluginAdapterHtml
+};

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

@@ -0,0 +1,261 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import * as path from "path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/uni-builder";
+import { fs, isUseSSRBundle } from "@modern-js/utils";
+import { mergeRsbuildConfig } from "@rsbuild/core";
+import { getServerCombinedModueFile } from "../../../plugins/analyze/utils";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
+var builderPluginAdapterSSR = function(options) {
+  return {
+    name: "builder-plugin-adapter-modern-ssr",
+    setup: function setup(api) {
+      var normalizedConfig = options.normalizedConfig;
+      api.modifyRsbuildConfig(function(config) {
+        return mergeRsbuildConfig(config, {
+          html: {
+            inject: isStreamingSSR(normalizedConfig) ? "body" : void 0
+          },
+          server: {
+            // the http-compression can't handler stream http.
+            // so we disable compress when user use stream ssr temporarily.
+            compress: isStreamingSSR(normalizedConfig) ? false : void 0
+          }
+        });
+      });
+      api.modifyBundlerChain(function() {
+        var _ref = _async_to_generator(function(chain, param) {
+          var target, isProd, HtmlBundlerPlugin, isServer, environment, builderConfig, normalizedConfig2, isServiceWorker;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                target = param.target, isProd = param.isProd, HtmlBundlerPlugin = param.HtmlPlugin, isServer = param.isServer, environment = param.environment;
+                builderConfig = environment.config;
+                normalizedConfig2 = options.normalizedConfig;
+                applyRouterPlugin(chain, "route-plugin", options, HtmlBundlerPlugin);
+                isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                if (target === "node" || isServiceWorker) {
+                  applyFilterEntriesBySSRConfig({
+                    isProd,
+                    chain,
+                    appNormalizedConfig: normalizedConfig2
+                  });
+                }
+                if (!isUseSSRBundle(normalizedConfig2))
+                  return [
+                    3,
+                    2
+                  ];
+                return [
+                  4,
+                  applySSRLoaderEntry(chain, options, isServer)
+                ];
+              case 1:
+                _state.sent();
+                applySSRDataLoader(chain, options);
+                _state.label = 2;
+              case 2:
+                if (!isHtmlDisabled(builderConfig, target)) {
+                  applyAsyncChunkHtmlPlugin({
+                    chain,
+                    modernConfig: options.normalizedConfig,
+                    HtmlBundlerPlugin
+                  });
+                }
+                return [
+                  2
+                ];
+            }
+          });
+        });
+        return function(chain, _) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    }
+  };
+};
+var isStreamingSSR = function(userConfig) {
+  var isStreaming = function(ssr) {
+    return ssr && typeof ssr === "object" && ssr.mode === "stream";
+  };
+  var server = userConfig.server;
+  if (isStreaming(server.ssr)) {
+    return true;
+  }
+  if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && typeof server.ssrByEntries === "object") {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = Object.keys(server.ssrByEntries)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var name = _step.value;
+        if (isStreaming(server.ssrByEntries[name])) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+  return false;
+};
+function applyAsyncChunkHtmlPlugin(param) {
+  var chain = param.chain, modernConfig = param.modernConfig, HtmlBundlerPlugin = param.HtmlBundlerPlugin;
+  if (isStreamingSSR(modernConfig)) {
+    chain.plugin("html-async-chunk").use(HtmlAsyncChunkPlugin, [
+      HtmlBundlerPlugin
+    ]);
+  }
+}
+function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
+  var _normalizedConfig_runtime, _normalizedConfig_deploy_worker;
+  var appContext = options.appContext, normalizedConfig = options.normalizedConfig;
+  var entrypoints = appContext.entrypoints;
+  var existNestedRoutes = entrypoints.some(function(entrypoint) {
+    return entrypoint.nestedRoutesEntry;
+  });
+  var routerConfig = normalizedConfig === null || normalizedConfig === void 0 ? void 0 : (_normalizedConfig_runtime = normalizedConfig.runtime) === null || _normalizedConfig_runtime === void 0 ? void 0 : _normalizedConfig_runtime.router;
+  var routerManifest = Boolean(routerConfig === null || routerConfig === void 0 ? void 0 : routerConfig.manifest);
+  var workerSSR = Boolean((_normalizedConfig_deploy_worker = normalizedConfig.deploy.worker) === null || _normalizedConfig_deploy_worker === void 0 ? void 0 : _normalizedConfig_deploy_worker.ssr);
+  var _normalizedConfig_output = normalizedConfig.output, enableInlineRouteManifests = _normalizedConfig_output.enableInlineRouteManifests, disableInlineRouteManifests = _normalizedConfig_output.disableInlineRouteManifests;
+  var inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
+  if (existNestedRoutes || routerManifest || workerSSR) {
+    var _normalizedConfig_output_distPath, _normalizedConfig_output1, _normalizedConfig_output2, _normalizedConfig_html, _normalizedConfig_security;
+    chain.plugin(pluginName).use(RouterPlugin, [
+      {
+        HtmlBundlerPlugin,
+        enableInlineRouteManifests: inlineRouteManifests,
+        staticJsDir: (_normalizedConfig_output1 = normalizedConfig.output) === null || _normalizedConfig_output1 === void 0 ? void 0 : (_normalizedConfig_output_distPath = _normalizedConfig_output1.distPath) === null || _normalizedConfig_output_distPath === void 0 ? void 0 : _normalizedConfig_output_distPath.js,
+        disableFilenameHash: (_normalizedConfig_output2 = normalizedConfig.output) === null || _normalizedConfig_output2 === void 0 ? void 0 : _normalizedConfig_output2.disableFilenameHash,
+        scriptLoading: (_normalizedConfig_html = normalizedConfig.html) === null || _normalizedConfig_html === void 0 ? void 0 : _normalizedConfig_html.scriptLoading,
+        nonce: (_normalizedConfig_security = normalizedConfig.security) === null || _normalizedConfig_security === void 0 ? void 0 : _normalizedConfig_security.nonce
+      }
+    ]);
+  }
+}
+function applyFilterEntriesBySSRConfig(param) {
+  var isProd = param.isProd, chain = param.chain, appNormalizedConfig = param.appNormalizedConfig;
+  var _this;
+  var serverConfig = appNormalizedConfig.server, outputConfig = appNormalizedConfig.output;
+  var entries = chain.entryPoints.entries();
+  if (isProd && ((outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg) === true || typeof ((_this = outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg) === null || _this === void 0 ? void 0 : _this[0]) === "function")) {
+    return;
+  }
+  if (typeof entries === "undefined") {
+    throw new Error("No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required");
+  }
+  var entryNames = Object.keys(entries);
+  if (isProd && entryNames.length === 1 && (outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg)) {
+    return;
+  }
+  var ssgEntries = [];
+  if (isProd && (outputConfig === null || outputConfig === void 0 ? void 0 : outputConfig.ssg)) {
+    var ssg = outputConfig.ssg;
+    entryNames.forEach(function(name) {
+      if (ssg[name]) {
+        ssgEntries.push(name);
+      }
+    });
+  }
+  var _ref = serverConfig || {}, ssr = _ref.ssr, ssrByEntries = _ref.ssrByEntries;
+  entryNames.forEach(function(name) {
+    if (!ssgEntries.includes(name) && !name.includes("server-loaders") && (ssr && (ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[name]) === false || !ssr && !(ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[name]))) {
+      chain.entryPoints.delete(name);
+    }
+  });
+}
+function applySSRLoaderEntry(chain, optinos, isServer) {
+  return _applySSRLoaderEntry.apply(this, arguments);
+}
+function _applySSRLoaderEntry() {
+  _applySSRLoaderEntry = _async_to_generator(function(chain, optinos, isServer) {
+    var appContext, internalDirectory, entrypoints;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appContext = optinos.appContext;
+          internalDirectory = appContext.internalDirectory;
+          entrypoints = appContext.entrypoints;
+          return [
+            4,
+            Promise.all(entrypoints.map(function() {
+              var _ref = _async_to_generator(function(entrypoint) {
+                var entryName, serverLoadersFile, err;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      entryName = entrypoint.entryName;
+                      serverLoadersFile = getServerCombinedModueFile(internalDirectory, entryName);
+                      if (!isServer)
+                        return [
+                          3,
+                          4
+                        ];
+                      _state2.label = 1;
+                    case 1:
+                      _state2.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                      ]);
+                      return [
+                        4,
+                        fs.access(serverLoadersFile, fs.constants.F_OK)
+                      ];
+                    case 2:
+                      _state2.sent();
+                      chain.entry("".concat(entryName, "-server-loaders")).add(serverLoadersFile);
+                      return [
+                        3,
+                        4
+                      ];
+                    case 3:
+                      err = _state2.sent();
+                      return [
+                        3,
+                        4
+                      ];
+                    case 4:
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(entrypoint) {
+                return _ref.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _applySSRLoaderEntry.apply(this, arguments);
+}
+function applySSRDataLoader(chain, options) {
+  var normalizedConfig = options.normalizedConfig, appContext = options.appContext;
+  var appDirectory = appContext.appDirectory;
+  var _normalizedConfig_source = normalizedConfig.source, _normalizedConfig_source_entriesDir = _normalizedConfig_source.entriesDir, entriesDir = _normalizedConfig_source_entriesDir === void 0 ? "./src" : _normalizedConfig_source_entriesDir;
+  var absolutePath = path.resolve(appDirectory, entriesDir).split(path.sep).join("(\\\\|/)");
+  var reg = new RegExp("".concat(absolutePath, ".*\\.(loader|data|data.client)\\.[t|j]sx?$"));
+  chain.module.rule("ssr-data-loader").test(reg).use("data-loader").loader(require.resolve("@modern-js/plugin-data-loader/loader")).end();
+}
+export {
+  builderPluginAdapterSSR
+};

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

@@ -0,0 +1,3 @@
+export * from "./adapterBasic";
+export * from "./adapterHtml";
+export * from "./adapterSSR";

package/dist/esm/builder/shared/bundlerPlugins/HtmlAsyncChunkPlugin.js

@@ -0,0 +1,51 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+var HtmlAsyncChunkPlugin = /* @__PURE__ */ function() {
+  "use strict";
+  function HtmlAsyncChunkPlugin2(htmlWebpackPlugin) {
+    _class_call_check(this, HtmlAsyncChunkPlugin2);
+    this.name = "HtmlAsyncChunkPlugin";
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+  }
+  var _proto = HtmlAsyncChunkPlugin2.prototype;
+  _proto.apply = function apply(compiler) {
+    var _this = this;
+    compiler.hooks.compilation.tap(this.name, function(compilation) {
+      var hooks = _this.htmlWebpackPlugin.getHooks(compilation);
+      hooks.alterAssetTagGroups.tap(_this.name, function(assets) {
+        var tags = _to_consumable_array(assets.headTags).concat(_to_consumable_array(assets.bodyTags));
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (var _iterator = tags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var tag = _step.value;
+            if (tag.tagName === "script") {
+              var attributes = tag.attributes;
+              if (attributes && attributes.defer === true) {
+                attributes.async = true;
+                delete attributes.defer;
+              }
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return assets;
+      });
+    });
+  };
+  return HtmlAsyncChunkPlugin2;
+}();
+export {
+  HtmlAsyncChunkPlugin
+};