@umijs/bundler-webpack 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/config/cssRules.js

@@ -1,98 +1,165 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCSSRules = void 0;
-function addCSSRules(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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-webpack/compiled/less'),
-                    lessOptions: Object.assign({ modifyVars: userConfig.theme, javascriptEnabled: true }, userConfig.lessLoader),
-                },
-            },
-            {
-                name: 'sass',
-                test: /\.(sass|scss)(\?.*)?$/,
-                loader: require.resolve('@umijs/bundler-webpack/compiled/sass-loader'),
-                loaderOptions: userConfig.sassLoader || {},
-            },
-        ];
-        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/),
-                    isCSSModules: true,
-                },
-                {
-                    rule: rule.test(test).oneOf('css').sideEffects(true),
-                    isCSSModules: false,
-                },
-            ].filter(Boolean);
-            // @ts-ignore
-            for (const { rule, isCSSModules } of nestRulesConfig) {
-                if (userConfig.styleLoader) {
-                    rule
-                        .use('style-loader')
-                        .loader(require.resolve('@umijs/bundler-webpack/compiled/style-loader'))
-                        .options(Object.assign({ base: 0, esModule: true }, userConfig.styleLoader));
-                }
-                else {
-                    rule
-                        .use('mini-css-extract-plugin-loader')
-                        .loader(require.resolve('@umijs/bundler-webpack/compiled/mini-css-extract-plugin/loader'))
-                        .options({
-                        publicPath: './',
-                        emit: true,
-                        esModule: true,
-                    });
-                }
-                rule
-                    .use('css-loader')
-                    .loader(require.resolve('css-loader'))
-                    .options(Object.assign(Object.assign({ importLoaders: 1, esModule: true, url: true, import: true }, (isCSSModules
-                    ? {
-                        modules: Object.assign({ localIdentName: '[local]___[hash:base64:5]' }, userConfig.cssLoaderModules),
-                    }
-                    : {})), userConfig.cssLoader));
-                rule
-                    .use('postcss-loader')
-                    .loader(require.resolve('@umijs/bundler-webpack/compiled/postcss-loader'))
-                    .options({
-                    postcssOptions: Object.assign({ ident: 'postcss', plugins: [
-                            require('@umijs/bundler-webpack/compiled/postcss-flexbugs-fixes'),
-                            require('postcss-preset-env')({
-                                browsers: opts.browsers,
-                                autoprefixer: Object.assign({ flexbox: 'no-2009' }, userConfig.autoprefixer),
-                                stage: 3,
-                            }),
-                        ].concat(userConfig.extraPostCSSPlugins || []) }, userConfig.postcssLoader),
-                });
-                if (loader) {
-                    rule
-                        .use(loader)
-                        .loader(typeof loader === 'string' ? require.resolve(loader) : loader)
-                        .options(loaderOptions || {});
-                }
-            }
+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;
 }
-exports.addCSSRules = addCSSRules;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCSSRules
+});

package/dist/config/definePlugin.d.ts

@@ -8,8 +8,10 @@ interface IOpts {
 }
 export declare function resolveDefine(opts: {
     define: any;
+    publicPath?: string;
 }): {
     'process.env': Record<string, any>;
+    'process.env.SSR_MANIFEST': string;
 };
 export declare function addDefinePlugin(opts: IOpts): Promise<void>;
 export {};

package/dist/config/definePlugin.js

@@ -1,45 +1,65 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addDefinePlugin = exports.resolveDefine = void 0;
-const webpack_1 = require("@umijs/bundler-webpack/compiled/webpack");
-const prefixRE = /^UMI_APP_/;
-const ENV_SHOULD_PASS = ['NODE_ENV', 'HMR', 'SOCKET_SERVER', 'ERROR_OVERLAY'];
+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"];
 function resolveDefine(opts) {
-    const env = {};
-    Object.keys(process.env).forEach((key) => {
-        if (prefixRE.test(key) || ENV_SHOULD_PASS.includes(key)) {
-            env[key] = process.env[key];
-        }
-    });
-    for (const key in env) {
-        env[key] = JSON.stringify(env[key]);
+  const env = {};
+  Object.keys(process.env).forEach((key) => {
+    if (prefixRE.test(key) || ENV_SHOULD_PASS.includes(key)) {
+      env[key] = process.env[key];
     }
-    const define = {};
-    if (opts.define) {
-        for (const key in opts.define) {
-            define[key] = JSON.stringify(opts.define[key]);
-        }
+  });
+  env.PUBLIC_PATH = opts.publicPath || "/";
+  for (const key in env) {
+    env[key] = JSON.stringify(env[key]);
+  }
+  const define = {};
+  if (opts.define) {
+    for (const key in opts.define) {
+      define[key] = JSON.stringify(opts.define[key]);
     }
-    return Object.assign({ 'process.env': env }, define);
+  }
+  return {
+    "process.env": env,
+    "process.env.SSR_MANIFEST": "process.env.SSR_MANIFEST",
+    ...define
+  };
 }
-exports.resolveDefine = resolveDefine;
-function addDefinePlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig } = opts;
-        config.plugin('define').use(webpack_1.DefinePlugin, [
-            resolveDefine({
-                define: userConfig.define || {},
-            }),
-        ]);
-    });
+async function addDefinePlugin(opts) {
+  const { config, userConfig } = opts;
+  config.plugin("define").use(import_webpack.DefinePlugin, [
+    resolveDefine({
+      define: userConfig.define || {},
+      publicPath: userConfig.publicPath
+    })
+  ]);
 }
-exports.addDefinePlugin = addDefinePlugin;
+// 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 {};

package/dist/config/detectCssModulesInDependence.js

@@ -0,0 +1,151 @@
+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/detectCssModulesInDependence.ts
+var detectCssModulesInDependence_exports = {};
+__export(detectCssModulesInDependence_exports, {
+  addDependenceCssModulesDetector: () => addDependenceCssModulesDetector
+});
+module.exports = __toCommonJS(detectCssModulesInDependence_exports);
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+async function addDependenceCssModulesDetector(opts) {
+  const { config, cwd, userConfig } = opts;
+  if (!userConfig.checkDepCssModules)
+    return;
+  const matchers = opts.extraBabelIncludes.map(function(p) {
+    if (import_utils.lodash.isRegExp(p)) {
+      return p;
+    }
+    let absPath;
+    if ((0, import_path.isAbsolute)(p)) {
+      absPath = p;
+    }
+    try {
+      if (p.startsWith("./")) {
+        absPath = require.resolve(p, { paths: [cwd] });
+      }
+      absPath = (0, import_path.dirname)(
+        import_utils.resolve.sync(`${p}/package.json`, {
+          basedir: cwd,
+          // same behavior as webpack, to ensure `include` paths matched
+          // ref: https://webpack.js.org/configuration/resolve/#resolvesymlinks
+          preserveSymlinks: false
+        })
+      );
+      return toRegExp(absPath);
+    } catch (e) {
+      if (e.code === "MODULE_NOT_FOUND") {
+        throw new Error("Cannot resolve extraBabelIncludes: " + p, {
+          cause: e
+        });
+      }
+      throw e;
+    }
+  });
+  config.plugin("dep-css-modules-detector").use(DetectCSsModulePlugin, [matchers]);
+}
+var _DetectCSsModulePlugin = class {
+  constructor(skipMatcher = []) {
+    this.skipMatcher = skipMatcher;
+  }
+  isCallRequireStyle(statement) {
+    if (
+      // var x= require(...) ?
+      statement.type === "CallExpression" && statement.callee.type === "Identifier" && statement.callee.name === "require" && // var x = require('xxxxx')
+      statement.arguments.length === 1 && statement.arguments[0].type === "Literal"
+    ) {
+      const requireArg = statement.arguments[0].value;
+      if (requireArg.endsWith(".less") || requireArg.endsWith(".css")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  apply(compiler) {
+    compiler.hooks.normalModuleFactory.tap(
+      _DetectCSsModulePlugin.PLUGIN_NAME,
+      (factory) => {
+        factory.hooks.parser.for("javascript/auto").tap("lessDetector", (parser) => {
+          parser.hooks.import.tap(
+            "lessDetector",
+            (statement, source) => {
+              var _a, _b;
+              const specifiers = statement.specifiers.length;
+              if (specifiers > 0 && (source.endsWith(".less") || source.endsWith(".css")) && this.isJSModule(parser)) {
+                this.throwError((_b = (_a = parser.state) == null ? void 0 : _a.module) == null ? void 0 : _b.resource, compiler);
+              }
+            }
+          );
+          parser.hooks.program.tap(
+            _DetectCSsModulePlugin.PLUGIN_NAME,
+            (program) => {
+              var _a, _b, _c, _d;
+              if (this.isJSModule(parser)) {
+                for (const statement of program.body) {
+                  if (statement.type === "AssignmentExpression" && // x= require("x.less") or var x = require(".css") ?
+                  this.isCallRequireStyle(statement.right)) {
+                    this.throwError((_b = (_a = parser.state) == null ? void 0 : _a.module) == null ? void 0 : _b.resource, compiler);
+                  }
+                  if (statement.type === "VariableDeclarator" && // var x= require("x.less") or var x = require(".css") ?
+                  this.isCallRequireStyle(statement.init)) {
+                    this.throwError((_d = (_c = parser.state) == null ? void 0 : _c.module) == null ? void 0 : _d.resource, compiler);
+                  }
+                }
+              }
+            }
+          );
+        });
+      }
+    );
+  }
+  isJSModule(parser) {
+    var _a, _b;
+    let res = (_b = (_a = parser.state) == null ? void 0 : _a.module) == null ? void 0 : _b.resource;
+    if (res) {
+      if (this.skipMatcher.some((r) => r.test(res))) {
+        return false;
+      }
+      return res.indexOf("node_modules") >= 0 && (res.endsWith(".js") || res.endsWith(".jsx"));
+    }
+    return false;
+  }
+  throwError(file, c) {
+    const logger = c.getInfrastructureLogger(_DetectCSsModulePlugin.PLUGIN_NAME) || console;
+    logger.error(import_utils.chalk.red(`Dependence file ${file} contains css module`));
+    logger.error(
+      import_utils.chalk.red(
+        `Please add the package's name in 'babelExtraIncludes' or use non-css module in dependence`
+      )
+    );
+    throw Error(_DetectCSsModulePlugin.ERROR_NAME);
+  }
+};
+var DetectCSsModulePlugin = _DetectCSsModulePlugin;
+DetectCSsModulePlugin.PLUGIN_NAME = "depCssModulesDetector";
+DetectCSsModulePlugin.ERROR_NAME = "USE CSS-MODULES IN NODE_MODULES";
+var toRegExp = (test) => {
+  if (typeof test === "string") {
+    return new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
+  }
+  return test;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addDependenceCssModulesDetector
+});

package/dist/config/detectDeadCode.d.ts

@@ -0,0 +1,12 @@
+import { Compilation } from '@umijs/bundler-webpack/compiled/webpack';
+import { DeadCodeParams } from '../types';
+export interface Options extends DeadCodeParams {
+    patterns: string[];
+    exclude: string[];
+    failOnHint: boolean;
+    detectUnusedFiles: boolean;
+    detectUnusedExport: boolean;
+}
+export declare const ignores: string[];
+declare const detectDeadCode: (compilation: Compilation, options: Options) => void;
+export default detectDeadCode;