Add the ability to exlcude certain plugins or loaders, if causing problems

Author: stephencookdev

README.md

@@ -123,6 +123,32 @@ const webpackConfig = smp.wrap({
 });
 ```
 
+### `options.excludedPlugins`
+
+Type: `Array<String|Function|RegExp>`<br>
+Default: `[]`
+
+Excludes plugins from SMP's proxy wrapping. Entries can be:
+
+- a plugin name
+- a plugin constructor
+- a regular expression matched against plugin names
+
+Name matching checks both `options.pluginNames` aliases and constructor names. E.g.
+
+```javascript
+const smp = new SpeedMeasurePlugin({
+  pluginNames: {
+    customReactRefresh: reactRefreshPlugin,
+  },
+  excludedPlugins: [
+    "customReactRefresh",
+    MiniCssExtractPlugin,
+    /SomeLegacyPlugin$/,
+  ],
+});
+```
+
 ### `options.loaderTopFiles`
 
 Type: `Number`<br>
@@ -168,6 +194,23 @@ This flag is _experimental_. Some loaders will have inaccurate results:
 
 We will find solutions to these issues before removing the _(experimental)_ flag on this option.
 
+### `options.excludedLoaders`
+
+Type: `Array<String|RegExp>`<br>
+Default: `[]`
+
+When `granularLoaderData` is enabled, SMP prepends its timing loader to each matching
+loader rule. Use this option to skip rules whose loader chain contains a matching
+loader name or regular expression. String matching checks both the original loader
+request and the normalized package name. E.g.
+
+```javascript
+const smp = new SpeedMeasurePlugin({
+  granularLoaderData: true,
+  excludedLoaders: ["thread-loader", /mini-css-extract-plugin/],
+});
+```
+
 ## FAQ
 
 ### What does general output time mean?

index.js

@@ -18,6 +18,18 @@ const {
 
 const NS = path.dirname(fs.realpathSync(__filename));
 
+const resetRegex = (pattern) => {
+  pattern.lastIndex = 0;
+  return pattern;
+};
+
+const matchesName = (names, matcher) => {
+  if (typeof matcher === "string") return names.includes(matcher);
+  if (matcher instanceof RegExp)
+    return names.some((name) => resetRegex(matcher).test(name));
+  return false;
+};
+
 module.exports = class SpeedMeasurePlugin {
   constructor(options) {
     this.options = options || {};
@@ -35,32 +47,67 @@ module.exports = class SpeedMeasurePlugin {
     );
   }
 
+  shouldExcludePlugin(plugin) {
+    const excludedPlugins = this.options.excludedPlugins || [];
+    const alias = Object.keys(this.options.pluginNames || {}).find(
+      (pluginName) => plugin === this.options.pluginNames[pluginName]
+    );
+    const pluginNames = [
+      alias,
+      plugin.constructor && plugin.constructor.name,
+    ].filter((name, index, names) => name && names.indexOf(name) === index);
+
+    return excludedPlugins.some(
+      (matcher) =>
+        matchesName(pluginNames, matcher) ||
+        (typeof matcher === "function" &&
+          (plugin === matcher || plugin.constructor === matcher))
+    );
+  }
+
+  shouldExcludeLoader(loader) {
+    const excludedLoaders = this.options.excludedLoaders || [];
+    const loaderNames = [loader.loader || loader]
+      .concat(getLoaderNames([loader]))
+      .filter((name, index, names) => name && names.indexOf(name) === index);
+
+    return excludedLoaders.some((matcher) => matchesName(loaderNames, matcher));
+  }
+
+  wrapPlugin(plugin) {
+    if (!plugin || typeof plugin.apply !== "function") return plugin;
+
+    const pluginName =
+      Object.keys(this.options.pluginNames || {}).find(
+        (pluginName) => plugin === this.options.pluginNames[pluginName]
+      ) ||
+      (plugin.constructor && plugin.constructor.name) ||
+      "(unable to deduce plugin name)";
+    if (this.shouldExcludePlugin(plugin)) return plugin;
+
+    return new WrappedPlugin(plugin, pluginName, this);
+  }
+
   wrap(config) {
     if (this.options.disable) return config;
     if (Array.isArray(config)) return config.map(this.wrap);
     if (typeof config === "function")
       return (...args) => this.wrap(config(...args));
 
-    config.plugins = (config.plugins || []).map((plugin) => {
-      const pluginName =
-        Object.keys(this.options.pluginNames || {}).find(
-          (pluginName) => plugin === this.options.pluginNames[pluginName]
-        ) ||
-        (plugin.constructor && plugin.constructor.name) ||
-        "(unable to deduce plugin name)";
-      return new WrappedPlugin(plugin, pluginName, this);
-    });
+    config.plugins = (config.plugins || []).map((plugin) =>
+      this.wrapPlugin(plugin)
+    );
 
     if (config.optimization && config.optimization.minimizer) {
       config.optimization.minimizer = config.optimization.minimizer.map(
-        (plugin) => {
-          return new WrappedPlugin(plugin, plugin.constructor.name, this);
-        }
+        (plugin) => this.wrapPlugin(plugin)
       );
     }
 
     if (config.module && this.options.granularLoaderData) {
-      config.module = prependLoader(config.module);
+      config.module = prependLoader(config.module, (loader) =>
+        this.shouldExcludeLoader(loader)
+      );
     }
 
     if (!this.smpPluginAdded) {

index.test.js

@@ -0,0 +1,145 @@
+const SpeedMeasurePlugin = require("./index");
+
+class IncludedPlugin {
+  apply() {}
+}
+
+class ExcludedPlugin {
+  apply() {}
+}
+
+class IncludedMinimizer {
+  apply() {}
+}
+
+class ExcludedMinimizer {
+  apply() {}
+}
+
+describe("wrap", () => {
+  it("should exclude named plugins and minimizers from wrapping", () => {
+    const includedPlugin = new IncludedPlugin();
+    const excludedPlugin = new ExcludedPlugin();
+    const includedMinimizer = new IncludedMinimizer();
+    const excludedMinimizer = new ExcludedMinimizer();
+    const smp = new SpeedMeasurePlugin({
+      excludedPlugins: ["ExcludedPlugin", "ExcludedMinimizer"],
+    });
+
+    const wrappedConfig = smp.wrap({
+      plugins: [includedPlugin, excludedPlugin],
+      optimization: {
+        minimizer: [includedMinimizer, excludedMinimizer],
+      },
+    });
+
+    expect(wrappedConfig.plugins[0]).not.toBe(includedPlugin);
+    expect(wrappedConfig.plugins[1]).toBe(excludedPlugin);
+    expect(wrappedConfig.optimization.minimizer[0]).not.toBe(includedMinimizer);
+    expect(wrappedConfig.optimization.minimizer[1]).toBe(excludedMinimizer);
+  });
+
+  it("should allow excluding plugins by constructor", () => {
+    const includedPlugin = new IncludedPlugin();
+    const excludedPlugin = new ExcludedPlugin();
+    const smp = new SpeedMeasurePlugin({
+      excludedPlugins: [ExcludedPlugin],
+    });
+
+    const wrappedConfig = smp.wrap({
+      plugins: [includedPlugin, excludedPlugin],
+    });
+
+    expect(wrappedConfig.plugins[0]).not.toBe(includedPlugin);
+    expect(wrappedConfig.plugins[1]).toBe(excludedPlugin);
+  });
+
+  it("should allow excluding plugins by regex", () => {
+    const includedPlugin = new IncludedPlugin();
+    const excludedPlugin = new ExcludedPlugin();
+    const smp = new SpeedMeasurePlugin({
+      excludedPlugins: [/Excluded/],
+    });
+
+    const wrappedConfig = smp.wrap({
+      plugins: [includedPlugin, excludedPlugin],
+    });
+
+    expect(wrappedConfig.plugins[0]).not.toBe(includedPlugin);
+    expect(wrappedConfig.plugins[1]).toBe(excludedPlugin);
+  });
+
+  it("should allow excluding plugins by custom pluginNames alias", () => {
+    const aliasedPlugin = new ExcludedPlugin();
+    const smp = new SpeedMeasurePlugin({
+      pluginNames: {
+        customPluginName: aliasedPlugin,
+      },
+      excludedPlugins: ["customPluginName"],
+    });
+
+    const wrappedConfig = smp.wrap({
+      plugins: [aliasedPlugin],
+    });
+
+    expect(wrappedConfig.plugins[0]).toBe(aliasedPlugin);
+  });
+
+  it("should skip injecting granular timing for excluded loaders by name", () => {
+    const smp = new SpeedMeasurePlugin({
+      granularLoaderData: true,
+      excludedLoaders: ["babel-loader"],
+    });
+
+    const wrappedConfig = smp.wrap({
+      module: {
+        rules: [{ use: ["babel-loader"] }, { use: ["file-loader"] }],
+      },
+    });
+
+    expect(wrappedConfig.module.rules[0].use).toEqual(["babel-loader"]);
+    expect(wrappedConfig.module.rules[1].use).toEqual([
+      "speed-measure-webpack-plugin/loader",
+      "file-loader",
+    ]);
+  });
+
+  it("should skip injecting granular timing for excluded loaders by regex", () => {
+    const smp = new SpeedMeasurePlugin({
+      granularLoaderData: true,
+      excludedLoaders: [/css-loader/],
+    });
+
+    const wrappedConfig = smp.wrap({
+      module: {
+        rules: [
+          {
+            use: ["style-loader", "/tmp/node_modules/css-loader/dist/cjs.js"],
+          },
+          { use: ["file-loader"] },
+        ],
+      },
+    });
+
+    expect(wrappedConfig.module.rules[1].use).toEqual([
+      "speed-measure-webpack-plugin/loader",
+      "file-loader",
+    ]);
+    expect(wrappedConfig.module.rules[0].use).toEqual([
+      "style-loader",
+      "/tmp/node_modules/css-loader/dist/cjs.js",
+    ]);
+  });
+
+  it('should leave the webpack 5 "..." minimizer sentinel untouched', () => {
+    const smp = new SpeedMeasurePlugin();
+
+    const wrappedConfig = smp.wrap({
+      optimization: {
+        minimizer: ["..."],
+      },
+    });
+
+    expect(wrappedConfig.optimization.minimizer).toEqual(["..."]);
+  });
+});