@rsdoctor/rspack-plugin 0.0.2-beta.1 → 0.1.0-beta

package/dist/builtinLoaderPlugin.d.ts

@@ -0,0 +1,4 @@
+import { Compiler } from "@rspack/core";
+export declare class BuiltinLoaderPlugin {
+  apply(compiler: Compiler): void;
+}

package/dist/builtinLoaderPlugin.js

@@ -0,0 +1,63 @@
+"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 builtinLoaderPlugin_exports = {};
+__export(builtinLoaderPlugin_exports, {
+  BuiltinLoaderPlugin: () => BuiltinLoaderPlugin
+});
+module.exports = __toCommonJS(builtinLoaderPlugin_exports);
+var import_path = __toESM(require("path"));
+const BuiltinLoaderName = "builtin:swc-loader";
+class BuiltinLoaderPlugin {
+  apply(compiler) {
+    compiler.hooks.beforeRun.tap(
+      {
+        name: `CustomLoaderPlugin`
+      },
+      () => {
+        const rules = compiler.options.module.rules;
+        rules.forEach((rule) => {
+          if (rule && typeof rule === "object" && Array.isArray(rule.use)) {
+            const _builtinLoaderRuleIndex = rule.use.findIndex((use) => typeof use === "object" && use.loader.includes(BuiltinLoaderName));
+            if (_builtinLoaderRuleIndex !== -1) {
+              const _builtinLoaderRule = rule.use[_builtinLoaderRuleIndex];
+              const options = typeof _builtinLoaderRule === "string" ? { type: "start" } : { ..._builtinLoaderRule, type: "start" };
+              rule.use.splice(_builtinLoaderRuleIndex, 0, { loader: import_path.default.join(__dirname, "./probeLoader.js"), options: { ...options, type: "end" } });
+              rule.use.splice(_builtinLoaderRuleIndex + 2, 0, { loader: import_path.default.join(__dirname, "./probeLoader.js"), options });
+            }
+          }
+        });
+        compiler.options.module.rules = rules;
+      }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuiltinLoaderPlugin
+});

package/dist/plugin.d.ts

@@ -1,17 +1,24 @@
 import { Compiler } from '@rspack/core';
 import { ModuleGraph } from '@rsdoctor/graph';
-import { DoctorWebpackSDK } from '@rsdoctor/sdk';
-import type { DoctorPluginInstance, DoctorPluginOptionsNormalized, DoctorRspackPluginOptions } from '@rsdoctor/core/types';
+import { RsdoctorWebpackSDK } from '@rsdoctor/sdk';
+import type { RsdoctorPluginInstance, RsdoctorPluginOptionsNormalized, RsdoctorRspackPluginOptions } from '@rsdoctor/core/types';
 import { Linter } from '@rsdoctor/types';
-export declare class RsdoctorRspackPlugin<Rules extends Linter.ExtendRuleData[]> implements DoctorPluginInstance<Compiler, Rules> {
+export declare class RsdoctorRspackPlugin<Rules extends Linter.ExtendRuleData[]> implements RsdoctorPluginInstance<Compiler, Rules> {
   readonly name = "RsdoctorRspackPlugin";
-  readonly sdk: DoctorWebpackSDK;
+  readonly sdk: RsdoctorWebpackSDK;
   _bootstrapTask: Promise<unknown>;
   protected browserIsOpened: boolean;
   modulesGraph: ModuleGraph;
-  options: DoctorPluginOptionsNormalized<Rules>;
-  constructor(options?: DoctorRspackPluginOptions<Rules>);
+  options: RsdoctorPluginOptionsNormalized<Rules>;
+  constructor(options?: RsdoctorRspackPluginOptions<Rules>);
   apply(compiler: unknown): unknown;
+  /**
+   * @description Generate ModuleGraph and ChunkGraph from stats and webpack module apis;
+   * @param {Compiler} compiler
+   * @return {*}
+   * @memberof RsdoctorWebpackPlugin
+   */
+  ensureModulesChunksGraphApplied(compiler: Compiler): void;
   done: (compiler: Compiler) => Promise<void>;
-  ensureModulesChunksGraphApplied(): void;
+  getRspackConfig(compiler: Compiler, version: string): void;
 }

package/dist/plugin.js

@@ -31,41 +31,36 @@ __export(plugin_exports, {
   RsdoctorRspackPlugin: () => RsdoctorRspackPlugin
 });
 module.exports = __toCommonJS(plugin_exports);
-var import_fs = __toESM(require("fs"));
 var import_graph = require("@rsdoctor/graph");
 var import_sdk = require("@rsdoctor/sdk");
-var import_build_utils = require("@rsdoctor/core/build-utils");
 var import_plugins = require("@rsdoctor/core/plugins");
 var import_types = require("@rsdoctor/types");
 var import_path = __toESM(require("path"));
-var import_common_utils = require("@rsdoctor/core/common-utils");
 var import_constants = require("./constants");
+var import_lodash = require("lodash");
+var import_builtinLoaderPlugin = require("./builtinLoaderPlugin");
 class RsdoctorRspackPlugin {
   constructor(options) {
     this.name = import_constants.pluginTapName;
     this.browserIsOpened = false;
     this.done = async (compiler) => {
-      const json = compiler.compilation.getStats().toJson();
-      const { chunkGraph, moduleGraph } = await import_common_utils.TransUtils.transStats(json);
+      const json = compiler.compilation.getStats().toJson({
+        all: false,
+        version: true,
+        chunks: true,
+        modules: true,
+        chunkModules: true,
+        assets: true,
+        builtAt: true,
+        chunkRelations: true
+      });
+      this.getRspackConfig(compiler, json.rspackVersion || "");
       await this.sdk.bootstrap();
-      this.sdk.reportChunkGraph(chunkGraph);
-      this.sdk.reportModuleGraph(moduleGraph);
       this.sdk.addClientRoutes([
-        import_types.Manifest.DoctorManifestClientRoutes.Overall,
-        import_types.Manifest.DoctorManifestClientRoutes.BundleSize,
-        import_types.Manifest.DoctorManifestClientRoutes.ModuleGraph
+        import_types.Manifest.RsdoctorManifestClientRoutes.Overall
       ]);
-      const reportFilePath = await import_build_utils.Chunks.generateTileGraph(
-        json,
-        {
-          reportFilename: import_build_utils.Chunks.TileGraphReportName,
-          reportTitle: "webpack-bundle-analyzer"
-        },
-        compiler.outputPath
-      );
-      reportFilePath && await this.sdk.reportTileHtml(import_fs.default.readFileSync(reportFilePath, "utf-8"));
       this.sdk.setOutputDir(
-        import_path.default.resolve(compiler.outputPath, `./${import_types.Constants.DoctorOutputFolder}`)
+        import_path.default.resolve(compiler.outputPath, `./${import_types.Constants.RsdoctorOutputFolder}`)
       );
       await this.sdk.writeStore();
       if (!this.options.disableClientServer) {
@@ -76,7 +71,7 @@ class RsdoctorRspackPlugin {
       }
     };
     this.options = (0, import_plugins.normalizeUserConfig)(options);
-    this.sdk = new import_sdk.DoctorWebpackSDK({
+    this.sdk = new import_sdk.RsdoctorWebpackSDK({
       name: import_constants.pluginTapName,
       root: process.cwd(),
       type: import_types.SDK.ToDataType.Normal,
@@ -103,8 +98,43 @@ class RsdoctorRspackPlugin {
     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.InternalRulesPlugin(this).apply(compiler);
+    new import_builtinLoaderPlugin.BuiltinLoaderPlugin().apply(compiler);
   }
-  ensureModulesChunksGraphApplied() {
+  /**
+   * @description Generate ModuleGraph and ChunkGraph from stats and webpack module apis;
+   * @param {Compiler} compiler
+   * @return {*}
+   * @memberof RsdoctorWebpackPlugin
+   */
+  ensureModulesChunksGraphApplied(compiler) {
+    (0, import_plugins.ensureModulesChunksGraphFn)(compiler, this);
+  }
+  getRspackConfig(compiler, version) {
+    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: "rspack",
+      version: version || "unknown",
+      config: configuration
+    });
+    this.sdk.setOutputDir(
+      import_path.default.resolve(compiler.outputPath, `./${import_types.Constants.RsdoctorOutputFolder}`)
+    );
+    if (configuration.name) {
+      this.sdk.setName(configuration.name);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/probeLoader.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+import { LoaderDefinitionFunction } from "@rspack/core";
+declare const loaderModule: Plugin.LoaderDefinition<Parameters<LoaderDefinitionFunction>, {}>;
+export default loaderModule;

package/dist/probeLoader.js

@@ -0,0 +1,71 @@
+"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 probeLoader_exports = {};
+__export(probeLoader_exports, {
+  default: () => probeLoader_default
+});
+module.exports = __toCommonJS(probeLoader_exports);
+var import_plugins = require("@rsdoctor/core/plugins");
+var import_loader_utils = require("loader-utils");
+var import_lodash = require("lodash");
+var import_path = __toESM(require("path"));
+const loaderModule = function(...args) {
+  const time = Date.now();
+  const code = args[0];
+  const sdk = (0, import_plugins.getSDK)();
+  const _options = this.getOptions();
+  const loaderData = {
+    resource: {
+      path: this.resourcePath,
+      query: (0, import_loader_utils.parseQuery)(this.resourceQuery || "?"),
+      queryRaw: this.resourceQuery,
+      ext: import_path.default.extname(this.resourcePath).slice(1)
+    },
+    loaders: [
+      {
+        loader: _options.loader,
+        loaderIndex: this.loaderIndex,
+        path: _options.loader,
+        input: _options.type === "start" ? code : null,
+        result: _options.type === "end" ? code : null,
+        startAt: _options.type === "start" ? time : 0,
+        endAt: _options.type === "end" ? time : 0,
+        options: (0, import_lodash.omit)(_options.options, "type"),
+        isPitch: false,
+        sync: false,
+        errors: [],
+        pid: process.pid,
+        ppid: process.ppid
+      }
+    ]
+  };
+  sdk.reportLoaderStartOrEnd(loaderData);
+  this.callback(null, ...args);
+};
+var probeLoader_default = loaderModule;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import type { RspackPluginInstance } from '@rspack/core';
-import type { DoctorWebpackPluginOptions } from '@rsdoctor/core/types';
-export interface DoctorRspackPluginOptions {
+import type { RsdoctorWebpackPluginOptions } from '@rsdoctor/core/types';
+export interface RsdoctorRspackPluginOptions {
   /**
    * turn on it if you don't need to see profile in browser.
    * @default false
@@ -9,12 +9,12 @@ export interface DoctorRspackPluginOptions {
   /**
    * the switch for the Rsdoctor features.
    */
-  features?: DoctorWebpackPluginOptions<[]>['features'];
+  features?: RsdoctorWebpackPluginOptions<[]>['features'];
   /**
    * configuration of the interceptor for webpack loaders.
    * @description worked when the `features.loader === true`.
    */
-  loaderInterceptorOptions?: DoctorWebpackPluginOptions<[]>['loaderInterceptorOptions'];
+  loaderInterceptorOptions?: RsdoctorWebpackPluginOptions<[]>['loaderInterceptorOptions'];
 }
 export interface RsdoctorRspackPluginInstance extends RspackPluginInstance {
   readonly name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/rspack-plugin",
-  "version": "0.0.2-beta.1",
+  "version": "0.1.0-beta",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -13,19 +13,21 @@
     "dist"
   ],
   "dependencies": {
-    "@rspack/core": "0.3.14",
+    "@rspack/core": "0.5.1",
+    "loader-utils": "^2.0.4",
     "lodash": "^4.17.21",
-    "@rsdoctor/sdk": "0.0.2-beta.1",
-    "@rsdoctor/core": "0.0.2-beta.1",
-    "@rsdoctor/graph": "0.0.2-beta.1"
+    "@rsdoctor/core": "0.1.0-beta",
+    "@rsdoctor/graph": "0.1.0-beta",
+    "@rsdoctor/sdk": "0.1.0-beta"
   },
   "devDependencies": {
+    "@types/loader-utils": "^2.0.5",
     "@types/lodash": "^4.14.200",
     "@types/node": "^16",
     "@types/tapable": "2.2.2",
     "tslib": "2.4.1",
     "typescript": "^5.2.2",
-    "@rsdoctor/types": "0.0.2-beta.1"
+    "@rsdoctor/types": "0.1.0-beta"
   },
   "publishConfig": {
     "access": "public",