@umijs/bundler-webpack 4.2.6-alpha.6 → 4.2.6-alpha.9

package/dist/config/config.js

@@ -0,0 +1,243 @@
+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);
+
+// src/config/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfig: () => getConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_case_sensitive_paths_webpack_plugin = __toESM(require("@umijs/case-sensitive-paths-webpack-plugin"));
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var import_webpack = __toESM(require("../../compiled/webpack"));
+var import_webpack_5_chain = __toESM(require("../../compiled/webpack-5-chain"));
+var import_constants = require("../constants");
+var import_RuntimePublicPathPlugin = require("../plugins/RuntimePublicPathPlugin");
+var import_types = require("../types");
+var import_browsersList = require("../utils/browsersList");
+var import_assetRules = require("./assetRules");
+var import_bundleAnalyzerPlugin = require("./bundleAnalyzerPlugin");
+var import_compressPlugin = require("./compressPlugin");
+var import_copyPlugin = require("./copyPlugin");
+var import_cssRules = require("./cssRules");
+var import_definePlugin = require("./definePlugin");
+var import_detectCssModulesInDependence = require("./detectCssModulesInDependence");
+var import_detectDeadCodePlugin = require("./detectDeadCodePlugin");
+var import_fastRefreshPlugin = require("./fastRefreshPlugin");
+var import_forkTSCheckerPlugin = require("./forkTSCheckerPlugin");
+var import_harmonyLinkingErrorPlugin = require("./harmonyLinkingErrorPlugin");
+var import_ignorePlugin = require("./ignorePlugin");
+var import_javaScriptRules = require("./javaScriptRules");
+var import_manifestPlugin = require("./manifestPlugin");
+var import_miniCSSExtractPlugin = require("./miniCSSExtractPlugin");
+var import_nodePolyfill = require("./nodePolyfill");
+var import_progressPlugin = require("./progressPlugin");
+var import_speedMeasureWebpackPlugin = require("./speedMeasureWebpackPlugin");
+var import_ssrPlugin = __toESM(require("./ssrPlugin"));
+var import_svgRules = require("./svgRules");
+async function getConfig(opts) {
+  var _a, _b, _c;
+  const { userConfig } = opts;
+  const isDev = opts.env === import_types.Env.development;
+  const config = new import_webpack_5_chain.default();
+  userConfig.targets || (userConfig.targets = import_constants.DEFAULT_BROWSER_TARGETS);
+  userConfig.inlineLimit = parseInt(userConfig.inlineLimit || "10000", 10);
+  const useHash = !!(opts.hash || userConfig.hash && !isDev);
+  const applyOpts = {
+    name: opts.name,
+    config,
+    userConfig,
+    cwd: opts.cwd,
+    env: opts.env,
+    babelPreset: opts.babelPreset,
+    extraBabelPlugins: opts.extraBabelPlugins || [],
+    extraBabelPresets: opts.extraBabelPresets || [],
+    extraBabelIncludes: opts.extraBabelIncludes || [],
+    extraEsbuildLoaderHandler: opts.extraEsbuildLoaderHandler || [],
+    browsers: (0, import_browsersList.getBrowsersList)({
+      targets: userConfig.targets
+    }),
+    useHash,
+    staticPathPrefix: opts.staticPathPrefix !== void 0 ? opts.staticPathPrefix : "static/",
+    port: opts.port,
+    host: opts.host
+  };
+  config.name(opts.name);
+  config.mode(opts.env);
+  config.stats("none");
+  Object.keys(opts.entry).forEach((key) => {
+    const entry = config.entry(key);
+    if (isDev && opts.hmr) {
+      entry.add(require.resolve("../../client/client/client"));
+    }
+    entry.add(opts.entry[key]);
+  });
+  config.devtool(
+    isDev ? userConfig.devtool === false ? false : userConfig.devtool || import_constants.DEFAULT_DEVTOOL : userConfig.devtool
+  );
+  const absOutputPath = (0, import_path.resolve)(
+    opts.cwd,
+    userConfig.outputPath || import_constants.DEFAULT_OUTPUT_PATH
+  );
+  const disableCompress = process.env.COMPRESS === "none";
+  config.output.path(absOutputPath).filename(useHash ? `[name].[contenthash:8].js` : `[name].js`).chunkFilename(
+    useHash ? `[name].[contenthash:8].async.js` : `[name].async.js`
+  ).publicPath(userConfig.publicPath || "auto").pathinfo(isDev || disableCompress).set(
+    "assetModuleFilename",
+    `${applyOpts.staticPathPrefix}[name].[hash:8][ext]`
+  ).set("hashFunction", "xxhash64");
+  config.resolve.set("symlinks", true).modules.add("node_modules").end().alias.merge(userConfig.alias || {}).end().extensions.merge([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".wasm"
+  ]).end();
+  config.externals(userConfig.externals || []);
+  config.target(["web", "es5"]);
+  config.experiments({
+    topLevelAwait: true,
+    outputModule: !!userConfig.esm
+  });
+  await (0, import_nodePolyfill.addNodePolyfill)(applyOpts);
+  await (0, import_javaScriptRules.addJavaScriptRules)(applyOpts);
+  await (0, import_cssRules.addCSSRules)(applyOpts);
+  await (0, import_assetRules.addAssetRules)(applyOpts);
+  await (0, import_svgRules.addSVGRules)(applyOpts);
+  await (0, import_miniCSSExtractPlugin.addMiniCSSExtractPlugin)(applyOpts);
+  await (0, import_ignorePlugin.addIgnorePlugin)(applyOpts);
+  await (0, import_definePlugin.addDefinePlugin)(applyOpts);
+  await (0, import_fastRefreshPlugin.addFastRefreshPlugin)(applyOpts);
+  await (0, import_progressPlugin.addProgressPlugin)(applyOpts);
+  await (0, import_detectDeadCodePlugin.addDetectDeadCodePlugin)(applyOpts);
+  await (0, import_forkTSCheckerPlugin.addForkTSCheckerPlugin)(applyOpts);
+  if (!opts.disableCopy) {
+    await (0, import_copyPlugin.addCopyPlugin)(applyOpts);
+  }
+  await (0, import_manifestPlugin.addManifestPlugin)(applyOpts);
+  if (isDev && opts.hmr) {
+    config.plugin("hmr").use(import_webpack.default.HotModuleReplacementPlugin);
+  }
+  await (0, import_ssrPlugin.default)(applyOpts);
+  await (0, import_compressPlugin.addCompressPlugin)(applyOpts);
+  await (0, import_harmonyLinkingErrorPlugin.addHarmonyLinkingErrorPlugin)(applyOpts);
+  await (0, import_detectCssModulesInDependence.addDependenceCssModulesDetector)(applyOpts);
+  if (userConfig.runtimePublicPath) {
+    config.plugin("runtimePublicPath").use(import_RuntimePublicPathPlugin.RuntimePublicPathPlugin);
+  }
+  config.plugin("case-sensitive-paths").use(import_case_sensitive_paths_webpack_plugin.default);
+  if (opts.cache) {
+    config.cache({
+      type: "filesystem",
+      version: require("../../package.json").version,
+      buildDependencies: {
+        config: opts.cache.buildDependencies || []
+      },
+      cacheDirectory: opts.cache.cacheDirectory || // 使用 rootDir 是在有 APP_ROOT 时，把 cache 目录放在根目录下
+      (0, import_path.join)(
+        opts.rootDir || opts.cwd,
+        "node_modules",
+        ".cache",
+        "bundler-webpack"
+      )
+    });
+    if (require.resolve("@umijs/utils/package").includes("_@umijs_utils@")) {
+      const nodeModulesPath = opts.cache.absNodeModulesPath || (0, import_path.join)(opts.rootDir || opts.cwd, "node_modules");
+      const localLinkedNodeModules = Object.keys(
+        Object.assign(
+          {},
+          (_a = opts.pkg) == null ? void 0 : _a.dependencies,
+          (_b = opts.pkg) == null ? void 0 : _b.peerDependencies,
+          (_c = opts.pkg) == null ? void 0 : _c.devDependencies
+        )
+      ).map((pkg) => {
+        try {
+          return (0, import_path.resolve)(
+            import_utils.resolve.sync(`${pkg}/package.json`, {
+              basedir: opts.rootDir || opts.cwd,
+              preserveSymlinks: false
+            }),
+            "../node_modules"
+          );
+        } catch {
+          return opts.rootDir || opts.cwd;
+        }
+      }).filter((pkg) => !pkg.startsWith(opts.rootDir || opts.cwd));
+      if (localLinkedNodeModules.length) {
+        import_utils.logger.info(
+          `Detected local linked tnpm node_modules, to avoid oom, they will be treated as immutablePaths & managedPaths in webpack snapshot:`
+        );
+        localLinkedNodeModules.forEach((p) => import_utils.logger.info(`  ${p}`));
+      }
+      config.snapshot({
+        immutablePaths: [nodeModulesPath, ...localLinkedNodeModules],
+        managedPaths: [nodeModulesPath, ...localLinkedNodeModules]
+      });
+    }
+    config.infrastructureLogging({
+      level: "error",
+      ...process.env.WEBPACK_FS_CACHE_DEBUG ? {
+        debug: /webpack\.cache/
+      } : {}
+    });
+  }
+  if (opts.analyze) {
+    await (0, import_bundleAnalyzerPlugin.addBundleAnalyzerPlugin)(applyOpts);
+  }
+  if (opts.chainWebpack) {
+    await opts.chainWebpack(config, {
+      env: opts.env,
+      webpack: import_webpack.default
+    });
+  }
+  if (userConfig.chainWebpack) {
+    await userConfig.chainWebpack(config, {
+      env: opts.env,
+      webpack: import_webpack.default
+    });
+  }
+  let webpackConfig = config.toConfig();
+  webpackConfig = await (0, import_speedMeasureWebpackPlugin.addSpeedMeasureWebpackPlugin)({
+    webpackConfig
+  });
+  if (opts.modifyWebpackConfig) {
+    webpackConfig = await opts.modifyWebpackConfig(webpackConfig, {
+      env: opts.env,
+      webpack: import_webpack.default
+    });
+  }
+  return webpackConfig;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfig
+});

package/dist/config/copyPlugin.d.ts

@@ -0,0 +1,10 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addCopyPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/copyPlugin.js

@@ -0,0 +1,63 @@
+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);
+
+// src/config/copyPlugin.ts
+var copyPlugin_exports = {};
+__export(copyPlugin_exports, {
+  addCopyPlugin: () => addCopyPlugin
+});
+module.exports = __toCommonJS(copyPlugin_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+async function addCopyPlugin(opts) {
+  var _a;
+  const { config, userConfig, cwd } = opts;
+  const publicDir = (0, import_path.join)(cwd, "public");
+  const copyPatterns = [
+    (0, import_fs.existsSync)(publicDir) && (0, import_fs.readdirSync)(publicDir).length && {
+      from: publicDir,
+      // ref: https://github.com/webpack-contrib/copy-webpack-plugin#info
+      // Set minimized so terser will not do minimize
+      info: { minimized: true }
+    },
+    ...userConfig.copy ? (_a = userConfig.copy) == null ? void 0 : _a.map((pattern) => {
+      if (typeof pattern === "string") {
+        return {
+          from: (0, import_path.resolve)(cwd, pattern),
+          info: { minimized: true }
+        };
+      }
+      return {
+        from: (0, import_path.resolve)(cwd, pattern.from),
+        to: (0, import_path.resolve)(cwd, pattern.to),
+        info: { minimized: true }
+      };
+    }) : []
+  ].filter(Boolean);
+  if (copyPatterns.length) {
+    config.plugin("copy").use(require("@umijs/bundler-webpack/compiled/copy-webpack-plugin"), [
+      {
+        patterns: copyPatterns
+      }
+    ]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCopyPlugin
+});

package/dist/config/cssRules.d.ts

@@ -0,0 +1,11 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+    browsers: any;
+}
+export declare function addCSSRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/cssRules.js

@@ -0,0 +1,165 @@
+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);
+
+// src/config/cssRules.ts
+var cssRules_exports = {};
+__export(cssRules_exports, {
+  addCSSRules: () => addCSSRules
+});
+module.exports = __toCommonJS(cssRules_exports);
+var import_utils = require("@umijs/utils");
+async function addCSSRules(opts) {
+  const { config, userConfig } = opts;
+  const rulesConfig = [
+    { name: "css", test: /\.css(\?.*)?$/ },
+    {
+      name: "less",
+      test: /\.less(\?.*)?$/,
+      loader: require.resolve("@umijs/bundler-webpack/compiled/less-loader"),
+      loaderOptions: {
+        implementation: require.resolve("@umijs/bundler-utils/compiled/less"),
+        lessOptions: {
+          modifyVars: userConfig.theme,
+          javascriptEnabled: true,
+          ...userConfig.lessLoader
+        }
+      }
+    },
+    {
+      name: "sass",
+      test: /\.(sass|scss)(\?.*)?$/,
+      loader: require.resolve("@umijs/bundler-webpack/compiled/sass-loader"),
+      loaderOptions: userConfig.sassLoader || {}
+    },
+    {
+      name: "stylus",
+      test: /\.(styl|stylus)(\?.*)?$/,
+      loader: require.resolve("@umijs/bundler-webpack/compiled/stylus-loader"),
+      loaderOptions: userConfig.stylusLoader || {}
+    }
+  ];
+  const cssPublicPath = userConfig.cssPublicPath || "./";
+  for (const { name, test, loader, loaderOptions } of rulesConfig) {
+    const rule = config.module.rule(name);
+    const nestRulesConfig = [
+      userConfig.autoCSSModules && {
+        rule: rule.test(test).oneOf("css-modules").resourceQuery(/modules/),
+        isAutoCSSModuleRule: true
+      },
+      {
+        rule: rule.test(test).oneOf("css").sideEffects(true),
+        isAutoCSSModuleRule: false
+      }
+    ].filter(Boolean);
+    for (const { rule: rule2, isAutoCSSModuleRule } of nestRulesConfig) {
+      if (userConfig.styleLoader) {
+        rule2.use("style-loader").loader(
+          require.resolve("@umijs/bundler-webpack/compiled/style-loader")
+        ).options({ base: 0, esModule: true, ...userConfig.styleLoader });
+      } else {
+        rule2.use("mini-css-extract-plugin").loader(
+          require.resolve("@umijs/bundler-webpack/compiled/mini-css-extract-plugin/loader")
+        ).options({
+          publicPath: cssPublicPath,
+          emit: true,
+          esModule: true
+        });
+      }
+      const getLocalIdent = userConfig.ssr && userConfig.ssr.compiler === "esbuild" ? getLocalIdentForSSR : void 0;
+      const localIdentName = "[local]___[hash:base64:5]";
+      let cssLoaderModulesConfig;
+      if (isAutoCSSModuleRule) {
+        cssLoaderModulesConfig = {
+          localIdentName,
+          ...userConfig.cssLoaderModules,
+          getLocalIdent
+        };
+      } else if (userConfig.normalCSSLoaderModules) {
+        cssLoaderModulesConfig = {
+          localIdentName,
+          auto: true,
+          ...userConfig.normalCSSLoaderModules,
+          getLocalIdent
+        };
+      }
+      rule2.use("css-loader").loader(require.resolve("css-loader")).options({
+        importLoaders: 1,
+        esModule: true,
+        url: {
+          filter: (url) => {
+            if (url.startsWith("/"))
+              return false;
+            return true;
+          }
+        },
+        import: true,
+        modules: cssLoaderModulesConfig,
+        ...userConfig.cssLoader
+      });
+      rule2.use("postcss-loader").loader(
+        require.resolve("@umijs/bundler-webpack/compiled/postcss-loader")
+      ).options({
+        postcssOptions: {
+          ident: "postcss",
+          plugins: [
+            require("@umijs/bundler-webpack/compiled/postcss-flexbugs-fixes"),
+            require("postcss-preset-env")({
+              browsers: opts.browsers,
+              autoprefixer: {
+                flexbox: "no-2009",
+                ...userConfig.autoprefixer
+              },
+              stage: 3
+            })
+          ].concat(userConfig.extraPostCSSPlugins || []),
+          ...userConfig.postcssLoader
+        }
+      });
+      if (loader) {
+        rule2.use(`${name}-loader`).loader(loader).options(loaderOptions || {});
+      }
+    }
+  }
+}
+function ensureLastSlash(path) {
+  return path.endsWith("/") ? path : path + "/";
+}
+function getLocalIdentForSSR(context, localIdentName, localName, opt) {
+  const classIdent = ((0, import_utils.winPath)(context.resourcePath).replace(
+    (0, import_utils.winPath)(ensureLastSlash(opt.context)),
+    ""
+  ) + "@" + localName).trim();
+  let hash = Buffer.from(classIdent).toString("base64").replace(/=/g, "");
+  hash = hash.substring(hash.length - 5);
+  const result = localIdentName.replace(/\[local]/g, localName).replace(/\[hash[^\[]*?]/g, hash);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCSSRules
+});

package/dist/config/definePlugin.d.ts

@@ -0,0 +1,16 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import type { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+    host?: string;
+    port?: number;
+}
+export declare function resolveDefine(opts: IOpts): {
+    'process.env': Record<string, any>;
+    'process.env.SSR_MANIFEST': string;
+};
+export declare function addDefinePlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/definePlugin.js

@@ -0,0 +1,80 @@
+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);
+
+// src/config/definePlugin.ts
+var definePlugin_exports = {};
+__export(definePlugin_exports, {
+  addDefinePlugin: () => addDefinePlugin,
+  resolveDefine: () => resolveDefine
+});
+module.exports = __toCommonJS(definePlugin_exports);
+var import_webpack = require("@umijs/bundler-webpack/compiled/webpack");
+var prefixRE = /^UMI_APP_/;
+var ENV_SHOULD_PASS = ["NODE_ENV", "HMR", "SOCKET_SERVER", "ERROR_OVERLAY"];
+var SOCKET_IGNORE_HOSTS = ["0.0.0.0", "127.0.0.1", "localhost"];
+var CUSTOM_ENV_GETTER = {
+  SOCKET_SERVER: (opts) => {
+    const { userConfig, host, port } = opts;
+    const socketServer = process.env.SOCKET_SERVER;
+    if (socketServer) {
+      return socketServer;
+    }
+    if (host && !SOCKET_IGNORE_HOSTS.includes(host)) {
+      const protocol = userConfig.https ? "https:" : "http:";
+      return `${protocol}//${host}:${port || 8e3}`;
+    }
+    return;
+  }
+};
+function resolveDefine(opts) {
+  const { userConfig } = opts;
+  const env = {};
+  ENV_SHOULD_PASS.concat(
+    Object.keys(process.env).filter((k) => prefixRE.test(k))
+  ).forEach((key) => {
+    const envValue = CUSTOM_ENV_GETTER[key] ? CUSTOM_ENV_GETTER[key](opts) : process.env[key];
+    if (typeof envValue === "undefined") {
+      return;
+    }
+    env[key] = envValue;
+  });
+  env.PUBLIC_PATH = userConfig.publicPath || "/";
+  for (const key in env) {
+    env[key] = JSON.stringify(env[key]);
+  }
+  const define = {};
+  if (userConfig.define) {
+    for (const key in userConfig.define) {
+      define[key] = JSON.stringify(userConfig.define[key]);
+    }
+  }
+  return {
+    "process.env": env,
+    "process.env.SSR_MANIFEST": "process.env.SSR_MANIFEST",
+    ...define
+  };
+}
+async function addDefinePlugin(opts) {
+  const { config } = opts;
+  config.plugin("define").use(import_webpack.DefinePlugin, [resolveDefine(opts)]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addDefinePlugin,
+  resolveDefine
+});

package/dist/config/detectCssModulesInDependence.d.ts

@@ -0,0 +1,10 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { IConfig } from '../types';
+interface IOpts {
+    userConfig: IConfig;
+    config: Config;
+    cwd: string;
+    extraBabelIncludes: Array<string | RegExp>;
+}
+export declare function addDependenceCssModulesDetector(opts: IOpts): Promise<void>;
+export {};