@rsdoctor/core 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/build-utils/build/chunks/assetsModules.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@rsdoctor/types';
+import { ParsedModuleSizeData } from "../../common/chunks";
+export declare function getAssetsModulesData(bundleStats: Plugin.StatsCompilation, bundleDir: string): Promise<ParsedModuleSizeData | null>;

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

@@ -0,0 +1,32 @@
+"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 assetsModules_exports = {};
+__export(assetsModules_exports, {
+  getAssetsModulesData: () => getAssetsModulesData
+});
+module.exports = __toCommonJS(assetsModules_exports);
+var import_chunks = require("../../common/chunks");
+var import_utils = require("../utils");
+async function getAssetsModulesData(bundleStats, bundleDir) {
+  return (0, import_chunks.getAssetsModulesData)(bundleStats, bundleDir, { parseBundle: import_utils.parseBundle });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAssetsModulesData
+});

package/dist/build-utils/build/chunks/chunkTransform.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+export declare function chunkTransform(assetMap: Map<string, {
+  content: string;
+}>, bundleStats: Plugin.StatsCompilation): import("@rsdoctor/graph").ChunkGraph;

package/dist/build-utils/build/chunks/chunkTransform.js

@@ -0,0 +1,31 @@
+"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 chunkTransform_exports = {};
+__export(chunkTransform_exports, {
+  chunkTransform: () => chunkTransform
+});
+module.exports = __toCommonJS(chunkTransform_exports);
+var import_chunks = require("../../common/chunks");
+function chunkTransform(assetMap, bundleStats) {
+  return (0, import_chunks.chunkTransform)(assetMap, bundleStats);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunkTransform
+});

package/dist/build-utils/build/chunks/generateTileGraph.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from '@rsdoctor/types';
+export declare const TileGraphReportName = "rsdoctor-tile-graph.html";
+type IGenerateReportOpts = {
+  reportFilename: string;
+  reportTitle?: string;
+  bundleDir?: string;
+  openBrowser?: boolean;
+};
+export declare function generateTileGraph(bundleStats: Plugin.BaseStats, opts: IGenerateReportOpts, buildOutputPath: string): Promise<string | null>;
+export {};

package/dist/build-utils/build/chunks/generateTileGraph.js

@@ -0,0 +1,77 @@
+"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 generateTileGraph_exports = {};
+__export(generateTileGraph_exports, {
+  TileGraphReportName: () => TileGraphReportName,
+  generateTileGraph: () => generateTileGraph
+});
+module.exports = __toCommonJS(generateTileGraph_exports);
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_logger = require("@rsdoctor/utils/logger");
+var import_viewer = require("webpack-bundle-analyzer/lib/viewer");
+var import_constants = require("@rsdoctor/types/dist/constants");
+const TileGraphReportName = "rsdoctor-tile-graph.html";
+async function generateJSONReportUtil(bundleStats, opts) {
+  await (0, import_viewer.generateReport)(bundleStats, {
+    ...opts,
+    logger: {
+      warn: () => {
+      },
+      info: () => {
+      },
+      error: (e) => {
+        console.log(e);
+      }
+    }
+  });
+}
+async function generateTileGraph(bundleStats, opts, buildOutputPath) {
+  try {
+    const tileReportHtmlDir = import_path.default.join(buildOutputPath, import_constants.DoctorOutputFolder);
+    if (!import_fs.default.existsSync(tileReportHtmlDir)) {
+      import_fs.default.mkdirSync(tileReportHtmlDir);
+    }
+    const { reportFilename } = opts;
+    await generateJSONReportUtil(bundleStats, {
+      ...opts,
+      openBrowser: false,
+      bundleDir: tileReportHtmlDir
+    });
+    return import_path.default.join(tileReportHtmlDir, `${reportFilename}`);
+  } catch (e) {
+    (0, import_logger.debug)(() => `Generate webpack-bundle-analyzer tile graph has error:${e}`);
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TileGraphReportName,
+  generateTileGraph
+});

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

@@ -0,0 +1,3 @@
+export * from './assetsModules';
+export * from './chunkTransform';
+export * from './generateTileGraph';

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

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

@@ -0,0 +1,4 @@
+export * as Chunks from './chunks';
+export * as Utils from './utils';
+export * as Types from '../../types';
+export * as ModuleGraph from './module-graph';

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

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

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

@@ -0,0 +1,3 @@
+export * from './webpack/transform';
+export * from './transform';
+export * from './treeShaking';

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

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

@@ -0,0 +1,2 @@
+import { Node } from '@rsdoctor/utils/ruleUtils';
+export declare function hasSetEsModuleStatement(program: Node.Program): boolean;

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

@@ -0,0 +1,44 @@
+"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 parser_exports = {};
+__export(parser_exports, {
+  hasSetEsModuleStatement: () => hasSetEsModuleStatement
+});
+module.exports = __toCommonJS(parser_exports);
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+const esmLabelStatement = import_ruleUtils.parser.internal.parseExpressionAt(
+  'Object.defineProperty(exports, "__esModule", { value: true })',
+  0,
+  {
+    ecmaVersion: 6,
+    ranges: false,
+    locations: false,
+    sourceType: "script"
+  }
+);
+function hasSetEsModuleStatement(program) {
+  const expressions = program.body.filter(import_ruleUtils.parser.asserts.isExpressionStatement).map((item) => item.expression).filter(import_ruleUtils.parser.asserts.isSimpleCallExpression);
+  return expressions.some(
+    (exp) => import_ruleUtils.parser.utils.isSameSemantics(exp, esmLabelStatement)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasSetEsModuleStatement
+});

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

@@ -0,0 +1,4 @@
+import { Plugin } from '@rsdoctor/types';
+import { TransformContext } from '.';
+import { ChunkGraph } from '@rsdoctor/graph';
+export declare function getModuleGraphByStats(compilation: Plugin.BaseCompilation, stats: Plugin.StatsCompilation, root: string, chunkGraph: ChunkGraph, features?: Plugin.DoctorWebpackPluginFeatures, context?: TransformContext): Promise<import("@rsdoctor/graph").ModuleGraph>;

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

@@ -0,0 +1,37 @@
+"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, {
+  getModuleGraphByStats: () => getModuleGraphByStats
+});
+module.exports = __toCommonJS(transform_exports);
+var import_module_graph = require("../../common/module-graph");
+var import__ = require(".");
+function getModuleGraphByStats(compilation, stats, root, chunkGraph, features, context) {
+  return (0, import__.appendModuleGraphByCompilation)(
+    compilation,
+    (0, import_module_graph.getModuleGraphByStats)(stats, root, chunkGraph),
+    features,
+    context
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModuleGraphByStats
+});

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

@@ -0,0 +1,3 @@
+import { ModuleGraph } from '@rsdoctor/graph';
+import type { Compilation } from 'webpack';
+export declare function appendTreeShaking(moduleGraph: ModuleGraph, compilation: Compilation): ModuleGraph;

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

@@ -0,0 +1,130 @@
+"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 treeShaking_exports = {};
+__export(treeShaking_exports, {
+  appendTreeShaking: () => appendTreeShaking
+});
+module.exports = __toCommonJS(treeShaking_exports);
+var import_graph = require("@rsdoctor/graph");
+var import_compatible = require("../../common/webpack/compatible");
+var import_utils = require("./utils");
+var import_module_graph = require("../../common/module-graph");
+function transformMgm(origin, webpackGraph, graph, cache) {
+  const module2 = graph.getModuleByWebpackId(origin.identifier());
+  if (!module2) {
+    return;
+  }
+  const mgm = new import_graph.ModuleGraphModule(module2, graph);
+  const originalMgm = webpackGraph.getExportsInfo(origin);
+  graph.addModuleGraphModule(mgm);
+  for (const info of originalMgm.exports) {
+    const { name } = info;
+    const exportIdStatement = (0, import_utils.getExportIdentifierStatement)(name, module2) ?? import_graph.Statement.getDefaultStatement(module2);
+    const declareIdStatement = (0, import_utils.getDeclarationIdentifier)(name, module2);
+    const exportInfo = new import_graph.ExportInfo(info.name, exportIdStatement);
+    if (declareIdStatement) {
+      const variable = new import_graph.Variable(
+        name,
+        module2,
+        info.getUsedInfo(),
+        declareIdStatement
+      );
+      variable.setExportInfo(exportInfo);
+      mgm.addVariable(variable);
+    }
+    cache.set(info, exportInfo);
+    mgm.addExportInfo(exportInfo);
+  }
+  for (const dep of origin.dependencies) {
+    if (dep.type !== "harmony import specifier") {
+      continue;
+    }
+    const HISDep = dep;
+    const { name, userRequest } = HISDep;
+    const originName = HISDep.getIds(webpackGraph)[0] ?? import_graph.SideEffect.NamespaceSymbol;
+    const importIdStatement = module2.getStatement(dep.loc);
+    const importInfo = new import_graph.SideEffect(
+      name,
+      module2,
+      importIdStatement,
+      userRequest,
+      originName
+    );
+    mgm.addSideEffect(importInfo);
+  }
+}
+function appendExportConnection(origin, webpackGraph, graph, cache) {
+  const module2 = graph.getModuleByWebpackId(origin.identifier());
+  const mgm = graph.getModuleGraphModule(module2);
+  const originalMgm = webpackGraph.getExportsInfo(origin);
+  if (!mgm || !module2) {
+    return;
+  }
+  for (const info of originalMgm.exports) {
+    if (!info.isReexport()) {
+      continue;
+    }
+    const lastExport = (0, import_compatible.getLastExportInfo)(info, webpackGraph);
+    const lastSdkExport = cache.get(lastExport);
+    const sdkExport = cache.get(info);
+    if (!lastSdkExport || !sdkExport) {
+      return;
+    }
+    sdkExport.setFromExport(lastSdkExport);
+  }
+}
+function appendImportConnection(origin, graph) {
+  const module2 = graph.getModuleByWebpackId(origin.identifier());
+  const mgm = graph.getModuleGraphModule(module2);
+  if (!mgm || !module2) {
+    return;
+  }
+  for (const info of mgm.getSideEffects()) {
+    const exportName = info.originName ?? info.name;
+    const resolveModule = info.fromDependency?.dependency;
+    if (!resolveModule) {
+      continue;
+    }
+    const resolveExport = graph.getModuleGraphModule(resolveModule).getExport(exportName);
+    if (resolveExport) {
+      info.setExportInfo(resolveExport);
+    }
+  }
+}
+function appendTreeShaking(moduleGraph, compilation) {
+  if (!(0, import_module_graph.isWebpack5orRspack)(compilation)) {
+    return moduleGraph;
+  }
+  const exportData = /* @__PURE__ */ new Map();
+  const { moduleGraph: webpackGraph } = compilation;
+  const allModules = (0, import_compatible.getAllModules)(compilation);
+  allModules.forEach(
+    (origin) => transformMgm(origin, webpackGraph, moduleGraph, exportData)
+  );
+  allModules.forEach(
+    (origin) => appendExportConnection(origin, webpackGraph, moduleGraph, exportData)
+  );
+  allModules.forEach((origin) => appendImportConnection(origin, moduleGraph));
+  exportData.clear();
+  return moduleGraph;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendTreeShaking
+});

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

@@ -0,0 +1,3 @@
+import * as SDK from '@rsdoctor/graph';
+export declare function getExportIdentifierStatement(name: string, module: SDK.Module): SDK.Statement | undefined;
+export declare function getDeclarationIdentifier(name: string, module: SDK.Module): SDK.Statement | undefined;

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

@@ -0,0 +1,113 @@
+"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, {
+  getDeclarationIdentifier: () => getDeclarationIdentifier,
+  getExportIdentifierStatement: () => getExportIdentifierStatement
+});
+module.exports = __toCommonJS(utils_exports);
+var import_lodash = require("lodash");
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+function getDefaultExportIdentifier(node, module2, searchId) {
+  const { declaration } = node;
+  if (import_ruleUtils.parser.asserts.isLiteral(declaration) && declaration.loc) {
+    return module2.getStatement(declaration.loc);
+  }
+  if (import_ruleUtils.parser.asserts.isIdentifier(declaration)) {
+    if (searchId) {
+      const result = getDeclarationIdentifier(declaration.name, module2);
+      if (result) {
+        return result;
+      }
+    } else if (declaration.loc) {
+      return module2.getStatement(declaration.loc);
+    }
+  }
+  if (import_ruleUtils.parser.asserts.isClassDeclaration(declaration) || import_ruleUtils.parser.asserts.isFunctionDeclaration(declaration)) {
+    if (declaration.id?.loc) {
+      return module2.getStatement(declaration.id.loc);
+    }
+  }
+  const startLine = node.declaration.loc?.start.line;
+  if (!(0, import_lodash.isNumber)(startLine)) {
+    return;
+  }
+  const { transformed } = module2.getSource();
+  const endColumn = transformed.split("\n")[startLine - 1].length - 1;
+  return module2.getStatement({
+    start: {
+      line: startLine,
+      column: 0
+    },
+    end: {
+      line: startLine,
+      column: endColumn
+    }
+  });
+}
+function getExportIdentifierStatement(name, module2) {
+  const ast = module2.getProgram();
+  if (!ast) {
+    return;
+  }
+  for (const node of ast.body) {
+    if (import_ruleUtils.parser.asserts.isExportDefaultDeclaration(node)) {
+      const result = getDefaultExportIdentifier(node, module2, false);
+      if (result) {
+        return result;
+      }
+    }
+    const id = import_ruleUtils.parser.utils.getIdentifierInExport(name, node);
+    if (id?.loc) {
+      return module2.getStatement(id.loc);
+    }
+  }
+}
+function getDeclarationIdentifier(name, module2) {
+  const ast = module2.getProgram();
+  if (!ast) {
+    return;
+  }
+  for (const node of ast.body) {
+    const id = import_ruleUtils.parser.utils.getIdentifierInDeclaration(name, node);
+    if (id?.loc) {
+      return module2.getStatement(id.loc);
+    }
+    if (import_ruleUtils.parser.asserts.isExportNamedDeclaration(node) && node.declaration) {
+      const id2 = import_ruleUtils.parser.utils.getIdentifierInDeclaration(
+        name,
+        node.declaration
+      );
+      if (id2?.loc) {
+        return module2.getStatement(id2.loc);
+      }
+    }
+    if (name === "default" && import_ruleUtils.parser.asserts.isExportDefaultDeclaration(node)) {
+      const result = getDefaultExportIdentifier(node, module2, true);
+      if (result) {
+        return result;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDeclarationIdentifier,
+  getExportIdentifierStatement
+});