@rsdoctor/webpack-plugin 0.0.2-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# Rsdoctor
+
+Rsdoctor is a tool for diagnosing and analyzing the build process and build artifacts to help developers quickly identify and solve problems.
+
+It also supports Webpack and Rspack builders, as well as various build frameworks, such as Rsbuild.
+
+## Documentation
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rsdoctor/blob/main/CONTRIBUTING.md).
+
+## License
+
+Rsdoctor is [MIT licensed](https://github.com/web-infra-dev/rsdoctor/blob/main/LICENSE).

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+import type { Tap } from 'tapable';
+export declare const pluginTapName = "DoctorWebpackPlugin";
+export declare const pluginTapPostOptions: Tap;
+export declare const pluginTapPreOptions: Tap;
+export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
+export declare const internalPluginTapPostOptions: (namespace: string) => Tap;

package/dist/constants.js

@@ -0,0 +1,52 @@
+"use strict";
+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);
+var constants_exports = {};
+__export(constants_exports, {
+  internalPluginTapPostOptions: () => internalPluginTapPostOptions,
+  internalPluginTapPreOptions: () => internalPluginTapPreOptions,
+  pluginTapName: () => pluginTapName,
+  pluginTapPostOptions: () => pluginTapPostOptions,
+  pluginTapPreOptions: () => pluginTapPreOptions
+});
+module.exports = __toCommonJS(constants_exports);
+const pluginTapName = "DoctorWebpackPlugin";
+const pluginTapPostOptions = {
+  name: pluginTapName,
+  stage: 999
+};
+const pluginTapPreOptions = {
+  name: pluginTapName,
+  stage: -999
+};
+const internalPluginTapPreOptions = (namespace) => ({
+  name: `${pluginTapName}:${namespace}`,
+  stage: -998
+});
+const internalPluginTapPostOptions = (namespace) => ({
+  name: `${pluginTapName}:${namespace}`,
+  stage: 1e3
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  internalPluginTapPostOptions,
+  internalPluginTapPreOptions,
+  pluginTapName,
+  pluginTapPostOptions,
+  pluginTapPreOptions
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './plugin';
+export * from './multiple';
+export * from './plugins/bundle';
+export { defineRule, LinterType } from '@rsdoctor/core/rules';

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  LinterType: () => import_rules.LinterType,
+  defineRule: () => import_rules.defineRule
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./plugin"), module.exports);
+__reExport(src_exports, require("./multiple"), module.exports);
+__reExport(src_exports, require("./plugins/bundle"), module.exports);
+var import_rules = require("@rsdoctor/core/rules");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LinterType,
+  defineRule,
+  ...require("./plugin"),
+  ...require("./multiple"),
+  ...require("./plugins/bundle")
+});

package/dist/multiple.d.ts

@@ -0,0 +1,7 @@
+import { Linter } from '@rsdoctor/types';
+import type { DoctorWebpackMultiplePluginOptions } from '@rsdoctor/core';
+import { RsdoctorWebpackPlugin } from './plugin';
+export declare class RsdoctorWebpackMultiplePlugin<Rules extends Linter.ExtendRuleData[]> extends RsdoctorWebpackPlugin<Rules> {
+  private controller;
+  constructor(options?: DoctorWebpackMultiplePluginOptions<Rules>);
+}

package/dist/multiple.js

@@ -0,0 +1,52 @@
+"use strict";
+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);
+var multiple_exports = {};
+__export(multiple_exports, {
+  RsdoctorWebpackMultiplePlugin: () => RsdoctorWebpackMultiplePlugin
+});
+module.exports = __toCommonJS(multiple_exports);
+var import_sdk = require("@rsdoctor/sdk");
+var import_plugin = require("./plugin");
+let globalController;
+class RsdoctorWebpackMultiplePlugin extends import_plugin.RsdoctorWebpackPlugin {
+  constructor(options = {}) {
+    const controller = (() => {
+      if (globalController) {
+        return globalController;
+      }
+      const controller2 = new import_sdk.DoctorSDKController();
+      globalController = controller2;
+      return controller2;
+    })();
+    const instance = controller.createSlave({
+      name: options.name || "Builder",
+      stage: options.stage,
+      extraConfig: { disableTOSUpload: options.disableTOSUpload || false }
+    });
+    super({
+      ...options,
+      sdkInstance: instance
+    });
+    this.controller = controller;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsdoctorWebpackMultiplePlugin
+});

package/dist/plugin.d.ts

@@ -0,0 +1,38 @@
+import type { DoctorPluginInstance, DoctorPluginOptionsNormalized, DoctorWebpackPluginOptions } from '@rsdoctor/core/types';
+import { ChunkGraph, ModuleGraph } from '@rsdoctor/graph';
+import { DoctorWebpackSDK } from '@rsdoctor/sdk';
+import { Linter } from '@rsdoctor/types';
+import { Compiler, StatsCompilation } from 'webpack';
+export declare class RsdoctorWebpackPlugin<Rules extends Linter.ExtendRuleData[]> implements DoctorPluginInstance<Compiler, Rules> {
+  readonly name = "DoctorWebpackPlugin";
+  readonly options: DoctorPluginOptionsNormalized<Rules>;
+  readonly sdk: DoctorWebpackSDK;
+  modulesGraph: ModuleGraph;
+  private outsideInstance;
+  _bootstrapTask: Promise<unknown>;
+  protected browserIsOpened: boolean;
+  chunkGraph: ChunkGraph;
+  constructor(options?: DoctorWebpackPluginOptions<Rules>);
+  apply(compiler: unknown): unknown;
+  afterPlugins: (compiler: Compiler) => void;
+  beforeRun: (compiler: Compiler) => Promise<void>;
+  private _modulesGraphApplied;
+  /**
+   * @description Generate ModuleGraph and ChunkGraph from stats and webpack module apis;
+   * @param {Compiler} compiler
+   * @return {*}
+   * @memberof DoctorWebpackPlugin
+   */
+  ensureModulesChunksGraphApplied(compiler: Compiler): void;
+  done: () => Promise<void>;
+  /**
+   * @protected
+   * @description This function to get module parsed code and size;
+   * @param {Compiler} compiler
+   * @param {StatsCompilation} stats
+   * @param {ModuleGraph} moduleGraph
+   * @return {*}
+   * @memberof DoctorWebpackPlugin
+   */
+  protected getModulesInfosByStats(compiler: Compiler, stats: StatsCompilation, moduleGraph: ModuleGraph): Promise<void>;
+}

package/dist/plugin.js

@@ -0,0 +1,252 @@
+"use strict";
+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);
+var plugin_exports = {};
+__export(plugin_exports, {
+  RsdoctorWebpackPlugin: () => RsdoctorWebpackPlugin
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_build_utils = require("@rsdoctor/core/build-utils");
+var import_common_utils = require("@rsdoctor/core/common-utils");
+var import_plugins = require("@rsdoctor/core/plugins");
+var import_graph = require("@rsdoctor/graph");
+var import_sdk = require("@rsdoctor/sdk");
+var import_types = require("@rsdoctor/types");
+var import_build = require("@rsdoctor/utils/build");
+var import_logger = require("@rsdoctor/utils/logger");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_lodash = require("lodash");
+var import_path = __toESM(require("path"));
+var import_constants = require("./constants");
+var import_bundle = require("./plugins/bundle");
+var import_resolver = require("./plugins/resolver");
+var import_rules = require("./plugins/rules");
+class RsdoctorWebpackPlugin {
+  constructor(options) {
+    this.name = import_constants.pluginTapName;
+    this.outsideInstance = false;
+    this.browserIsOpened = false;
+    this.afterPlugins = (compiler) => {
+      if (compiler.isChild())
+        return;
+      const { plugins, infrastructureLogging, ...rest } = compiler.options;
+      const _rest = (0, import_lodash.cloneDeep)(rest);
+      (0, import_plugins.makeRulesSerializable)(_rest.module.defaultRules);
+      (0, import_plugins.makeRulesSerializable)(_rest.module.rules);
+      const configuration = {
+        ..._rest,
+        plugins: plugins.map((e) => e?.constructor.name)
+      };
+      this.sdk.reportConfiguration({
+        name: "webpack",
+        version: compiler.webpack?.version || "unknown",
+        config: configuration
+      });
+      this.sdk.setOutputDir(
+        import_path.default.resolve(compiler.outputPath, `./${import_types.Constants.DoctorOutputFolder}`)
+      );
+      if (configuration.name) {
+        this.sdk.setName(configuration.name);
+      }
+    };
+    this.beforeRun = async (compiler) => {
+      if (compiler.isChild())
+        return;
+      await this._bootstrapTask.then(() => {
+        if (!this.options.disableClientServer && !this.browserIsOpened) {
+          this.browserIsOpened = true;
+          this.sdk.server.openClientPage();
+        }
+      });
+    };
+    this._modulesGraphApplied = false;
+    this.done = async () => {
+      try {
+        this.sdk.server.broadcast();
+        (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[Before Write Manifest]");
+        await this.sdk.writeStore();
+        (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Write Manifest]");
+        if (this.options.disableClientServer) {
+          await this.sdk.dispose();
+          (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After SDK Dispose]");
+        }
+      } catch (e) {
+      }
+    };
+    this.options = (0, import_plugins.normalizeUserConfig)(options);
+    this.sdk = this.options.sdkInstance ?? new import_sdk.DoctorWebpackSDK({
+      name: import_constants.pluginTapName,
+      root: process.cwd(),
+      type: this.options.reportCodeType,
+      config: { disableTOSUpload: this.options.disableTOSUpload }
+    });
+    this.outsideInstance = Boolean(this.options.sdkInstance);
+    this.modulesGraph = new import_graph.ModuleGraph();
+    this.chunkGraph = new import_graph.ChunkGraph();
+  }
+  apply(compiler) {
+    if (!this._bootstrapTask) {
+      this._bootstrapTask = this.sdk.bootstrap();
+    }
+    if (!this.outsideInstance) {
+      (0, import_plugins.setSDK)(this.sdk);
+    }
+    new import_plugins.InternalSummaryPlugin(this).apply(compiler);
+    if (this.options.features.loader) {
+      new import_plugins.InternalLoaderPlugin(this).apply(compiler);
+    }
+    if (this.options.features.resolver) {
+      new import_resolver.InternalResolverPlugin(this).apply(compiler);
+    }
+    if (this.options.features.plugins) {
+      new import_plugins.InternalPluginsPlugin(this).apply(compiler);
+    }
+    if (this.options.features.bundle) {
+      new import_bundle.InternalBundlePlugin(this).apply(compiler);
+    }
+    new import_plugins.InternalErrorReporterPlugin(this).apply(compiler);
+    new import_rules.InternalRulesPlugin(this).apply(compiler);
+    new import_plugins.InternalProgressPlugin(this).apply(compiler);
+    compiler.hooks.afterPlugins.tap(import_constants.pluginTapPostOptions, this.afterPlugins);
+    compiler.hooks.watchRun.tapPromise(import_constants.pluginTapPostOptions, this.beforeRun);
+    compiler.hooks.beforeRun.tapPromise(import_constants.pluginTapPostOptions, this.beforeRun);
+    compiler.hooks.done.tapPromise(
+      {
+        ...import_constants.pluginTapPostOptions,
+        stage: import_constants.pluginTapPostOptions.stage + 100
+      },
+      this.done.bind(this)
+    );
+  }
+  /**
+   * @description Generate ModuleGraph and ChunkGraph from stats and webpack module apis;
+   * @param {Compiler} compiler
+   * @return {*}
+   * @memberof DoctorWebpackPlugin
+   */
+  ensureModulesChunksGraphApplied(compiler) {
+    if (this._modulesGraphApplied)
+      return;
+    this._modulesGraphApplied = true;
+    const context = {
+      astCache: /* @__PURE__ */ new Map(),
+      packagePathMap: /* @__PURE__ */ new Map(),
+      getSourceMap: (file) => {
+        return this.sdk.getSourceMap(file);
+      }
+    };
+    compiler.hooks.normalModuleFactory.tap(
+      (0, import_constants.internalPluginTapPostOptions)("moduleGraph"),
+      (factory) => {
+        const record = (parser) => {
+          parser.hooks.program.tap(import_constants.pluginTapPreOptions, (ast) => {
+            context.astCache.set(parser.state.current, ast);
+          });
+        };
+        factory.hooks.parser.for("javascript/auto").tap(import_constants.pluginTapPostOptions, record);
+        factory.hooks.parser.for("javascript/dynamic").tap(import_constants.pluginTapPostOptions, record);
+        factory.hooks.parser.for("javascript/esm").tap(import_constants.pluginTapPostOptions, record);
+      }
+    );
+    compiler.hooks.done.tapPromise(
+      (0, import_constants.internalPluginTapPreOptions)("moduleGraph"),
+      async (stats) => {
+        const statsJson = stats.toJson();
+        (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[Before Generate ModuleGraph]");
+        this.chunkGraph = import_build_utils.Chunks.chunkTransform(/* @__PURE__ */ new Map(), statsJson);
+        this.modulesGraph = await import_build_utils.ModuleGraph.getModuleGraphByStats(
+          stats.compilation,
+          statsJson,
+          process.cwd(),
+          this.chunkGraph,
+          this.options.features,
+          context
+        );
+        (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Generate ModuleGraph]");
+        if (this.options.features.treeShaking) {
+          this.modulesGraph = import_build_utils.ModuleGraph.appendTreeShaking(
+            this.modulesGraph,
+            stats.compilation
+          );
+          this.sdk.addClientRoutes([
+            import_types.Manifest.DoctorManifestClientRoutes.TreeShaking
+          ]);
+          (0, import_logger.debug)(
+            import_build.Process.getMemoryUsageMessage,
+            "[After AppendTreeShaking to ModuleGraph]"
+          );
+        }
+        await this.getModulesInfosByStats(
+          compiler,
+          statsJson,
+          this.modulesGraph
+        );
+        (0, import_logger.debug)(import_build.Process.getMemoryUsageMessage, "[After Transform ModuleGraph]");
+        this.modulesGraph && await this.sdk.reportModuleGraph(this.modulesGraph);
+        await this.sdk.reportChunkGraph(this.chunkGraph);
+        const reportFilePath = await import_build_utils.Chunks.generateTileGraph(
+          statsJson,
+          {
+            reportFilename: import_build_utils.Chunks.TileGraphReportName,
+            reportTitle: "bundle-analyzer"
+          },
+          compiler.outputPath
+        );
+        reportFilePath && await this.sdk.reportTileHtml(
+          import_fs_extra.default.readFileSync(reportFilePath, "utf-8")
+        );
+      }
+    );
+  }
+  /**
+   * @protected
+   * @description This function to get module parsed code and size;
+   * @param {Compiler} compiler
+   * @param {StatsCompilation} stats
+   * @param {ModuleGraph} moduleGraph
+   * @return {*}
+   * @memberof DoctorWebpackPlugin
+   */
+  async getModulesInfosByStats(compiler, stats, moduleGraph) {
+    if (!moduleGraph) {
+      return;
+    }
+    try {
+      const parsedModulesData = await import_build_utils.Chunks.getAssetsModulesData(
+        stats,
+        compiler.outputPath
+      ) || {};
+      import_common_utils.Chunks.transformAssetsModulesData(parsedModulesData, moduleGraph);
+    } catch (e) {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsdoctorWebpackPlugin
+});

package/dist/plugins/bundle.d.ts

@@ -0,0 +1,14 @@
+import { InternalBasePlugin } from '@rsdoctor/core/plugins';
+import type { Compilation, Compiler } from 'webpack';
+export declare class InternalBundlePlugin<T extends Compiler> extends InternalBasePlugin<T> {
+  readonly name = "bundle";
+  map: Map<string, {
+    content: string;
+  }>;
+  apply(compiler: T): void;
+  ensureAssetContent(name: string): {
+    content: string;
+  };
+  thisCompilation: (compilation: Compilation) => void;
+  done: () => Promise<void>;
+}

package/dist/plugins/bundle.js

@@ -0,0 +1,80 @@
+"use strict";
+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);
+var bundle_exports = {};
+__export(bundle_exports, {
+  InternalBundlePlugin: () => InternalBundlePlugin
+});
+module.exports = __toCommonJS(bundle_exports);
+var import_common_utils = require("@rsdoctor/core/common-utils");
+var import_plugins = require("@rsdoctor/core/plugins");
+var import_types = require("@rsdoctor/types");
+class InternalBundlePlugin extends import_plugins.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "bundle";
+    this.map = /* @__PURE__ */ new Map();
+    this.thisCompilation = (compilation) => {
+      if (compilation.hooks.processAssets && compilation.hooks.afterOptimizeAssets) {
+        compilation.hooks.afterOptimizeAssets.tap(
+          this.tapPostOptions,
+          (assets) => {
+            Object.keys(assets).forEach((file) => {
+              const v = this.ensureAssetContent(file);
+              v.content = assets[file].source().toString();
+            });
+          }
+        );
+      } else {
+        compilation.hooks.afterOptimizeChunkAssets.tap(
+          this.tapPostOptions,
+          (chunks) => {
+            [...chunks].reduce((t, chunk) => t.concat([...chunk.files]), []).forEach((file) => {
+              const v = this.ensureAssetContent(file);
+              v.content = compilation.assets[file].source().toString();
+            });
+          }
+        );
+      }
+    };
+    this.done = async () => {
+      import_common_utils.Chunks.assetsContents(this.map, this.scheduler.chunkGraph);
+      this.sdk.addClientRoutes([
+        import_types.Manifest.DoctorManifestClientRoutes.ModuleGraph,
+        import_types.Manifest.DoctorManifestClientRoutes.BundleSize
+      ]);
+    };
+  }
+  apply(compiler) {
+    this.scheduler.ensureModulesChunksGraphApplied(compiler);
+    compiler.hooks.compilation.tap(this.tapPostOptions, this.thisCompilation);
+    compiler.hooks.done.tapPromise(this.tapPreOptions, this.done.bind(this));
+  }
+  ensureAssetContent(name) {
+    const asset = this.map.get(name);
+    if (asset)
+      return asset;
+    const v = { content: "" };
+    this.map.set(name, v);
+    return v;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalBundlePlugin
+});

package/dist/plugins/resolver.d.ts

@@ -0,0 +1,37 @@
+import { InternalBasePlugin } from '@rsdoctor/core/plugins';
+import { DoctorWebpackSDK } from '@rsdoctor/sdk';
+import { SDK } from '@rsdoctor/types';
+import type { Compiler, ResolvePluginInstance, Resolver } from 'webpack';
+interface DoctorResolverPluginOptions {}
+interface ResolveRequestContext {
+  issuer: string;
+}
+interface ResolveRequestWithContext {
+  [key: string]: unknown;
+  context: ResolveRequestContext;
+}
+export declare class DoctorResolverPlugin implements ResolvePluginInstance {
+  protected options: DoctorResolverPluginOptions;
+  protected sdk: DoctorWebpackSDK;
+  protected tapOptions: {
+    name: string;
+  };
+  protected contextMap: Map<string, [number, [number, number]]>;
+  constructor(options: DoctorResolverPluginOptions, sdk: DoctorWebpackSDK);
+  protected getResolverData(context: ResolveRequestContext, params: {
+    request: string;
+    query?: string;
+    result?: string;
+    error?: Error;
+    stacks?: SDK.ResolveStackData[];
+  }): SDK.PathResolverData | undefined;
+  protected getResolveStackData(request: ResolveRequestWithContext, path: string, name?: string): SDK.ResolveStackData;
+  protected getResolveRequest(request: string | undefined, ctx?: Parameters<Resolver['resolve']>[3]): string;
+  apply(resolver: Resolver): void;
+}
+export declare class InternalResolverPlugin extends InternalBasePlugin<Compiler> {
+  readonly name = "resolver";
+  apply(compiler: Compiler): void;
+  afterPlugins: (compiler: Compiler) => void;
+}
+export {};

package/dist/plugins/resolver.js

@@ -0,0 +1,177 @@
+"use strict";
+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);
+var resolver_exports = {};
+__export(resolver_exports, {
+  DoctorResolverPlugin: () => DoctorResolverPlugin,
+  InternalResolverPlugin: () => InternalResolverPlugin
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_plugins = require("@rsdoctor/core/plugins");
+var import_types = require("@rsdoctor/types");
+var import_common = require("@rsdoctor/utils/common");
+var import_path = __toESM(require("path"));
+class DoctorResolverPlugin {
+  constructor(options, sdk) {
+    this.options = options;
+    this.sdk = sdk;
+    this.tapOptions = {
+      name: "DoctorResolverPlugin"
+    };
+    this.contextMap = /* @__PURE__ */ new Map();
+  }
+  getResolverData(context, params) {
+    const ctx = this.contextMap.get(context.issuer);
+    if (!ctx)
+      return;
+    const { request, query, result, error, stacks } = params;
+    const [start, startHRTime] = ctx;
+    const data = {
+      isEntry: Boolean(context.issuer),
+      issuerPath: context.issuer || "",
+      request,
+      startAt: start,
+      endAt: import_common.Time.getCurrentTimestamp(start, startHRTime),
+      pid: process.pid,
+      ppid: process.ppid
+    };
+    if (query) {
+      data.query = query;
+    }
+    if (result) {
+      data.result = result;
+    }
+    if (error) {
+      data.error = error;
+      data.stacks = stacks || [];
+    }
+    return data;
+  }
+  getResolveStackData(request, path2, name = "anonymous") {
+    const data = {
+      name,
+      // issuerPath: request.context.issuer,
+      path: path2
+    };
+    const keys = [
+      "request",
+      "query",
+      "fragment",
+      "file",
+      "module",
+      "directory",
+      "internal"
+    ];
+    keys.forEach((key) => {
+      if (request[key]) {
+        data[key] = request[key];
+      }
+    });
+    return data;
+  }
+  getResolveRequest(request, ctx) {
+    if (request)
+      return request;
+    if (ctx && ctx.stack) {
+      const [target] = [...ctx.stack].map((e) => e.split(" ").map((e2) => e2.trim())).filter((e) => e.length > 2);
+      if (target) {
+        return target[target.length - 1];
+      }
+    }
+    return "";
+  }
+  apply(resolver) {
+    resolver.hooks.result.tap(this.tapOptions, (request, rsctx) => {
+      const { context } = request;
+      const ctx = this.contextMap.get(context.issuer);
+      if (ctx) {
+        const data = this.getResolverData(context, {
+          request: this.getResolveRequest(request.request, rsctx),
+          query: request.query,
+          result: request.path
+        });
+        data && this.sdk.reportResolver([data]);
+      }
+    });
+    resolver.hooks.noResolve.tap(this.tapOptions, (request, error) => {
+      const { context } = request;
+      if (context.issuer) {
+        const resolvedPaths = new Set(
+          error.details.split("\n").map((e) => e.trim().split(" ")[0]).filter((e) => import_path.default.isAbsolute(e))
+        );
+        if (resolvedPaths.size) {
+          if (this.contextMap.has(context.issuer)) {
+            const stacks = [...resolvedPaths].map(
+              (e) => this.getResolveStackData(
+                request,
+                e,
+                "noResolve"
+              )
+            );
+            const data = this.getResolverData(context, {
+              request: this.getResolveRequest(request.request),
+              query: request.query,
+              error,
+              stacks
+            });
+            data && this.sdk.reportResolver([data]);
+          }
+        }
+      }
+    });
+    resolver.hooks.resolveStep.tap(this.tapOptions, (_, request) => {
+      const { context } = request;
+      if (context.issuer && !this.contextMap.has(context.issuer)) {
+        this.contextMap.set(context.issuer, [Date.now(), process.hrtime()]);
+      }
+    });
+  }
+}
+class InternalResolverPlugin extends import_plugins.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "resolver";
+    this.afterPlugins = (compiler) => {
+      if (compiler.isChild())
+        return;
+      compiler.options.resolve.plugins = (compiler.options.resolve.plugins ?? []).concat(new DoctorResolverPlugin({}, this.sdk));
+      this.sdk.addClientRoutes([
+        import_types.Manifest.DoctorManifestClientRoutes.ModuleResolve
+      ]);
+    };
+  }
+  apply(compiler) {
+    this.scheduler.ensureModulesChunksGraphApplied(compiler);
+    compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DoctorResolverPlugin,
+  InternalResolverPlugin
+});

package/dist/plugins/rules.d.ts

@@ -0,0 +1,8 @@
+import { InternalBasePlugin } from '@rsdoctor/core/plugins';
+import type { Compilation, Compiler, Stats } from 'webpack';
+export declare class InternalRulesPlugin extends InternalBasePlugin<Compiler> {
+  readonly name = "rules";
+  apply(compiler: Compiler): void;
+  done: (stats: Stats) => Promise<void>;
+  protected lint(compilation: Compilation): Promise<void>;
+}

package/dist/plugins/rules.js

@@ -0,0 +1,85 @@
+"use strict";
+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);
+var rules_exports = {};
+__export(rules_exports, {
+  InternalRulesPlugin: () => InternalRulesPlugin
+});
+module.exports = __toCommonJS(rules_exports);
+var import_plugins = require("@rsdoctor/core/plugins");
+var import_rules = require("@rsdoctor/core/rules");
+var import_error = require("@rsdoctor/utils/error");
+var import_lodash = require("lodash");
+class InternalRulesPlugin extends import_plugins.InternalBasePlugin {
+  constructor() {
+    super(...arguments);
+    this.name = "rules";
+    this.done = async (stats) => {
+      await this.lint(stats.compilation);
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
+  }
+  async lint(compilation) {
+    const options = this.options ?? {};
+    const linter = new import_rules.Linter(options.linter);
+    const result = await linter.validate(this.sdk.getRuleContext({}));
+    const validateErrors = result.errors.map(
+      (err) => import_error.DevToolError.from(err, {
+        detail: err.detail,
+        controller: {
+          noColor: true
+        }
+      })
+    );
+    const errors = validateErrors.filter((item) => item.level === "Error");
+    const warnings = validateErrors.filter((item) => item.level === "Warn");
+    const toWebpackError = (err) => err.toError();
+    result.replace.forEach((item) => {
+      if ((0, import_lodash.isArray)(compilation.errors) && compilation.errors.includes(item)) {
+        (0, import_lodash.pull)(compilation.errors, item);
+      }
+      if ((0, import_lodash.isArray)(compilation.warnings) && compilation.warnings.includes(item)) {
+        (0, import_lodash.pull)(compilation.warnings, item);
+      }
+    });
+    if ((0, import_lodash.isArray)(compilation.errors)) {
+      errors.forEach((err) => {
+        compilation.warnings.push(toWebpackError(err));
+      });
+    }
+    if ((0, import_lodash.isArray)(compilation.warnings)) {
+      warnings.forEach((err) => {
+        compilation.warnings.push(toWebpackError(err));
+      });
+    }
+    this.sdk.reportError(validateErrors);
+    await linter.afterValidate({
+      data: this.sdk.getRuleContext({}),
+      validateResult: result,
+      hooks: {
+        afterSaveManifest: this.sdk.hooks.afterSaveManifest
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalRulesPlugin
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rsdoctor/webpack-plugin",
+  "version": "0.0.2-beta.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-infra-dev/rsdoctor",
+    "directory": "packages/webpack-plugin"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "fs-extra": "^11.1.1",
+    "lodash": "^4.17.21",
+    "webpack": "^5.89.0",
+    "@rsdoctor/core": "0.0.2-beta.0",
+    "@rsdoctor/sdk": "0.0.2-beta.0",
+    "@rsdoctor/graph": "0.0.2-beta.0",
+    "@rsdoctor/utils": "0.0.2-beta.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.2",
+    "@types/lodash": "^4.14.200",
+    "@types/node": "^16",
+    "@types/tapable": "2.2.2",
+    "@types/webpack": "5.28.0",
+    "tslib": "2.4.1",
+    "typescript": "^5.2.2",
+    "@rsdoctor/types": "0.0.2-beta.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev": "npm run start",
+    "build": "modern build",
+    "start": "modern build -w",
+    "test": "vitest run"
+  }
+}