@rsdoctor/core 0.1.0 → 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";
@@ -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,
@@ -130,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) => {
@@ -168,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);
@@ -199,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/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)) {
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/core",
-  "version": "0.1.0",
+  "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",
-    "@rsdoctor/types": "0.1.0",
-    "@rsdoctor/sdk": "0.1.0",
-    "@rsdoctor/utils": "0.1.0"
+    "@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"
+    "@rsdoctor/test-helper": "0.1.1"
   },
   "publishConfig": {
     "access": "public",