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

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.js

@@ -1,34 +1,49 @@
-"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 });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addFastRefreshPlugin = void 0;
-// @ts-ignore
-const lib_1 = __importDefault(require("@pmmmwh/react-refresh-webpack-plugin/lib"));
-const constants_1 = require("../constants");
-const types_1 = require("../types");
-function addFastRefreshPlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig, name } = opts;
-        const isDev = opts.env === types_1.Env.development;
-        const useFastRefresh = isDev && userConfig.fastRefresh !== false && name !== constants_1.MFSU_NAME;
-        // TODO: Should only run in react csr
-        if (useFastRefresh) {
-            config
-                .plugin('fastRefresh')
-                .after('hmr')
-                .use(lib_1.default, [{ overlay: false }]);
-        }
-    });
+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 }]);
+  }
 }
-exports.addFastRefreshPlugin = addFastRefreshPlugin;
+// 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.js

@@ -1,27 +1,40 @@
-"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.addIgnorePlugin = void 0;
-const webpack_1 = require("@umijs/bundler-webpack/compiled/webpack");
-function addIgnorePlugin(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { config, userConfig } = opts;
-        if (userConfig.ignoreMomentLocale) {
-            config.plugin('ignore-moment-locale').use(webpack_1.IgnorePlugin, [
-                {
-                    resourceRegExp: /^\.\/locale$/,
-                    contextRegExp: /moment$/,
-                },
-            ]);
-        }
-    });
+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/ignorePlugin.ts
+var ignorePlugin_exports = {};
+__export(ignorePlugin_exports, {
+  addIgnorePlugin: () => addIgnorePlugin
+});
+module.exports = __toCommonJS(ignorePlugin_exports);
+var import_webpack = require("@umijs/bundler-webpack/compiled/webpack");
+async function addIgnorePlugin(opts) {
+  const { config, userConfig } = opts;
+  if (userConfig.ignoreMomentLocale) {
+    config.plugin("ignore-moment-locale").use(import_webpack.IgnorePlugin, [
+      {
+        resourceRegExp: /^\.\/locale$/,
+        contextRegExp: /moment$/
+      }
+    ]);
+  }
 }
-exports.addIgnorePlugin = addIgnorePlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addIgnorePlugin
+});

package/dist/config/javaScriptRules.d.ts

@@ -7,6 +7,8 @@ interface IOpts {
     env: Env;
     extraBabelPlugins: any[];
     extraBabelPresets: any[];
+    extraBabelIncludes: Array<string | RegExp>;
+    extraEsbuildLoaderHandler: any[];
     babelPreset: any;
     name?: string;
 }