@rsdoctor/webpack-plugin 0.0.0-next-20240620044732

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,42 @@
+# Rsdoctor plugin
+
+This Rsdoctor plugin is an analysis plugin for the Webpack builder.
+
+## features
+
+- Rsdoctor is a one-stop tool for diagnosing and analyzing the build process and build artifacts.
+- Rsdoctor is a tool that supports Webpack and Rspack build analysis.
+- Rsdoctor is an analysis tool that can display the time-consuming and behavioral details of the compilation.
+- Rsdoctor is a tool that provides bundle Diff and other anti-degradation capabilities simultaneously.
+
+## Note
+
+This plugin is used by the `Webpack` repo to open Rsdoctor, [Quik Start](https://rsdoctor.dev/guide/start/quick-start).
+
+Initialize the RsdoctorWebpackPlugin plugin in the [plugins](https://webpack.js.org/configuration/plugins/#plugins) section of the `webpack.config.js` file, as shown below:
+
+```js title="webpack.config.js"
+const { RsdoctorWebpackPlugin } = require('@rsdoctor/webpack-plugin');
+
+module.exports = {
+  // ...
+  plugins: [
+    process.env.RSDOCTOR &&
+      new RsdoctorWebpackPlugin({
+        // options
+      }),
+  ].filter(Boolean),
+};
+```
+
+## Documentation
+
+https://rsdoctor.dev/
+
+## 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,7 @@
+import type { Tap } from 'tapable';
+export declare const pluginTapName = "RsdoctorWebpackPlugin";
+export declare const pluginTapPostOptions: Tap;
+export declare const pluginTapPreOptions: Tap;
+export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
+export declare const internalPluginTapPostOptions: (namespace: string) => Tap;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAEnC,eAAO,MAAM,aAAa,0BAA0B,CAAC;AAErD,eAAO,MAAM,oBAAoB,EAAE,GAGlC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,GAGjC,CAAC;AAEF,eAAO,MAAM,2BAA2B,cAAe,MAAM,KAAG,GAG9D,CAAC;AAEH,eAAO,MAAM,4BAA4B,cAAe,MAAM,KAAG,GAG/D,CAAC"}

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 = "RsdoctorWebpackPlugin";
+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 { defineRule, LinterType } from '@rsdoctor/core/rules';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAE3B,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,35 @@
+"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);
+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")
+});

package/dist/multiple.d.ts

@@ -0,0 +1,8 @@
+import type { Linter } from '@rsdoctor/types';
+import type { RsdoctorMultiplePluginOptions } from '@rsdoctor/core';
+import { RsdoctorWebpackPlugin } from './plugin';
+export declare class RsdoctorWebpackMultiplePlugin<Rules extends Linter.ExtendRuleData[]> extends RsdoctorWebpackPlugin<Rules> {
+    private controller;
+    constructor(options?: RsdoctorMultiplePluginOptions<Rules>);
+}
+//# sourceMappingURL=multiple.d.ts.map

package/dist/multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple.d.ts","sourceRoot":"","sources":["../src/multiple.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAIjD,qBAAa,6BAA6B,CACxC,KAAK,SAAS,MAAM,CAAC,cAAc,EAAE,CACrC,SAAQ,qBAAqB,CAAC,KAAK,CAAC;IAEpC,OAAO,CAAC,UAAU,CAAwB;gBAE9B,OAAO,GAAE,6BAA6B,CAAC,KAAK,CAAM;CAuB/D"}

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.RsdoctorSDKController();
+      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,28 @@
+import type { RsdoctorPluginInstance, RsdoctorPluginOptionsNormalized, RsdoctorWebpackPluginOptions } from '@rsdoctor/core/types';
+import { ChunkGraph, ModuleGraph } from '@rsdoctor/graph';
+import { RsdoctorWebpackSDK } from '@rsdoctor/sdk';
+import { Linter } from '@rsdoctor/types';
+import type { Compiler } from 'webpack';
+export declare class RsdoctorWebpackPlugin<Rules extends Linter.ExtendRuleData[]> implements RsdoctorPluginInstance<Compiler, Rules> {
+    readonly name = "RsdoctorWebpackPlugin";
+    readonly options: RsdoctorPluginOptionsNormalized<Rules>;
+    readonly sdk: RsdoctorWebpackSDK;
+    modulesGraph: ModuleGraph;
+    private outsideInstance;
+    _bootstrapTask: Promise<unknown>;
+    protected browserIsOpened: boolean;
+    chunkGraph: ChunkGraph;
+    constructor(options?: RsdoctorWebpackPluginOptions<Rules>);
+    apply(compiler: unknown): unknown;
+    afterPlugins: (compiler: Compiler) => void;
+    beforeRun: (compiler: Compiler) => Promise<void>;
+    /**
+     * @description Generate ModuleGraph and ChunkGraph from stats and webpack module apis;
+     * @param {Compiler} compiler
+     * @return {*}
+     * @memberof RsdoctorWebpackPlugin
+     */
+    ensureModulesChunksGraphApplied(compiler: Compiler): void;
+    done: () => Promise<void>;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,sBAAsB,EACtB,+BAA+B,EAC/B,4BAA4B,EAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAa,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAKpD,OAAO,KAAK,EAAE,QAAQ,EAA8B,MAAM,SAAS,CAAC;AAOpE,qBAAa,qBAAqB,CAAC,KAAK,SAAS,MAAM,CAAC,cAAc,EAAE,CACtE,YAAW,sBAAsB,CAAC,QAAQ,EAAE,KAAK,CAAC;IAElD,SAAgB,IAAI,2BAAiB;IAErC,SAAgB,OAAO,EAAE,+BAA+B,CAAC,KAAK,CAAC,CAAC;IAEhE,SAAgB,GAAG,EAAE,kBAAkB,CAAC;IAEjC,YAAY,EAAE,WAAW,CAAC;IAEjC,OAAO,CAAC,eAAe,CAAS;IAEzB,cAAc,EAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEzC,SAAS,CAAC,eAAe,UAAS;IAE3B,UAAU,EAAE,UAAU,CAAC;gBAElB,OAAO,CAAC,EAAE,4BAA4B,CAAC,KAAK,CAAC;IAkBzD,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO;IAuD1B,YAAY,aAAc,QAAQ,KAAG,IAAI,CAiC9C;IAEK,SAAS,aAAoB,QAAQ,KAAG,QAAQ,IAAI,CAAC,CAS1D;IAEF;;;;;OAKG;IACI,+BAA+B,CAAC,QAAQ,EAAE,QAAQ;IAIlD,IAAI,QAAa,QAAQ,IAAI,CAAC,CAYnC;CACH"}

package/dist/plugin.js

@@ -0,0 +1,160 @@
+"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_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_lodash = require("lodash");
+var import_path = __toESM(require("path"));
+var import_constants = require("./constants");
+var import_resolver = require("./plugins/resolver");
+var import_plugins2 = require("@rsdoctor/core/plugins");
+var import_common = require("@rsdoctor/utils/common");
+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)
+      };
+      const rspackVersion = compiler.webpack?.rspackVersion;
+      const webpackVersion = compiler.webpack?.version;
+      this.sdk.reportConfiguration({
+        name: rspackVersion ? "rspack" : "webpack",
+        version: rspackVersion || webpackVersion || "unknown",
+        config: configuration
+      });
+      this.sdk.setOutputDir(
+        import_path.default.resolve(compiler.outputPath, `./${import_types.Constants.RsdoctorOutputFolder}`)
+      );
+      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.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.RsdoctorWebpackSDK({
+      port: this.options.port,
+      name: import_constants.pluginTapName,
+      root: process.cwd(),
+      type: this.options.reportCodeType,
+      config: { disableTOSUpload: this.options.disableTOSUpload },
+      innerClientPath: this.options.innerClientPath
+    });
+    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 && !import_common.Loader.isVue(compiler)) {
+      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_plugins.InternalBundlePlugin(this).apply(compiler);
+      new import_plugins.InternalBundleTagPlugin(this).apply(compiler);
+    }
+    new import_plugins.InternalErrorReporterPlugin(this).apply(compiler);
+    new import_plugins.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 RsdoctorWebpackPlugin
+   */
+  ensureModulesChunksGraphApplied(compiler) {
+    (0, import_plugins2.ensureModulesChunksGraphFn)(compiler, this);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsdoctorWebpackPlugin
+});

package/dist/plugins/resolver.d.ts

@@ -0,0 +1,39 @@
+import { InternalBasePlugin } from '@rsdoctor/core/plugins';
+import { RsdoctorWebpackSDK } from '@rsdoctor/sdk';
+import { SDK } from '@rsdoctor/types';
+import type { Compiler, ResolvePluginInstance, Resolver } from 'webpack';
+interface RsdoctorResolverPluginOptions {
+}
+interface ResolveRequestContext {
+    issuer: string;
+}
+interface ResolveRequestWithContext {
+    [key: string]: unknown;
+    context: ResolveRequestContext;
+}
+export declare class RsdoctorResolverPlugin implements ResolvePluginInstance {
+    protected options: RsdoctorResolverPluginOptions;
+    protected sdk: RsdoctorWebpackSDK;
+    protected tapOptions: {
+        name: string;
+    };
+    protected contextMap: Map<string, [number, [number, number]]>;
+    constructor(options: RsdoctorResolverPluginOptions, sdk: RsdoctorWebpackSDK);
+    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 {};
+//# sourceMappingURL=resolver.d.ts.map

package/dist/plugins/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/plugins/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAY,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzE,UAAU,6BAA6B;CAAG;AAE1C,UAAU,qBAAqB;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,yBAAyB;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,qBAAqB,CAAC;CAChC;AAED,qBAAa,sBAAuB,YAAW,qBAAqB;IAQhE,SAAS,CAAC,OAAO,EAAE,6BAA6B;IAChD,SAAS,CAAC,GAAG,EAAE,kBAAkB;IARnC,SAAS,CAAC,UAAU;;MAElB;IAEF,SAAS,CAAC,UAAU,0CAAiD;gBAGzD,OAAO,EAAE,6BAA6B,EACtC,GAAG,EAAE,kBAAkB;IAGnC,SAAS,CAAC,eAAe,CACvB,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,GAAG,CAAC,gBAAgB,EAAE,CAAC;KACjC;IAiCH,SAAS,CAAC,mBAAmB,CAC3B,OAAO,EAAE,yBAAyB,EAClC,IAAI,EAAE,MAAM,EACZ,IAAI,SAAc;IA2BpB,SAAS,CAAC,iBAAiB,CACzB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,GAAG,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAwB1C,KAAK,CAAC,QAAQ,EAAE,QAAQ;CA4DzB;AAED,qBAAa,sBAAuB,SAAQ,kBAAkB,CAAC,QAAQ,CAAC;IACtE,SAAgB,IAAI,cAAc;IAE3B,KAAK,CAAC,QAAQ,EAAE,QAAQ;IAMxB,YAAY,aAAc,QAAQ,UAYvC;CACH"}

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, {
+  InternalResolverPlugin: () => InternalResolverPlugin,
+  RsdoctorResolverPlugin: () => RsdoctorResolverPlugin
+});
+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 RsdoctorResolverPlugin {
+  constructor(options, sdk) {
+    this.options = options;
+    this.sdk = sdk;
+    this.tapOptions = {
+      name: "RsdoctorResolverPlugin"
+    };
+    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?.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 RsdoctorResolverPlugin({}, this.sdk));
+      this.sdk.addClientRoutes([
+        import_types.Manifest.RsdoctorManifestClientRoutes.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 = {
+  InternalResolverPlugin,
+  RsdoctorResolverPlugin
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@rsdoctor/webpack-plugin",
+  "version": "0.0.0-next-20240620044732",
+  "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",
+    "@rsdoctor/core": "0.0.0-next-20240620044732",
+    "@rsdoctor/sdk": "0.0.0-next-20240620044732",
+    "@rsdoctor/utils": "0.0.0-next-20240620044732",
+    "@rsdoctor/graph": "0.0.0-next-20240620044732",
+    "@rsdoctor/types": "0.0.0-next-20240620044732"
+  },
+  "devDependencies": {
+    "webpack": "^5.89.0",
+    "@types/fs-extra": "^11.0.2",
+    "@types/lodash": "^4.17.0",
+    "@types/node": "^16",
+    "@types/tapable": "2.2.2",
+    "@types/webpack": "5.28.0",
+    "tslib": "2.4.1",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "webpack": "5.x"
+  },
+  "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"
+  }
+}