@rsdoctor/core 0.1.0-beta → 0.1.1

package/README.md

@@ -1,11 +1,18 @@
-# Rsdoctor
+# Rsdoctor Core
 
-Rsdoctor is a tool for diagnosing and analyzing the build process and build artifacts to help developers quickly identify and solve problems.
+This is the core package of Rsdoctor, providing core tools and analysis capabilities for Rsdoctor plugins.
 
-It also supports Webpack and Rspack builders, as well as various build frameworks, such as Rsbuild.
+## 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.
 
 ## Documentation
 
+https://rsdoctor.dev/
+
 ## Contributing
 
 Please read the [Contributing Guide](https://github.com/web-infra-dev/rsdoctor/blob/main/CONTRIBUTING.md).

package/dist/build-utils/build/utils/loader.d.ts

@@ -1,7 +1,12 @@
 /// <reference types="node" />
 import type { Common, Plugin } from '@rsdoctor/types';
 import { SourceMapInput as WebpackSourceMapInput } from '../../../types';
-export declare function loadLoaderModule(p: string, cwd?: string): {
+export declare function parsePathQueryFragment(str: string): {
+  path: string;
+  query: string;
+  fragment: string;
+};
+export declare function loadLoaderModule(loaderPath: string, cwd?: string): {
   default: Plugin.LoaderDefinition<Common.PlainObject, {}>;
   pitch: Plugin.PitchLoaderDefinitionFunction;
   raw: boolean | void;
@@ -9,4 +14,5 @@ export declare function loadLoaderModule(p: string, cwd?: string): {
 export declare function getLoaderOptions<T>(loaderContext: Plugin.LoaderContext<T>): T;
 export declare function extractLoaderName(loaderPath: string, cwd?: string): string;
 export declare function mapEachRules<T extends Plugin.BuildRuleSetRule>(rules: T[], callback: (rule: T) => T): T[];
+export declare function changeBuiltinLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderName: string, appendRules: (rule: T, index: number) => T): T[];
 export declare function createLoaderContextTrap(this: Plugin.LoaderContext<Common.PlainObject>, final: (err: Error | null | undefined, res: string | Buffer | null, sourceMap?: WebpackSourceMapInput) => void): Plugin.LoaderContext<Common.PlainObject<any>>;

package/dist/build-utils/build/utils/loader.js

@@ -28,19 +28,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loader_exports = {};
 __export(loader_exports, {
+  changeBuiltinLoader: () => changeBuiltinLoader,
   createLoaderContextTrap: () => createLoaderContextTrap,
   extractLoaderName: () => extractLoaderName,
   getLoaderOptions: () => getLoaderOptions,
   loadLoaderModule: () => loadLoaderModule,
-  mapEachRules: () => mapEachRules
+  mapEachRules: () => mapEachRules,
+  parsePathQueryFragment: () => parsePathQueryFragment
 });
 module.exports = __toCommonJS(loader_exports);
 var import_loader_utils = require("loader-utils");
 var import_path = __toESM(require("path"));
 var import_lodash = require("lodash");
 var import_common = require("@rsdoctor/utils/common");
-function loadLoaderModule(p, cwd = process.cwd()) {
-  const mod = process.env.DOCTOR_TEST ? require(import_path.default.resolve(cwd, p)) : require(require.resolve(p, {
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+function parsePathQueryFragment(str) {
+  const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+  return {
+    path: match?.[1].replace(/\0(.)/g, "$1") || "",
+    query: match?.[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+    fragment: match?.[3] || ""
+  };
+}
+function loadLoaderModule(loaderPath, cwd = process.cwd()) {
+  const cleanLoaderPath = parsePathQueryFragment(loaderPath).path;
+  const mod = process.env.DOCTOR_TEST ? require(import_path.default.resolve(cwd, cleanLoaderPath)) : require(require.resolve(cleanLoaderPath, {
     paths: [cwd, import_path.default.resolve(cwd, "node_modules")]
   }));
   const isESM = mod.__esModule && typeof mod.default === "function";
@@ -73,7 +85,7 @@ function extractLoaderName(loaderPath, cwd = "") {
   return res;
 }
 function mapEachRules(rules, callback) {
-  return rules.map((rule, i) => {
+  return rules.map((rule) => {
     if (typeof rule === "string") {
       return callback({
         loader: rule
@@ -104,6 +116,17 @@ function mapEachRules(rules, callback) {
           )
         };
       }
+      if (typeof rule.use === "function") {
+        const funcUse = rule.use;
+        const newRule = {
+          ...rule,
+          use: (...args) => {
+            const rules2 = funcUse.apply(null, args);
+            return mapEachRules(rules2, callback);
+          }
+        };
+        return newRule;
+      }
       if (Array.isArray(rule.use)) {
         return {
           ...rule,
@@ -114,9 +137,6 @@ function mapEachRules(rules, callback) {
         ...rule,
         use: mapEachRules([rule.use], callback)
       };
-      throw new Error(
-        `webpack.module.rules.use[${i}] parse error: ${rule.use}`
-      );
     }
     if ("rules" in rule && Array.isArray(rule.rules)) {
       return {
@@ -133,6 +153,68 @@ function mapEachRules(rules, callback) {
     return rule;
   });
 }
+function getLoaderNameMatch(_r, loaderName) {
+  return typeof _r === "object" && typeof _r?.loader === "string" && _r.loader === loaderName || typeof _r === "string" && _r === loaderName;
+}
+function changeBuiltinLoader(rules, loaderName, appendRules) {
+  return rules.map((rule) => {
+    if (!rule || typeof rule === "string")
+      return rule;
+    if (getLoaderNameMatch(rule, loaderName)) {
+      const _rule = {
+        ...rule,
+        use: [
+          {
+            loader: rule.loader,
+            options: rule.options
+          }
+        ],
+        loader: void 0,
+        options: void 0
+      };
+      return appendRules(_rule, 0);
+    }
+    if (rule.use) {
+      if (Array.isArray(rule.use)) {
+        const _index = (0, import_lodash.findIndex)(
+          rule.use,
+          (_r) => getLoaderNameMatch(_r, loaderName)
+        );
+        if (_index > -1) {
+          return appendRules(rule, _index);
+        }
+      } else if (typeof rule.use === "object" && !Array.isArray(rule.use) && typeof rule.use !== "function") {
+        rule.use = [
+          {
+            ...rule.use
+          }
+        ];
+        return appendRules(rule, 0);
+      }
+    }
+    if ("oneOf" in rule && rule.oneOf) {
+      return {
+        ...rule,
+        oneOf: changeBuiltinLoader(
+          rule.oneOf,
+          loaderName,
+          appendRules
+        )
+      };
+    }
+    if ("rules" in rule && rule.rules) {
+      return {
+        ...rule,
+        rules: changeBuiltinLoader(
+          rule.rules,
+          loaderName,
+          appendRules
+        )
+      };
+    }
+    return rule;
+  });
+}
 function createLoaderContextTrap(final) {
   const cb = this.callback;
   let callback = (...args) => {
@@ -171,7 +253,9 @@ function createLoaderContextTrap(final) {
               if (options.hasOptions) {
                 return (0, import_lodash.omit)(target.query, [import_common.Loader.LoaderInternalPropertyName]);
               }
-              return target.resourceQuery;
+              const innerLoaderPath = options?.loader;
+              const loaderQuery = parsePathQueryFragment(innerLoaderPath).query;
+              return loaderQuery;
             }
           }
           return Reflect.get(target, key, receiver);
@@ -202,9 +286,11 @@ function createLoaderContextTrap(final) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  changeBuiltinLoader,
   createLoaderContextTrap,
   extractLoaderName,
   getLoaderOptions,
   loadLoaderModule,
-  mapEachRules
+  mapEachRules,
+  parsePathQueryFragment
 });

package/dist/build-utils/build/utils/parseBundle.js

@@ -92,7 +92,7 @@ const parseBundle = (bundlePath, modulesData) => {
       if (state.locations)
         return;
       const { left, right } = node;
-      if (left && left.object && left.object.name === "exports" && left.property && left.property.name === "modules" && isModulesHash(right)) {
+      if (left?.object && left.object.name === "exports" && left.property && left.property.name === "modules" && isModulesHash(right)) {
         state.locations = getModulesLocations(right);
       }
     },

package/dist/build-utils/common/chunks/assetsModules.js

@@ -36,7 +36,6 @@ var import_lodash = require("lodash");
 var import_path = __toESM(require("path"));
 var import_logger = require("@rsdoctor/utils/logger");
 var import_module_graph = require("../module-graph");
-const logger = (0, import_logger.createLogger)();
 async function getAssetsModulesData(bundleStats, bundleDir, opts) {
   const { parseBundle = () => ({}) } = opts || {};
   if ((0, import_lodash.isEmpty)(bundleStats.assets) && !(0, import_lodash.isEmpty)(bundleStats.children)) {
@@ -62,7 +61,7 @@ async function getAssetsModulesData(bundleStats, bundleDir, opts) {
   if (bundleDir && bundleStats?.assets) {
     bundlesSources = {};
     parsedModules = {};
-    for (const statAsset of bundleStats?.assets) {
+    for (const statAsset of bundleStats.assets) {
       const assetFile = import_path.default.join(bundleDir, statAsset.name);
       let bundleInfo;
       const collectedModules = [];
@@ -72,7 +71,7 @@ async function getAssetsModulesData(bundleStats, bundleDir, opts) {
       } catch (err) {
         const { code = "", message } = err;
         const msg = code === "ENOENT" ? "no such file" : message;
-        process.env.DEVTOOLS_NODE_DEV === "1" && logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+        process.env.DEVTOOLS_NODE_DEV === "1" && import_logger.logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
         continue;
       }
       bundlesSources[statAsset.name] = (0, import_lodash.pick)(bundleInfo, "src", "runtimeSrc");
@@ -81,7 +80,7 @@ async function getAssetsModulesData(bundleStats, bundleDir, opts) {
     if ((0, import_lodash.isEmpty)(bundlesSources)) {
       bundlesSources = null;
       parsedModules = null;
-      process.env.DEVTOOLS_DEV && logger.warn(
+      process.env.DEVTOOLS_DEV && import_logger.logger.warn(
         "\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n"
       );
     }

package/dist/build-utils/common/webpack/compatible.js

@@ -72,7 +72,7 @@ function getModuleExportsType(module2, moduleGraph, strict = false) {
   if (moduleGraph) {
     return module2.getExportsType(moduleGraph, strict);
   }
-  const exportsType = module2.buildMeta && module2.buildMeta.exportsType;
+  const exportsType = module2.buildMeta?.exportsType;
   if (!exportsType && !strict) {
     return "dynamic";
   }

package/dist/inner-plugins/plugins/bundle.js

@@ -63,7 +63,9 @@ class InternalBundlePlugin extends import_base.InternalBasePlugin {
       }
     };
     this.done = async () => {
-      import_common.Chunks.assetsContents(this.map, this.scheduler.chunkGraph);
+      if (this.scheduler.chunkGraph) {
+        import_common.Chunks.assetsContents(this.map, this.scheduler.chunkGraph);
+      }
       this.sdk.addClientRoutes([
         import_types.Manifest.RsdoctorManifestClientRoutes.ModuleGraph,
         import_types.Manifest.RsdoctorManifestClientRoutes.BundleSize

package/dist/inner-plugins/plugins/loader.js

@@ -128,7 +128,7 @@ class InternalLoaderPlugin extends import_base.InternalBasePlugin {
         return tap;
       }
     };
-    if (compiler.webpack && compiler.webpack.NormalModule && compiler.webpack.NormalModule.getCompilationHooks) {
+    if (compiler.webpack?.NormalModule?.getCompilationHooks) {
       compiler.webpack.NormalModule.getCompilationHooks(
         compilation
       ).loader.intercept(interceptor);

package/dist/inner-plugins/plugins/summary.d.ts

@@ -5,10 +5,10 @@ export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extend
   private times;
   private preTimes;
   private postTimes;
-  apply(compiler: Plugin.BaseCompiler): void;
+  apply(compiler: T): void;
   private mark;
   beforeCompile: () => Promise<void>;
   afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
-  done: (compiler: Plugin.BaseCompiler) => Promise<void>;
+  done: (compiler: T) => Promise<void>;
   private report;
 }

package/dist/inner-plugins/utils/loader.js

@@ -107,7 +107,7 @@ function interceptLoader(rules, loaderPath, options, cwd = process.cwd(), resolv
     return target;
   };
   return import_build.Utils.mapEachRules(rules, (rule) => {
-    if (rule?.loader && rule.loader.startsWith("builtin:")) {
+    if (rule.loader?.startsWith("builtin:")) {
       return rule;
     }
     const opts = {
@@ -171,7 +171,7 @@ async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, r
     file: loaderData[0].resource.path
   };
   const sdk = (0, import_sdk.getSDK)();
-  if (sdk && sdk.reportLoader) {
+  if (sdk?.reportLoader) {
     sdk.reportLoader(loaderData);
     sdk.reportSourceMap(sourceMapData);
     return loaderData;

package/dist/rules/rule.d.ts

@@ -16,7 +16,7 @@ export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta
   get title(): string;
   get severity(): Linter.Severity;
   get config(): Config | undefined;
-  get category(): "bundle" | "compile" | RuleTypes.RuleMessageCategory | "emo";
+  get category(): "bundle" | RuleTypes.RuleMessageCategory | "compile" | "emo";
   setOption(opt: Linter.RuleConfigItem): void;
   match(level: Linter.Severity): boolean;
   validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;

package/dist/types/plugin.d.ts

@@ -1,7 +1,9 @@
 import type { Linter as LinterType, Common, Plugin, SDK } from '@rsdoctor/types';
 import type { RsdoctorSlaveSDK, RsdoctorWebpackSDK } from '@rsdoctor/sdk';
-import { ModuleGraph } from '@rsdoctor/graph';
-type InternalRules = any;
+import { ChunkGraph, ModuleGraph } from '@rsdoctor/graph';
+import { rules } from "../rules/rules";
+import { RuleData } from '@rsdoctor/types/dist/linter';
+type InternalRules = typeof rules[number] & RuleData[];
 export interface RsdoctorWebpackPluginOptions<Rules extends LinterType.ExtendRuleData[]> {
   /** Checker configuration */
   linter?: LinterType.Options<Rules, InternalRules>;
@@ -65,6 +67,8 @@ export interface RsdoctorPluginInstance<T extends Plugin.BaseCompiler, Rules ext
   readonly name: string;
   readonly options: RsdoctorPluginOptionsNormalized<Rules>;
   readonly sdk: RsdoctorWebpackSDK;
+  _modulesGraphApplied?: boolean;
+  chunkGraph?: ChunkGraph;
   modulesGraph: ModuleGraph;
   ensureModulesChunksGraphApplied(compiler: T): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/core",
-  "version": "0.1.0-beta",
+  "version": "0.1.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -51,10 +51,10 @@
     "semver": "^7.5.4",
     "source-map": "^0.7.4",
     "webpack-bundle-analyzer": "^4.9.1",
-    "@rsdoctor/graph": "0.1.0-beta",
-    "@rsdoctor/sdk": "0.1.0-beta",
-    "@rsdoctor/types": "0.1.0-beta",
-    "@rsdoctor/utils": "0.1.0-beta"
+    "@rsdoctor/sdk": "0.1.1",
+    "@rsdoctor/graph": "0.1.1",
+    "@rsdoctor/types": "0.1.1",
+    "@rsdoctor/utils": "0.1.1"
   },
   "devDependencies": {
     "@types/bytes": "3.1.1",
@@ -73,7 +73,7 @@
     "tslib": "2.4.1",
     "typescript": "^5.2.2",
     "webpack": "^5.89.0",
-    "@rsdoctor/test-helper": "0.1.0-beta"
+    "@rsdoctor/test-helper": "0.1.1"
   },
   "publishConfig": {
     "access": "public",