@rsdoctor/core 0.0.2-beta.0

package/dist/build-utils/build/module-graph/webpack/transform.d.ts

@@ -0,0 +1,11 @@
+import type { SourceMapConsumer } from 'source-map';
+import * as Webpack from 'webpack';
+import { Node } from '@rsdoctor/utils/ruleUtils';
+import { Plugin } from '@rsdoctor/types';
+import { ModuleGraph } from '@rsdoctor/graph';
+export interface TransformContext {
+  astCache?: Map<Webpack.NormalModule, Node.Program>;
+  packagePathMap?: Map<string, string>;
+  getSourceMap?(module: string): Promise<SourceMapConsumer | undefined>;
+}
+export declare function appendModuleGraphByCompilation(compilation: Plugin.BaseCompilation, graph: ModuleGraph, features?: Plugin.DoctorWebpackPluginFeatures, context?: TransformContext): Promise<ModuleGraph>;

package/dist/build-utils/build/module-graph/webpack/transform.js

@@ -0,0 +1,197 @@
+"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 transform_exports = {};
+__export(transform_exports, {
+  appendModuleGraphByCompilation: () => appendModuleGraphByCompilation
+});
+module.exports = __toCommonJS(transform_exports);
+var import_build = require("@rsdoctor/utils/build");
+var import_compatible = require("../../../common/webpack/compatible");
+var import_module_graph = require("../../../common/module-graph");
+var import_parser = require("../parser");
+async function readFile(target, wbFs) {
+  if (wbFs?.fs?.readFile) {
+    const result = new Promise((resolve, reject) => {
+      wbFs.fs.readFile(target, (err, content) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        if (content) {
+          resolve(Buffer.from(content));
+        } else {
+          resolve();
+        }
+      });
+    }).catch(() => {
+    });
+    if (result) {
+      return result;
+    }
+  }
+  return import_build.File.fse.readFile(target).catch(() => {
+  });
+}
+function appendDependency(webpackDep, module2, webpackGraph, graph) {
+  const resolvedWebpackModule = (0, import_compatible.getResolveModule)(
+    webpackDep,
+    webpackGraph
+  );
+  if (!resolvedWebpackModule) {
+    return;
+  }
+  const rawRequest = (0, import_compatible.getWebpackDependencyRequest)(
+    webpackDep,
+    resolvedWebpackModule
+  );
+  const resolveRequest = (0, import_compatible.getWebpackModulePath)(resolvedWebpackModule);
+  const request = rawRequest ?? resolveRequest;
+  if (!module2.getDependencyByRequest(request)) {
+    const depModule = graph.getModuleByFile(resolveRequest);
+    if (depModule) {
+      const dep = module2.addDependency(
+        request,
+        depModule,
+        (0, import_module_graph.getImportKind)(webpackDep)
+      );
+      if (dep) {
+        graph.addDependency(dep);
+      }
+    }
+  }
+  const dependency = module2.getDependencyByRequest(request);
+  if (dependency) {
+    dependency.setBuildMeta({
+      exportsType: (0, import_compatible.getModuleExportsType)(
+        resolvedWebpackModule,
+        webpackGraph,
+        module2.meta.strictHarmonyModule
+      )
+    });
+    const statement = (0, import_compatible.getDependencyPosition)(webpackDep, module2, false);
+    if (statement) {
+      dependency.addStatement(statement);
+    }
+    dependency.statements.forEach((state) => {
+      state.position.source = state.module.getSourceRange(
+        state.position.transformed
+      );
+    });
+  }
+}
+function getModuleSource(modulePath, wbFs, sourceMap) {
+  if (sourceMap) {
+    try {
+      const contentFromSourceMap = sourceMap.sourceContentFor(modulePath);
+      if (contentFromSourceMap) {
+        return Buffer.from(contentFromSourceMap);
+      }
+    } catch (e) {
+    }
+  }
+  return process.env.NODE_ENV === "test" ? Buffer.from("test code") : readFile(modulePath, wbFs);
+}
+async function appendModuleData(origin, webpackGraph, graph, wbFs, features, context) {
+  const module2 = graph.getModuleByWebpackId((0, import_compatible.getWebpackModuleId)(origin));
+  if (!origin || !module2) {
+    return;
+  }
+  const { getSourceMap, astCache, packagePathMap } = context ?? {};
+  try {
+    const sourceMap = await getSourceMap?.(module2.path);
+    const source = await getModuleSource(module2.path, wbFs, sourceMap) ?? Buffer.from("");
+    if (sourceMap) {
+      module2.setSourceMap(sourceMap);
+    }
+    if (astCache?.has(origin)) {
+      const program = astCache.get(origin);
+      module2.setProgram(program);
+      module2.meta.hasSetEsModuleStatement = (0, import_parser.hasSetEsModuleStatement)(program);
+    }
+    const transformed = (0, import_compatible.isExternalModule)(origin) ? "" : module2.getSource().transformed.length > 0 ? module2.getSource().transformed : origin.originalSource?.()?.source().toString() ?? "";
+    const transformedSize = (0, import_compatible.isExternalModule)(origin) ? 0 : module2.getSize().transformedSize > 0 ? module2.getSize().transformedSize : Buffer.from(transformed).byteLength;
+    module2.setSource({
+      transformed,
+      source: source.toString()
+    });
+    module2.setSize({
+      transformedSize,
+      sourceSize: source.byteLength
+    });
+    let packageData;
+    if (packagePathMap && origin.resourceResolveData) {
+      let { descriptionFileRoot: root } = origin.resourceResolveData;
+      const { descriptionFileData: data } = origin.resourceResolveData;
+      if (root && data.name && data.version) {
+        if (packagePathMap.has(root)) {
+          root = packagePathMap.get(root);
+        } else {
+          const realpath = await import_build.File.fse.realpath(root);
+          root = realpath;
+          packagePathMap.set(root, realpath);
+        }
+        packageData = {
+          ...origin.resourceResolveData.descriptionFileData,
+          root
+        };
+      }
+    }
+    module2.meta.strictHarmonyModule = origin.buildMeta?.strictHarmonyModule ?? false;
+    module2.meta.packageData = packageData;
+    if (!features?.lite) {
+      Array.from(origin.dependencies).filter((item) => (0, import_module_graph.isImportDependency)(item)).concat(
+        origin.blocks.reduce(
+          (ans, item) => ans.concat(item.dependencies),
+          []
+        )
+      ).forEach((dep) => appendDependency(dep, module2, webpackGraph, graph));
+    }
+  } catch (e) {
+    console.error(`module ${module2.path} transform has error:`, e);
+  }
+}
+async function appendModuleGraphByCompilation(compilation, graph, features, context) {
+  try {
+    if ("rspackVersion" in compilation.compiler && compilation.compiler.rspackVersion) {
+      return graph;
+    }
+    const { moduleGraph: webpackGraph, fileSystemInfo } = compilation;
+    const allModules = (0, import_compatible.getAllModules)(compilation);
+    await Promise.all(
+      allModules.map((module2) => {
+        return appendModuleData(
+          module2,
+          webpackGraph,
+          graph,
+          fileSystemInfo,
+          features,
+          context
+        );
+      })
+    );
+    (0, import_module_graph.removeNoImportStyle)(graph);
+    return graph;
+  } catch (e) {
+    return graph;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendModuleGraphByCompilation
+});

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

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

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

@@ -0,0 +1,26 @@
+"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 utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./loader"), module.exports);
+__reExport(utils_exports, require("./plugin"), module.exports);
+__reExport(utils_exports, require("./parseBundle"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./loader"),
+  ...require("./plugin"),
+  ...require("./parseBundle")
+});

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

@@ -0,0 +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): {
+  default: Plugin.LoaderDefinition<Common.PlainObject, {}>;
+  pitch: Plugin.PitchLoaderDefinitionFunction;
+  raw: boolean | void;
+};
+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 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

@@ -0,0 +1,210 @@
+"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 loader_exports = {};
+__export(loader_exports, {
+  createLoaderContextTrap: () => createLoaderContextTrap,
+  extractLoaderName: () => extractLoaderName,
+  getLoaderOptions: () => getLoaderOptions,
+  loadLoaderModule: () => loadLoaderModule,
+  mapEachRules: () => mapEachRules
+});
+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, {
+    paths: [cwd, import_path.default.resolve(cwd, "node_modules")]
+  }));
+  const isESM = mod.__esModule && typeof mod.default === "function";
+  return {
+    default: isESM ? mod.default : typeof mod === "function" ? mod : null,
+    pitch: mod.default?.pitch || mod.pitch,
+    raw: mod.default?.raw || mod.raw || false
+  };
+}
+function getLoaderOptions(loaderContext) {
+  if (typeof loaderContext.getOptions === "function") {
+    return loaderContext.getOptions();
+  }
+  return (0, import_loader_utils.getOptions)(loaderContext);
+}
+function extractLoaderName(loaderPath, cwd = "") {
+  let res = loaderPath.replace(cwd, "");
+  if (!import_path.default.isAbsolute(res))
+    return res;
+  const nms = "/node_modules/";
+  const idx = res.lastIndexOf(nms);
+  if (idx !== -1) {
+    res = res.slice(idx + nms.length);
+    const ln = "loader";
+    const lnIdx = res.lastIndexOf(ln);
+    if (lnIdx > -1) {
+      res = res.slice(0, lnIdx + ln.length);
+    }
+  }
+  return res;
+}
+function mapEachRules(rules, callback) {
+  return rules.map((rule, i) => {
+    if (typeof rule === "string") {
+      return callback({
+        loader: rule
+      });
+    }
+    if (rule.loader && typeof rule.loader === "string") {
+      return callback(rule);
+    }
+    if (Array.isArray(rule.loaders)) {
+      const { loaders, ...rest } = rule;
+      return {
+        ...rest,
+        use: mapEachRules(loaders, callback)
+      };
+    }
+    if (rule.use && (!Array.isArray(rule.use) || rule.use.length !== 0)) {
+      if (typeof rule.use === "string") {
+        return {
+          ...rule,
+          use: mapEachRules(
+            [
+              {
+                loader: rule.use,
+                options: rule.options
+              }
+            ],
+            callback
+          )
+        };
+      }
+      if (Array.isArray(rule.use)) {
+        return {
+          ...rule,
+          use: mapEachRules(rule.use, callback)
+        };
+      }
+      return {
+        ...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 {
+        ...rule,
+        rules: mapEachRules(rule.rules, callback)
+      };
+    }
+    if (Array.isArray(rule.oneOf)) {
+      return {
+        ...rule,
+        oneOf: mapEachRules(rule.oneOf, callback)
+      };
+    }
+    return rule;
+  });
+}
+function createLoaderContextTrap(final) {
+  const cb = this.callback;
+  let callback = (...args) => {
+    final(args[0], args[1] ?? null, args[2]);
+    return cb.call(this, ...args);
+  };
+  const ac = this.async;
+  let async = (...args) => {
+    const cb2 = ac(...args);
+    return (...args2) => {
+      final(args2[0], args2[1] ?? null, args2[2]);
+      return cb2(...args2);
+    };
+  };
+  const trap = new Proxy(this, {
+    get(target, key, receiver) {
+      switch (key) {
+        case "async":
+          return async;
+        case "callback":
+          return callback;
+        case "query":
+          if (target.query) {
+            if (typeof target.query === "string") {
+              const res = target.query.replace(
+                // eslint-disable-next-line no-useless-escape
+                new RegExp(
+                  `"${import_common.Loader.LoaderInternalPropertyName}":{[^}]*},{0,1}`
+                ),
+                ""
+              );
+              return res;
+            }
+            if (typeof target.query === "object") {
+              const options = target.query[import_common.Loader.LoaderInternalPropertyName];
+              if (options.hasOptions) {
+                return (0, import_lodash.omit)(target.query, [import_common.Loader.LoaderInternalPropertyName]);
+              }
+              return target.resourceQuery;
+            }
+          }
+          return Reflect.get(target, key, receiver);
+        case "getOptions":
+          return typeof target.getOptions === "function" ? () => (0, import_lodash.omit)(target.getOptions(), [import_common.Loader.LoaderInternalPropertyName]) : Reflect.get(target, key, receiver);
+        default:
+          const _target = target;
+          return _target[key];
+      }
+    },
+    set(target, key, value, receiver) {
+      switch (key) {
+        case "async":
+          async = value;
+          return true;
+        case "callback":
+          callback = value;
+          return true;
+        default:
+          return Reflect.set(target, key, value, receiver);
+      }
+    },
+    defineProperty(target, p, attrs) {
+      return Reflect.defineProperty(target, p, attrs);
+    }
+  });
+  return trap;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLoaderContextTrap,
+  extractLoaderName,
+  getLoaderOptions,
+  loadLoaderModule,
+  mapEachRules
+});

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

@@ -0,0 +1,12 @@
+import { ParseBundle } from "../../../types";
+/**
+ * The following code is based on
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/src/parseUtils.js#L10
+ *
+ *
+ * MIT Licensed
+ * Author th0r
+ * Copyright JS Foundation and other contributors.
+ * https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/44bd8d0f9aa3b098e271af220096ea70cc44bc9e/LICENSE
+ */
+export declare const parseBundle: ParseBundle;