@modern-js/builder 2.46.1 → 3.0.0-alpha.0

package/dist/plugins/environmentDefaults.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var environmentDefaults_exports = {};
+__export(environmentDefaults_exports, {
+  pluginEnvironmentDefaults: () => pluginEnvironmentDefaults
+});
+module.exports = __toCommonJS(environmentDefaults_exports);
+var import_node_path = require("node:path");
+var import_utils = require("../shared/utils");
+const pluginEnvironmentDefaults = (distPath = {}) => ({
+  name: "builder:environment-defaults-plugin",
+  setup(api) {
+    api.modifyRsbuildConfig((config, { mergeRsbuildConfig }) => {
+      var _config_environments, _config_environments1;
+      const compatConfig = {};
+      if ((_config_environments = config.environments) === null || _config_environments === void 0 ? void 0 : _config_environments[import_utils.SERVICE_WORKER_ENVIRONMENT_NAME]) {
+        var _compatConfig;
+        var _environments;
+        (_environments = (_compatConfig = compatConfig).environments) !== null && _environments !== void 0 ? _environments : _compatConfig.environments = {};
+        compatConfig.environments[import_utils.SERVICE_WORKER_ENVIRONMENT_NAME] = {
+          output: {
+            polyfill: "off",
+            distPath: {
+              root: (0, import_node_path.join)(distPath.root || "dist", distPath.worker || "worker"),
+              js: "",
+              css: "",
+              jsAsync: "",
+              cssAsync: ""
+            },
+            filename: {
+              js: "[name].js"
+            }
+          }
+        };
+      }
+      if ((_config_environments1 = config.environments) === null || _config_environments1 === void 0 ? void 0 : _config_environments1.node) {
+        var _compatConfig1;
+        var _environments1;
+        (_environments1 = (_compatConfig1 = compatConfig).environments) !== null && _environments1 !== void 0 ? _environments1 : _compatConfig1.environments = {};
+        compatConfig.environments.node = {
+          output: {
+            // no need to emit assets for SSR bundles
+            emitAssets: false,
+            distPath: {
+              root: (0, import_node_path.join)(distPath.root || "dist", distPath.server || "bundles"),
+              js: "",
+              css: "",
+              jsAsync: "",
+              cssAsync: ""
+            }
+          }
+        };
+      }
+      return compatConfig.environments ? mergeRsbuildConfig(compatConfig, config) : config;
+    });
+    api.modifyRsbuildConfig({
+      handler: (config) => {
+        const environmentNameOrder = [
+          "web",
+          "node",
+          "workerSSR"
+        ];
+        config.environments = Object.fromEntries(Object.entries(config.environments).sort((a1, a2) => environmentNameOrder.includes(a1[0]) ? environmentNameOrder.indexOf(a1[0]) - environmentNameOrder.indexOf(a2[0]) : 1));
+      },
+      order: "post"
+    });
+    api.modifyEnvironmentConfig(async (config, { name }) => {
+      var _config_output;
+      var _overrideBrowserslist;
+      (_overrideBrowserslist = (_config_output = config.output).overrideBrowserslist) !== null && _overrideBrowserslist !== void 0 ? _overrideBrowserslist : _config_output.overrideBrowserslist = await (0, import_utils.getBrowserslistWithDefault)(api.context.rootPath, config, name === import_utils.SERVICE_WORKER_ENVIRONMENT_NAME ? "node" : config.output.target);
+    });
+    api.modifyBundlerChain(async (chain, { environment }) => {
+      const isServiceWorker = environment.name === import_utils.SERVICE_WORKER_ENVIRONMENT_NAME;
+      if (isServiceWorker) {
+        chain.output.libraryTarget("commonjs2");
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginEnvironmentDefaults
+});

package/dist/plugins/globalVars.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { ChainedGlobalVars } from '../types';
+export declare const pluginGlobalVars: (options?: ChainedGlobalVars) => RsbuildPlugin;

package/dist/plugins/{moment.js → globalVars.js}

@@ -16,28 +16,35 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var moment_exports = {};
-__export(moment_exports, {
-  builderPluginMoment: () => builderPluginMoment
+var globalVars_exports = {};
+__export(globalVars_exports, {
+  pluginGlobalVars: () => pluginGlobalVars
 });
-module.exports = __toCommonJS(moment_exports);
-const builderPluginMoment = () => ({
-  name: "builder-plugin-moment",
+module.exports = __toCommonJS(globalVars_exports);
+var import_utils = require("@modern-js/utils");
+const pluginGlobalVars = (options) => ({
+  name: "builder:global-vars",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { webpack }) => {
-      const config = api.getNormalizedConfig();
-      if (config.performance.removeMomentLocale) {
-        chain.plugin("remove-moment-locale").use(webpack.IgnorePlugin, [
-          {
-            resourceRegExp: /^\.\/locale$/,
-            contextRegExp: /moment$/
-          }
-        ]);
+    api.modifyBundlerChain((chain, { env, target, bundler }) => {
+      if (!options) {
+        return;
       }
+      const globalVars = (0, import_utils.applyOptionsChain)({}, options, {
+        env,
+        target
+      });
+      const serializedVars = {};
+      Object.entries(globalVars).forEach(([key, value]) => {
+        var _JSON_stringify;
+        serializedVars[key] = (_JSON_stringify = JSON.stringify(value)) !== null && _JSON_stringify !== void 0 ? _JSON_stringify : "undefined";
+      });
+      chain.plugin("globalVars").use(bundler.DefinePlugin, [
+        serializedVars
+      ]);
     });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  builderPluginMoment
+  pluginGlobalVars
 });

package/dist/plugins/htmlMinify.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const pluginHtmlMinifierTerser: () => RsbuildPlugin;

package/dist/plugins/htmlMinify.js

@@ -0,0 +1,126 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var htmlMinify_exports = {};
+__export(htmlMinify_exports, {
+  pluginHtmlMinifierTerser: () => pluginHtmlMinifierTerser
+});
+module.exports = __toCommonJS(htmlMinify_exports);
+var import_ts_deepmerge = require("ts-deepmerge");
+function applyRemoveConsole(options, config) {
+  const { removeConsole } = config.performance;
+  const compressOptions = typeof options.compress === "boolean" ? {} : options.compress || {};
+  if (removeConsole === true) {
+    options.compress = {
+      ...compressOptions,
+      drop_console: true
+    };
+  } else if (Array.isArray(removeConsole)) {
+    const pureFuncs = removeConsole.map((method) => `console.${method}`);
+    options.compress = {
+      ...compressOptions,
+      pure_funcs: pureFuncs
+    };
+  }
+  return options;
+}
+function getTerserMinifyOptions(config) {
+  const options = {
+    mangle: {
+      safari10: true
+    },
+    format: {
+      ascii_only: config.output.charset === "ascii"
+    }
+  };
+  if (config.output.legalComments === "none") {
+    var _options;
+    (_options = options).format || (_options.format = {});
+    options.format.comments = false;
+  }
+  const finalOptions = applyRemoveConsole(options, config);
+  return finalOptions;
+}
+function getMinifyOptions(config) {
+  const minifyJS = getTerserMinifyOptions(config);
+  return {
+    removeComments: false,
+    useShortDoctype: true,
+    keepClosingSlash: true,
+    collapseWhitespace: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    removeEmptyAttributes: true,
+    minifyJS,
+    minifyCSS: true,
+    minifyURLs: true
+  };
+}
+const pluginHtmlMinifierTerser = () => ({
+  name: "builder:plugin-html-minifier-terser",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { isProd, environment }) => {
+      const { output, tools: { htmlPlugin } } = environment.config;
+      const disableHtmlMinify = !isProd || output.minify === false || htmlPlugin === false;
+      const { minify } = await Promise.resolve().then(() => __toESM(require("html-minifier-terser")));
+      const pluginRecord = chain.plugins.entries();
+      const minifyOptions = getMinifyOptions(environment.config);
+      for (const id of Object.keys(pluginRecord)) {
+        if (!id.startsWith("html-")) {
+          continue;
+        }
+        const values = pluginRecord[id].values();
+        const isHtmlRspackPlugin = values.some((item) => {
+          var _item_constructor;
+          const name = (item === null || item === void 0 ? void 0 : item.name) || ((_item_constructor = item.constructor) === null || _item_constructor === void 0 ? void 0 : _item_constructor.name);
+          return name === "HtmlRspackPlugin";
+        });
+        if (isHtmlRspackPlugin && !disableHtmlMinify) {
+          chain.plugin(id).tap((options) => {
+            if (!options.length) {
+              return options;
+            }
+            const userMinifyOption = options[0].minify;
+            if (userMinifyOption === false) {
+              return options;
+            }
+            const minifyFn = (html) => minify(html, userMinifyOption ? (0, import_ts_deepmerge.merge)(minifyOptions, userMinifyOption) : minifyOptions);
+            options[0].minify = minifyFn;
+            return options;
+          });
+          continue;
+        }
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginHtmlMinifierTerser
+});

package/dist/plugins/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const pluginManifest: () => RsbuildPlugin;

package/dist/plugins/{entry.js → manifest.js}

@@ -26,27 +26,29 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var entry_exports = {};
-__export(entry_exports, {
-  builderPluginEntry: () => builderPluginEntry
+var manifest_exports = {};
+__export(manifest_exports, {
+  pluginManifest: () => pluginManifest
 });
-module.exports = __toCommonJS(entry_exports);
-var import_lodash = __toESM(require("@modern-js/utils/lodash"));
-const builderPluginEntry = () => ({
-  name: "builder-plugin-entry",
+module.exports = __toCommonJS(manifest_exports);
+var import_manifest = require("../shared/manifest");
+const pluginManifest = () => ({
+  name: "builder:manifest",
   setup(api) {
-    api.modifyBundlerChain(async (chain) => {
-      const { entry } = api.context;
-      const { preEntry } = api.getNormalizedConfig().source;
-      Object.keys(entry).forEach((entryName) => {
-        const appendEntry = (file) => chain.entry(entryName).add(file);
-        preEntry.forEach(appendEntry);
-        import_lodash.default.castArray(entry[entryName]).forEach(appendEntry);
-      });
+    api.modifyBundlerChain(async (chain, { target, CHAIN_ID }) => {
+      const { RspackManifestPlugin } = await Promise.resolve().then(() => __toESM(require("rspack-manifest-plugin")));
+      const publicPath = chain.output.get("publicPath");
+      chain.plugin(CHAIN_ID.PLUGIN.MANIFEST).use(RspackManifestPlugin, [
+        {
+          fileName: target === "web" ? "asset-manifest.json" : `asset-manifest-${target}.json`,
+          publicPath,
+          generate: import_manifest.generateManifest
+        }
+      ]);
     });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  builderPluginEntry
+  pluginManifest
 });

package/dist/plugins/postcss.d.ts

@@ -0,0 +1,6 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { ToolsAutoprefixerConfig } from '../types';
+export interface PluginPostcssOptions {
+    autoprefixer?: ToolsAutoprefixerConfig;
+}
+export declare const pluginPostcss: (options?: PluginPostcssOptions) => RsbuildPlugin;

package/dist/plugins/postcss.js

@@ -0,0 +1,133 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var postcss_exports = {};
+__export(postcss_exports, {
+  pluginPostcss: () => pluginPostcss
+});
+module.exports = __toCommonJS(postcss_exports);
+var import_utils = require("@modern-js/utils");
+var import_getCssSupport = require("../shared/getCssSupport");
+const userPostcssrcCache = /* @__PURE__ */ new Map();
+const clonePostCSSConfig = (config) => ({
+  ...config,
+  plugins: config.plugins ? [
+    ...config.plugins
+  ] : void 0
+});
+async function loadUserPostcssrc(root) {
+  const cached = userPostcssrcCache.get(root);
+  if (cached) {
+    return clonePostCSSConfig(await cached);
+  }
+  const { default: postcssrc } = await Promise.resolve().then(() => __toESM(require("../../compiled/postcss-load-config")));
+  const promise = postcssrc({}, root).catch((err) => {
+    var _err_message;
+    if ((_err_message = err.message) === null || _err_message === void 0 ? void 0 : _err_message.includes("No PostCSS Config found")) {
+      return {};
+    }
+    throw err;
+  });
+  userPostcssrcCache.set(root, promise);
+  return promise.then((config) => {
+    userPostcssrcCache.set(root, config);
+    return clonePostCSSConfig(config);
+  });
+}
+const pluginPostcss = (options = {}) => ({
+  name: "builder:postcss-plugins",
+  pre: [
+    "builder:environment-defaults-plugin"
+  ],
+  setup(api) {
+    const { autoprefixer } = options;
+    api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig }) => {
+      var _config_output;
+      if (config.output.target !== "web") {
+        return config;
+      }
+      const cssSupport = (0, import_getCssSupport.getCssSupport)(config.output.overrideBrowserslist);
+      const enableExtractCSS = !((_config_output = config.output) === null || _config_output === void 0 ? void 0 : _config_output.injectStyles);
+      const enableCssMinify = !enableExtractCSS && (0, import_utils.isProd)();
+      const cssnanoOptions = {
+        preset: [
+          "default",
+          {
+            // merge longhand will break safe-area-inset-top, so disable it
+            // https://github.com/cssnano/cssnano/issues/803
+            // https://github.com/cssnano/cssnano/issues/967
+            mergeLonghand: false,
+            /**
+            * normalizeUrl will transform relative url from `./assets/img.svg` to `assets/img.svg`.
+            * It may break the behavior of webpack resolver while using style-loader.
+            * So disable it while `output.injectStyles = true`
+            */
+            normalizeUrl: false
+          }
+        ]
+      };
+      const plugins = [
+        require("postcss-flexbugs-fixes"),
+        !cssSupport.customProperties && require("postcss-custom-properties"),
+        !cssSupport.initial && require("postcss-initial"),
+        !cssSupport.pageBreak && require("postcss-page-break"),
+        !cssSupport.fontVariant && require("postcss-font-variant"),
+        !cssSupport.mediaMinmax && require("postcss-media-minmax"),
+        require("postcss-nesting"),
+        enableCssMinify ? require("cssnano")(cssnanoOptions) : false,
+        // The last insert autoprefixer
+        require("autoprefixer")((0, import_utils.applyOptionsChain)({
+          flexbox: "no-2009",
+          overrideBrowserslist: config.output.overrideBrowserslist
+        }, autoprefixer))
+      ].filter(Boolean);
+      const userOptions = await loadUserPostcssrc(api.context.rootPath);
+      return mergeEnvironmentConfig(
+        {
+          tools: {
+            postcss: {
+              postcssOptions: {
+                ...userOptions,
+                plugins: [
+                  ...userOptions.plugins || [],
+                  ...plugins
+                ]
+              }
+            }
+          }
+        },
+        // user config has higher priority than builtin config
+        config
+      );
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginPostcss
+});

package/dist/plugins/runtimeChunk.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const pluginRuntimeChunk: (disableInlineRuntimeChunk?: boolean) => RsbuildPlugin;

package/dist/plugins/runtimeChunk.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtimeChunk_exports = {};
+__export(runtimeChunk_exports, {
+  pluginRuntimeChunk: () => pluginRuntimeChunk
+});
+module.exports = __toCommonJS(runtimeChunk_exports);
+var import_utils = require("../shared/utils");
+const pluginRuntimeChunk = (disableInlineRuntimeChunk) => ({
+  name: "builder:runtime-chunk",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { target, environment }) => {
+      if (target !== "web") {
+        return;
+      }
+      const { config } = environment;
+      const { chunkSplit } = config.performance;
+      if (chunkSplit.strategy !== "all-in-one") {
+        chain.optimization.runtimeChunk({
+          name: import_utils.RUNTIME_CHUNK_NAME
+        });
+      }
+    });
+    api.modifyRsbuildConfig((config) => {
+      var _config;
+      (_config = config).output || (_config.output = {});
+      if (disableInlineRuntimeChunk) {
+        return;
+      }
+      if (!config.output.inlineScripts) {
+        config.output.inlineScripts = import_utils.RUNTIME_CHUNK_REGEX;
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginRuntimeChunk
+});

package/dist/rsc/common.d.ts

@@ -0,0 +1,22 @@
+export type { ClientReference, ImportManifestEntry, ModuleLoading, SSRManifest, SSRModuleMap, ClientReferencesMap, ServerReferencesMap, ServerManifest, ServerReferencesModuleInfo, ClientManifest, } from '@modern-js/types/server';
+import type { Rspack } from '@rsbuild/core';
+import { type Module } from '@swc/core';
+export declare const rspackRscLayerName = "react-server";
+export type SourceMap = Parameters<Rspack.LoaderDefinitionFunction>[1];
+export declare const MODERN_RSC_INFO = "modernRscInfo";
+export declare const sharedData: {
+    store: Map<string, any>;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    clear(): void;
+};
+export declare function setBuildInfo(mod: Rspack.Module, property: Record<string, any>): void;
+export declare function setRscBuildInfo(mod: Rspack.Module, property: Record<string, any>): void;
+export declare function removeRscBuildInfo(mod: Rspack.Module): void;
+export declare function getRscBuildInfo(mod: Rspack.Module): any;
+export declare function isCssModule(mod: Rspack.Module): any;
+export declare const parseSource: (source: string) => Promise<Module>;
+export declare const getExportNames: (ast: Module, collectFuncOnly?: boolean) => Promise<string[]>;
+export declare const isServerModule: (ast: Module) => Promise<boolean>;
+export declare const isClientModule: (ast: Module) => Promise<boolean>;
+export declare function findRootIssuer(modulegraph: Rspack.ModuleGraph, module: Rspack.NormalModule): Rspack.NormalModule;