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

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;

package/dist/config/detectDeadCode.js

@@ -0,0 +1,191 @@
+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/detectDeadCode.ts
+var detectDeadCode_exports = {};
+__export(detectDeadCode_exports, {
+  default: () => detectDeadCode_default,
+  ignores: () => ignores
+});
+module.exports = __toCommonJS(detectDeadCode_exports);
+var import_webpack = require("@umijs/bundler-webpack/compiled/webpack");
+var import_utils = require("@umijs/utils");
+var import_path = __toESM(require("path"));
+var ignores = [
+  "**/node_modules/**",
+  "**/.umi/**",
+  "**/.umi-production/**",
+  "**/.umi-test/**",
+  "coverage/**",
+  "dist/**",
+  "config/**",
+  "public/**",
+  "mock/**"
+];
+var detectDeadCode = (compilation, options) => {
+  const assets = getWebpackAssets(compilation);
+  const compiledFilesDictionary = convertFilesToDict(assets);
+  const context = options.context;
+  if (!options.patterns.length) {
+    options.patterns = getDefaultSourcePattern({ cwd: context });
+  }
+  const includedFiles = options.patterns.map((pattern) => {
+    return import_utils.glob.sync(pattern, {
+      ignore: [...ignores, ...options.exclude],
+      cwd: context,
+      absolute: true
+    });
+  }).flat();
+  const unusedFiles = options.detectUnusedFiles ? includedFiles.filter((file) => !compiledFilesDictionary[file]) : [];
+  const unusedExportMap = options.detectUnusedExport ? getUnusedExportMap(convertFilesToDict(includedFiles), compilation) : {};
+  logUnusedFiles(unusedFiles);
+  logUnusedExportMap(unusedExportMap);
+  const hasUnusedThings = unusedFiles.length || Object.keys(unusedExportMap).length;
+  if (hasUnusedThings && options.failOnHint) {
+    process.exit(2);
+  }
+};
+var getUnusedExportMap = (includedFileMap, compilation) => {
+  const unusedExportMap = {};
+  compilation.chunks.forEach((chunk) => {
+    compilation.chunkGraph.getChunkModules(chunk).forEach((module2) => {
+      outputUnusedExportMap(
+        compilation,
+        chunk,
+        module2,
+        includedFileMap,
+        unusedExportMap
+      );
+    });
+  });
+  return unusedExportMap;
+};
+var outputUnusedExportMap = (compilation, chunk, module2, includedFileMap, unusedExportMap) => {
+  if (!(module2 instanceof import_webpack.NormalModule) || !module2.resource) {
+    return;
+  }
+  const path2 = (0, import_utils.winPath)(module2.resource);
+  if (!/^((?!(node_modules)).)*$/.test(path2))
+    return;
+  const providedExports = compilation.chunkGraph.moduleGraph.getProvidedExports(module2);
+  const usedExports = compilation.chunkGraph.moduleGraph.getUsedExports(
+    module2,
+    chunk.runtime
+  );
+  if (usedExports !== true && providedExports !== true && includedFileMap[path2]) {
+    if (usedExports === false) {
+      if (providedExports == null ? void 0 : providedExports.length) {
+        unusedExportMap[path2] = providedExports;
+      }
+    } else if (providedExports instanceof Array) {
+      const unusedExports = providedExports.filter(
+        (item) => usedExports && !usedExports.has(item)
+      );
+      if (unusedExports.length) {
+        unusedExportMap[path2] = unusedExports;
+      }
+    }
+  }
+};
+var logUnusedExportMap = (unusedExportMap) => {
+  if (!Object.keys(unusedExportMap).length) {
+    return;
+  }
+  let numberOfUnusedExport = 0;
+  let logStr = "";
+  Object.keys(unusedExportMap).forEach((filePath, fileIndex) => {
+    const unusedExports = unusedExportMap[filePath];
+    logStr += [
+      `
+${fileIndex + 1}. `,
+      import_utils.chalk.yellow(`${filePath}
+`),
+      "    >>>  ",
+      import_utils.chalk.yellow(`${unusedExports.join(",  ")}`)
+    ].join("");
+    numberOfUnusedExport += unusedExports.length;
+  });
+  console.log(
+    import_utils.chalk.yellow.bold("\nWarning:"),
+    import_utils.chalk.yellow(
+      `There are ${numberOfUnusedExport} unused exports in ${Object.keys(unusedExportMap).length} files:`
+    ),
+    logStr,
+    import_utils.chalk.red.bold("\nPlease be careful if you want to remove them (¬º-°)¬.\n")
+  );
+};
+var getWebpackAssets = (compilation) => {
+  const outputPath = compilation.getPath(
+    compilation.compiler.outputPath
+  );
+  const assets = [
+    ...Array.from(compilation.fileDependencies),
+    ...compilation.getAssets().map((asset) => import_path.default.join(outputPath, asset.name))
+  ];
+  return assets;
+};
+var convertFilesToDict = (assets) => {
+  return assets.filter((path2) => !/(node_modules|(\.umi))/.test(path2) && Boolean(path2)).reduce((fileDictionary, file) => {
+    const unixFile = (0, import_utils.winPath)(file);
+    fileDictionary[unixFile] = true;
+    return fileDictionary;
+  }, {});
+};
+var logUnusedFiles = (unusedFiles) => {
+  if (!(unusedFiles == null ? void 0 : unusedFiles.length)) {
+    return;
+  }
+  console.log(
+    import_utils.chalk.yellow.bold("\nWarning:"),
+    import_utils.chalk.yellow(`There are ${unusedFiles.length} unused files:`),
+    ...unusedFiles.map(
+      (file, index) => `
+${index + 1}. ${import_utils.chalk.yellow(file)}`
+    ),
+    import_utils.chalk.red.bold("\nPlease be careful if you want to remove them (¬º-°)¬.\n")
+  );
+};
+function isDirExist(p) {
+  return import_utils.fsExtra.existsSync(p) && import_utils.fsExtra.statSync(p).isDirectory();
+}
+function getDefaultSourcePattern(opts) {
+  const { cwd } = opts;
+  const srcPath = import_path.default.join(cwd, "src");
+  if (isDirExist(srcPath)) {
+    return ["src/**/*"];
+  }
+  const dirs = import_utils.fsExtra.readdirSync(cwd).filter((p) => {
+    return !p.startsWith(".") && isDirExist(p);
+  });
+  return dirs.map((dir) => `${dir}/**/*`);
+}
+var detectDeadCode_default = detectDeadCode;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ignores
+});

package/dist/config/detectDeadCodePlugin.d.ts

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

package/dist/config/detectDeadCodePlugin.js

@@ -0,0 +1,82 @@
+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/detectDeadCodePlugin.ts
+var detectDeadCodePlugin_exports = {};
+__export(detectDeadCodePlugin_exports, {
+  addDetectDeadCodePlugin: () => addDetectDeadCodePlugin
+});
+module.exports = __toCommonJS(detectDeadCodePlugin_exports);
+var import_types = require("../types");
+var import_detectDeadCode = __toESM(require("./detectDeadCode"));
+var defaultOptions = {
+  patterns: [],
+  exclude: [],
+  failOnHint: false,
+  detectUnusedFiles: true,
+  detectUnusedExport: true
+};
+var DetectDeadCodePlugin = class {
+  constructor(options) {
+    this.options = defaultOptions;
+    this.handleAfterEmit = (compilation, callback) => {
+      (0, import_detectDeadCode.default)(compilation, this.options);
+      callback();
+    };
+    if (!options) {
+      return;
+    }
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  apply(compiler) {
+    if (!this.options.context) {
+      this.options = {
+        ...this.options,
+        context: compiler.context
+      };
+    }
+    compiler.hooks.afterEmit.tapAsync(
+      "DetectDeadCodePlugin",
+      this.handleAfterEmit
+    );
+  }
+};
+async function addDetectDeadCodePlugin(opts) {
+  const { config, userConfig } = opts;
+  const isDev = opts.env === import_types.Env.development;
+  if (userConfig.deadCode && !isDev) {
+    config.plugin("detect-dead-code-plugin").use(DetectDeadCodePlugin, [userConfig.deadCode]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addDetectDeadCodePlugin
+});

package/dist/config/fastRefreshPlugin.d.ts

@@ -0,0 +1,12 @@
+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;
+    name?: string;
+}
+export declare function addFastRefreshPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/fastRefreshPlugin.js

@@ -0,0 +1,49 @@
+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/fastRefreshPlugin.ts
+var fastRefreshPlugin_exports = {};
+__export(fastRefreshPlugin_exports, {
+  addFastRefreshPlugin: () => addFastRefreshPlugin
+});
+module.exports = __toCommonJS(fastRefreshPlugin_exports);
+var import_lib = __toESM(require("@umijs/react-refresh-webpack-plugin/lib"));
+var import_constants = require("../constants");
+var import_types = require("../types");
+async function addFastRefreshPlugin(opts) {
+  const { config, userConfig, name } = opts;
+  const isDev = opts.env === import_types.Env.development;
+  const useFastRefresh = isDev && userConfig.fastRefresh !== false && name !== import_constants.MFSU_NAME;
+  if (useFastRefresh) {
+    config.plugin("fastRefresh").after("hmr").use(import_lib.default, [{ overlay: false }]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addFastRefreshPlugin
+});

package/dist/config/forkTSCheckerPlugin.d.ts

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

package/dist/config/forkTSCheckerPlugin.js

@@ -0,0 +1,49 @@
+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/forkTSCheckerPlugin.ts
+var forkTSCheckerPlugin_exports = {};
+__export(forkTSCheckerPlugin_exports, {
+  addForkTSCheckerPlugin: () => addForkTSCheckerPlugin
+});
+module.exports = __toCommonJS(forkTSCheckerPlugin_exports);
+var import_fork_ts_checker_webpack_plugin = __toESM(require("fork-ts-checker-webpack-plugin"));
+async function addForkTSCheckerPlugin(opts) {
+  var _a;
+  const { config, userConfig } = opts;
+  if (userConfig.forkTSChecker) {
+    if ((_a = userConfig.forkTSChecker.typescript) == null ? void 0 : _a.enable) {
+      userConfig.forkTSChecker.typescript.typescriptPath = require.resolve("typescript");
+    }
+    config.plugin("fork-ts-checker-plugin").use(import_fork_ts_checker_webpack_plugin.default, [userConfig.forkTSChecker]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addForkTSCheckerPlugin
+});

package/dist/config/harmonyLinkingErrorPlugin.d.ts

@@ -0,0 +1,6 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+interface IOpts {
+    config: Config;
+}
+export declare function addHarmonyLinkingErrorPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/harmonyLinkingErrorPlugin.js

@@ -0,0 +1,53 @@
+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/harmonyLinkingErrorPlugin.ts
+var harmonyLinkingErrorPlugin_exports = {};
+__export(harmonyLinkingErrorPlugin_exports, {
+  addHarmonyLinkingErrorPlugin: () => addHarmonyLinkingErrorPlugin
+});
+module.exports = __toCommonJS(harmonyLinkingErrorPlugin_exports);
+var LINKING_ERROR_TAG = "was not found in";
+var CSS_NO_EXPORTS = /\.(css|sass|scss|styl|less)' \(module has no exports\)/;
+var HarmonyLinkingErrorPlugin = class {
+  apply(compiler) {
+    compiler.hooks.afterCompile.tap(
+      "HarmonyLinkingErrorPlugin",
+      (compilation) => {
+        if (!compilation.warnings.length) {
+          return;
+        }
+        const harmonyLinkingErrors = compilation.warnings.filter((w) => {
+          return w.name === "ModuleDependencyWarning" && !w.module.resource.includes("node_modules") && w.message.includes(LINKING_ERROR_TAG) && !CSS_NO_EXPORTS.test(w.message);
+        });
+        if (!harmonyLinkingErrors.length) {
+          return;
+        }
+        compilation.errors.push(...harmonyLinkingErrors);
+      }
+    );
+  }
+};
+async function addHarmonyLinkingErrorPlugin(opts) {
+  const { config } = opts;
+  config.plugin("harmony-linking-error-plugin").use(HarmonyLinkingErrorPlugin);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addHarmonyLinkingErrorPlugin
+});

package/dist/config/ignorePlugin.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 addIgnorePlugin(opts: IOpts): Promise<void>;
+export {};