@rsdoctor/core 0.0.2-beta.0

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

@@ -0,0 +1,50 @@
+"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 common_exports = {};
+__export(common_exports, {
+  Chunks: () => Chunks,
+  ModuleGraph: () => ModuleGraph,
+  TransUtils: () => TransUtils,
+  Types: () => Types,
+  Webpack: () => Webpack
+});
+module.exports = __toCommonJS(common_exports);
+var Chunks = __toESM(require("./chunks"));
+var Types = __toESM(require("../../types"));
+var ModuleGraph = __toESM(require("./module-graph"));
+var TransUtils = __toESM(require("./trans-utils"));
+var Webpack = __toESM(require("./webpack/compatible"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Chunks,
+  ModuleGraph,
+  TransUtils,
+  Types,
+  Webpack
+});

package/dist/build-utils/common/module-graph/compatible.d.ts

@@ -0,0 +1,9 @@
+import { Plugin, SDK } from '@rsdoctor/types';
+/**
+ * Reverse decode the location (loc) information.
+ * baseon
+ * // TODO::
+ * @link https://github.com/webpack/webpack/blob/main/lib/formatLocation.js#L30-L66
+ */
+export declare function getPositionByStatsLocation(loc: string): SDK.SourceRange | undefined;
+export declare function isWebpack5orRspack(compilation: Plugin.BaseCompilation): Boolean;

package/dist/build-utils/common/module-graph/compatible.js

@@ -0,0 +1,63 @@
+"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 compatible_exports = {};
+__export(compatible_exports, {
+  getPositionByStatsLocation: () => getPositionByStatsLocation,
+  isWebpack5orRspack: () => isWebpack5orRspack
+});
+module.exports = __toCommonJS(compatible_exports);
+function getPositionByStatsLocation(loc) {
+  function formatPosition(loc2) {
+    const [line, column] = loc2.split(":");
+    return { line: Number(line), column: Number(column) };
+  }
+  if (loc.includes("-")) {
+    const positionString = loc.split("-");
+    const start = formatPosition(positionString[0]);
+    const end = formatPosition(positionString[1]);
+    return {
+      start,
+      end: Number.isNaN(end.column) ? {
+        line: start.line,
+        column: end.line
+      } : end
+    };
+  }
+  if (loc.includes(":")) {
+    return {
+      start: formatPosition(loc)
+    };
+  }
+  if (loc.includes("[")) {
+    const result = loc.match(/\[(\d+)\]/);
+    return {
+      start: {
+        index: Number(result[1])
+      }
+    };
+  }
+}
+function isWebpack5orRspack(compilation) {
+  return "moduleGraph" in compilation && Boolean(compilation.moduleGraph);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPositionByStatsLocation,
+  isWebpack5orRspack
+});

package/dist/build-utils/common/module-graph/index.d.ts

@@ -0,0 +1,3 @@
+export * from './transform';
+export * from './compatible';
+export * from './utils';

package/dist/build-utils/common/module-graph/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 module_graph_exports = {};
+module.exports = __toCommonJS(module_graph_exports);
+__reExport(module_graph_exports, require("./transform"), module.exports);
+__reExport(module_graph_exports, require("./compatible"), module.exports);
+__reExport(module_graph_exports, require("./utils"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./transform"),
+  ...require("./compatible"),
+  ...require("./utils")
+});

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

@@ -0,0 +1,10 @@
+import { Plugin } from '@rsdoctor/types';
+import { ModuleGraph, ChunkGraph } from '@rsdoctor/graph';
+export declare function getModulesFromArray(modules: Plugin.StatsModule[], collectedModules: Plugin.StatsModule[]): void;
+/**
+ * this function can run in browser & node.
+ */
+export declare function getModuleGraphByStats({
+  modules,
+  chunks
+}: Plugin.StatsCompilation, root: string, chunkGraph: ChunkGraph): ModuleGraph;

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

@@ -0,0 +1,193 @@
+"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 transform_exports = {};
+__export(transform_exports, {
+  getModuleGraphByStats: () => getModuleGraphByStats,
+  getModulesFromArray: () => getModulesFromArray
+});
+module.exports = __toCommonJS(transform_exports);
+var import_types = require("@rsdoctor/types");
+var import_path_browserify = __toESM(require("path-browserify"));
+var import_graph = require("@rsdoctor/graph");
+var import_utils = require("./utils");
+var import_compatible = require("./compatible");
+function getCanSkip(data) {
+  if (!data.identifier || !(data?.nameForCondition || data.name) || data.identifier.startsWith("webpack/runtime") || data?.name?.startsWith("(webpack)")) {
+    return true;
+  }
+}
+function getGetModuleName(root, data) {
+  if (data.nameForCondition) {
+    return data.nameForCondition.replace("\0", "");
+  }
+  const name = data.name.replace(/ ?\+ ?\d+ ?modules$/, "");
+  return import_path_browserify.default.isAbsolute(name) ? name : import_path_browserify.default.join(root, name);
+}
+function getModuleFromChildren(module2, collectedModules) {
+  if (module2.type === "module" || typeof module2.type === "undefined") {
+    collectedModules.push(module2);
+  } else if ("children" in module2 && module2.children) {
+    getModulesFromArray(
+      module2.children,
+      collectedModules
+    );
+  }
+}
+function getModulesFromArray(modules, collectedModules) {
+  modules.forEach((module2) => {
+    getModuleFromChildren(module2, collectedModules);
+  });
+}
+function getModulesFromChunks(chunks, collectedModules) {
+  chunks?.forEach((chunk) => {
+    if (chunk.modules?.length) {
+      collectedModules.push(...chunk.modules);
+    }
+  });
+}
+function getModuleGraphByStats({ modules, chunks }, root, chunkGraph) {
+  import_graph.ModuleGraph.init();
+  const moduleGraph = new import_graph.ModuleGraph();
+  const allModules = [];
+  const collectedModules = [];
+  getModulesFromArray(modules ?? [], collectedModules);
+  getModulesFromChunks(chunks ?? [], collectedModules);
+  for (const data of collectedModules ?? []) {
+    if (getCanSkip(data)) {
+      continue;
+    }
+    if (moduleGraph.getModuleByWebpackId(data.identifier)) {
+      continue;
+    }
+    allModules.push(data);
+    const isConcatenated = Boolean(data.modules && data.modules.length > 0);
+    const concatenatedModule = new import_graph.Module(
+      data.identifier,
+      getGetModuleName(root, data),
+      data.depth === 0,
+      isConcatenated ? import_types.SDK.ModuleKind.Concatenation : import_types.SDK.ModuleKind.Normal
+    );
+    data.chunks?.forEach((_chunkId) => {
+      const chunk = chunkGraph.getChunkById(String(_chunkId));
+      chunk && concatenatedModule.addChunk(chunk);
+    });
+    moduleGraph.addModule(concatenatedModule);
+    if (data.source) {
+      concatenatedModule.setSource({
+        transformed: Buffer.isBuffer(data.source) ? data.source.toString() : data.source
+      });
+    }
+    if (typeof data.size === "number") {
+      concatenatedModule.setSize({
+        sourceSize: data.size,
+        transformedSize: data.size
+      });
+    }
+    for (const normal of data.modules ?? []) {
+      if (getCanSkip(normal)) {
+        continue;
+      }
+      allModules.push(normal);
+      const webpackId = normal.identifier;
+      const normalModule = moduleGraph.getModuleByWebpackId(webpackId) ?? new import_graph.Module(
+        webpackId,
+        getGetModuleName(root, normal),
+        normal.depth === 0,
+        import_types.SDK.ModuleKind.Normal
+      );
+      normal.chunks?.forEach((_chunkId) => {
+        const chunk = chunkGraph.getChunkById(String(_chunkId));
+        chunk && normalModule.addChunk(chunk);
+      });
+      if (normal.source) {
+        normalModule.setSource({
+          transformed: Buffer.isBuffer(normal.source) ? normal.source.toString() : normal.source
+        });
+      }
+      if (typeof normal.size === "number") {
+        normalModule.setSize({
+          sourceSize: normal.size,
+          transformedSize: normal.size
+        });
+      }
+      moduleGraph.addModule(normalModule);
+      concatenatedModule.addNormalModule(normalModule);
+    }
+  }
+  for (const module2 of allModules) {
+    const currentModule = moduleGraph.getModuleByWebpackId(
+      module2.identifier ?? ""
+    );
+    if (!currentModule) {
+      continue;
+    }
+    const dependencies = (module2.reasons ?? []).filter(import_utils.isImportDependency).filter((item) => Boolean(item.moduleIdentifier && item.userRequest));
+    (module2.reasons ?? []).filter((item) => item.type === "from origin").forEach(
+      (dep) => dep?.children?.forEach(
+        (_d) => dependencies.push({ ...dep, ..._d, children: void 0 })
+      )
+    );
+    for (const dep of dependencies) {
+      const rawRequest = dep.userRequest;
+      const requestModule = moduleGraph.getModuleByWebpackId(
+        dep.moduleIdentifier
+      );
+      if (!requestModule) {
+        continue;
+      }
+      if (!requestModule.getDependencyByRequest(rawRequest)) {
+        const data = requestModule.addDependency(
+          rawRequest,
+          currentModule,
+          (0, import_utils.getImportKind)(dep)
+        );
+        if (data) {
+          moduleGraph.addDependency(data);
+        }
+      }
+      const dependency = requestModule.getDependencyByRequest(rawRequest);
+      if (dependency && dep?.loc) {
+        const position = (0, import_compatible.getPositionByStatsLocation)(dep.loc);
+        if (position) {
+          dependency.addStatement(
+            new import_graph.Statement(requestModule, {
+              transformed: position
+            })
+          );
+        }
+      }
+    }
+  }
+  return moduleGraph;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModuleGraphByStats,
+  getModulesFromArray
+});

package/dist/build-utils/common/module-graph/utils.d.ts

@@ -0,0 +1,17 @@
+import { SDK } from '@rsdoctor/types';
+import type { ModuleGraph } from '@rsdoctor/graph';
+interface DependencyData {
+  type?: string;
+}
+/** Determine whether it is the import statement itself */
+export declare function isImportDependency({
+  type
+}: DependencyData): boolean;
+export declare function getImportKind(dep: DependencyData): SDK.DependencyKind;
+/**
+ * Remove the css module without connection
+ *   - This will happen when the user uses the mini-css plug-in.
+ */
+export declare function removeNoImportStyle(graph: ModuleGraph): void;
+export declare function isStyleExt(path: string): boolean;
+export {};

package/dist/build-utils/common/module-graph/utils.js

@@ -0,0 +1,62 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  getImportKind: () => getImportKind,
+  isImportDependency: () => isImportDependency,
+  isStyleExt: () => isStyleExt,
+  removeNoImportStyle: () => removeNoImportStyle
+});
+module.exports = __toCommonJS(utils_exports);
+var import_types = require("@rsdoctor/types");
+function isImportDependency({ type }) {
+  return type === "harmony side effect evaluation" || type === "cjs require" || type === "cjs full require" || type === "cjs export require" || type === "provided" || type === "esm import";
+}
+function getImportKind(dep) {
+  const { type } = dep;
+  if (!type) {
+    return import_types.SDK.DependencyKind.Unknown;
+  }
+  if (type.includes("harmony")) {
+    return import_types.SDK.DependencyKind.ImportStatement;
+  }
+  if (type.includes("cjs")) {
+    return import_types.SDK.DependencyKind.RequireCall;
+  }
+  if (type.includes("import()")) {
+    return import_types.SDK.DependencyKind.DynamicImport;
+  }
+  if (type.includes("amd")) {
+    return import_types.SDK.DependencyKind.AMDRequire;
+  }
+  return import_types.SDK.DependencyKind.Unknown;
+}
+function removeNoImportStyle(graph) {
+  graph.getModules().filter((module2) => isStyleExt(module2.path)).filter((item) => item.getImported().length === 0).forEach((item) => graph.removeModule(item));
+}
+function isStyleExt(path) {
+  return /\.(c|le|sa|sc)ss(\?.*)?$/.test(path);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getImportKind,
+  isImportDependency,
+  isStyleExt,
+  removeNoImportStyle
+});

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

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

package/dist/build-utils/common/trans-utils/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 trans_utils_exports = {};
+module.exports = __toCommonJS(trans_utils_exports);
+__reExport(trans_utils_exports, require("./transStats"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./transStats")
+});

package/dist/build-utils/common/trans-utils/transStats.d.ts

@@ -0,0 +1,6 @@
+import type { ChunkGraph } from '@rsdoctor/graph';
+import { Plugin } from '@rsdoctor/types';
+export declare function transStats(json: Plugin.StatsCompilation): Promise<{
+  chunkGraph: ChunkGraph;
+  moduleGraph: import("@rsdoctor/graph").ModuleGraph;
+}>;

package/dist/build-utils/common/trans-utils/transStats.js

@@ -0,0 +1,35 @@
+"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 transStats_exports = {};
+__export(transStats_exports, {
+  transStats: () => transStats
+});
+module.exports = __toCommonJS(transStats_exports);
+var import__ = require("..");
+async function transStats(json) {
+  const chunkGraph = import__.Chunks.chunkTransform(/* @__PURE__ */ new Map(), json);
+  const moduleGraph = import__.ModuleGraph.getModuleGraphByStats(json, ".", chunkGraph);
+  const assetsModuleMap = await import__.Chunks.getAssetsModulesData(json, json.outputPath || "", {}) || {};
+  import__.Chunks.transformAssetsModulesData(assetsModuleMap, moduleGraph);
+  return { chunkGraph, moduleGraph };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transStats
+});

package/dist/build-utils/common/webpack/compatible.d.ts

@@ -0,0 +1,26 @@
+import type { SDK } from '@rsdoctor/types';
+import { ModuleGraph as SdkModuleGraph, Module as SdkModule, Statement } from '@rsdoctor/graph';
+import { Compilation, Dependency, ExternalModule, Module, ModuleGraph, NormalModule } from 'webpack';
+import type { EntryPoint, ExportInfo } from "../../../types/index.d";
+export declare function isNormalModule(mod: Module): mod is NormalModule;
+export declare function getWebpackModuleId(mod: Module): string;
+export declare function getWebpackModulePath(mod: NormalModule): string;
+export declare function getWebpackDependencyRequest(dep: Dependency, module?: NormalModule): string;
+export declare function getResolveRequest(dep: Dependency, graph: ModuleGraph): string;
+export declare function isExternalModule(mod: Module): mod is ExternalModule;
+export declare function getModuleSource(mod: NormalModule): string;
+export declare function getResolveModule(dep: Dependency, graph?: ModuleGraph): Module | null;
+export declare function getEntryModule(entryMap: Map<string, EntryPoint>): NormalModule[];
+/**
+ * Get the type of dependencies between modules.
+ * This property can determine what runtime webpack has added to the modules.
+ * In webpack 5, it can be directly obtained using internal APIs.
+ * In webpack 4, manual conversion is required. Since webpack 4 is not as strict as webpack 5 in terms of compatibility, we can follow the logic of webpack 5 here.
+ */
+export declare function getModuleExportsType(module: NormalModule, moduleGraph?: ModuleGraph, strict?: boolean): SDK.DependencyBuildMeta['exportsType'];
+export declare function getDependencyPosition(dep: Dependency, module: SdkModule, getSource?: boolean): Statement | undefined;
+export declare function getExportDependency(info: ExportInfo, module: NormalModule): Dependency | undefined;
+export declare function getSdkDependencyByWebpackDependency(dep: Dependency, module: NormalModule, graph: SdkModuleGraph): import("@rsdoctor/graph").Dependency | undefined;
+export declare function getExportStatement(info: ExportInfo, normalModule: NormalModule, graph: SdkModuleGraph): Statement | undefined;
+export declare function getLastExportInfo(info: ExportInfo, webpackGraph: ModuleGraph): ExportInfo | undefined;
+export declare function getAllModules(compilation: Compilation): NormalModule[];