@rsdoctor/rspack-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,7 @@
+import type { Tap } from 'tapable';
+export declare const pluginTapName = "RsdoctorRspackPlugin";
+export declare const pluginTapPostOptions: Tap;
+export declare const pluginTapPreOptions: Tap;
+export declare const internalPluginTapPreOptions: (namespace: string) => Tap;
+export declare const internalPluginTapPostOptions: (namespace: string) => Tap;
+export declare const pkg: any;

package/dist/constants.js

@@ -0,0 +1,55 @@
+"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,
+  pkg: () => pkg,
+  pluginTapName: () => pluginTapName,
+  pluginTapPostOptions: () => pluginTapPostOptions,
+  pluginTapPreOptions: () => pluginTapPreOptions
+});
+module.exports = __toCommonJS(constants_exports);
+const pluginTapName = "RsdoctorRspackPlugin";
+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
+});
+const pkg = require("../package.json");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  internalPluginTapPostOptions,
+  internalPluginTapPreOptions,
+  pkg,
+  pluginTapName,
+  pluginTapPostOptions,
+  pluginTapPreOptions
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './plugin';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugin")
+});

package/dist/plugin.d.ts

@@ -0,0 +1,17 @@
+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 { Linter } from '@rsdoctor/types';
+export declare class RsdoctorRspackPlugin<Rules extends Linter.ExtendRuleData[]> implements DoctorPluginInstance<Compiler, Rules> {
+  readonly name = "RsdoctorRspackPlugin";
+  readonly sdk: DoctorWebpackSDK;
+  _bootstrapTask: Promise<unknown>;
+  protected browserIsOpened: boolean;
+  modulesGraph: ModuleGraph;
+  options: DoctorPluginOptionsNormalized<Rules>;
+  constructor(options?: DoctorRspackPluginOptions<Rules>);
+  apply(compiler: unknown): unknown;
+  done: (compiler: Compiler) => Promise<void>;
+  ensureModulesChunksGraphApplied(): void;
+}

package/dist/plugin.js

@@ -0,0 +1,113 @@
+"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, {
+  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");
+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);
+      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
+      ]);
+      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}`)
+      );
+      await this.sdk.writeStore();
+      if (!this.options.disableClientServer) {
+        await this.sdk.server.openClientPage("homepage");
+      }
+      if (this.options.disableClientServer) {
+        await this.sdk.dispose();
+      }
+    };
+    this.options = (0, import_plugins.normalizeUserConfig)(options);
+    this.sdk = new import_sdk.DoctorWebpackSDK({
+      name: import_constants.pluginTapName,
+      root: process.cwd(),
+      type: import_types.SDK.ToDataType.Normal,
+      config: { disableTOSUpload: this.options.disableTOSUpload }
+    });
+    this.modulesGraph = new import_graph.ModuleGraph();
+  }
+  apply(compiler) {
+    if (!this._bootstrapTask) {
+      this._bootstrapTask = this.sdk.bootstrap();
+    }
+    (0, import_plugins.setSDK)(this.sdk);
+    compiler.hooks.done.tapPromise(
+      {
+        ...import_constants.pluginTapPostOptions,
+        stage: import_constants.pluginTapPostOptions.stage + 100
+      },
+      this.done.bind(this, compiler)
+    );
+    new import_plugins.InternalSummaryPlugin(this).apply(compiler);
+    if (this.options.features.loader) {
+      new import_plugins.InternalLoaderPlugin(this).apply(compiler);
+    }
+    if (this.options.features.plugins) {
+      new import_plugins.InternalPluginsPlugin(this).apply(compiler);
+    }
+  }
+  ensureModulesChunksGraphApplied() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsdoctorRspackPlugin
+});

package/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@rsdoctor/rspack-plugin",
+  "version": "0.0.2-beta.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-infra-dev/rsdoctor",
+    "directory": "packages/rspack-plugin"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@rspack/core": "0.3.14",
+    "lodash": "^4.17.21",
+    "@rsdoctor/sdk": "0.0.2-beta.0",
+    "@rsdoctor/graph": "0.0.2-beta.0",
+    "@rsdoctor/core": "0.0.2-beta.0"
+  },
+  "devDependencies": {
+    "@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.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev": "npm run start",
+    "start": "modern build -w",
+    "build": "modern build",
+    "test": "vitest run"
+  }
+}