@rsdoctor/graph 0.0.2-beta.0

package/dist/esm/graph/module-graph/graph.js

@@ -0,0 +1,335 @@
+import { SDK } from "@rsdoctor/types";
+import { Dependency } from "./dependency";
+import { Module } from "./module";
+import { Statement } from "./statement";
+import {
+  ModuleGraphModule,
+  ExportInfo,
+  SideEffect,
+  Variable
+} from "./tree-shaking";
+class ModuleGraph {
+  constructor() {
+    this._dependenciesIdMap = /* @__PURE__ */ new Map();
+    this._moduleWebpackIdMap = /* @__PURE__ */ new Map();
+    this._moduleIdMap = /* @__PURE__ */ new Map();
+    this._moduleGraphModules = /* @__PURE__ */ new Map();
+    this._exportIdMap = /* @__PURE__ */ new Map();
+    this._sideEffectIdMap = /* @__PURE__ */ new Map();
+    this._varIdMap = /* @__PURE__ */ new Map();
+  }
+  static init() {
+    Module.init();
+    Dependency.init();
+    ModuleGraphModule.init();
+  }
+  static fromData(data) {
+    const moduleGraph = new ModuleGraph();
+    const getStatement = (data2) => new Statement(moduleGraph.getModuleById(data2.module), data2.position);
+    for (const item of data.modules ?? []) {
+      const module = new Module(
+        String(item.id),
+        item.path,
+        item.isEntry,
+        item.kind
+      );
+      module.id = item.id;
+      module.setSize(item.size);
+      module.meta = {
+        strictHarmonyModule: item.meta?.strictHarmonyModule ?? false,
+        hasSetEsModuleStatement: item.meta?.hasSetEsModuleStatement ?? false
+      };
+      module._isPreferSource = item.isPreferSource;
+      module.chunks = item.chunks;
+      moduleGraph.addModule(module);
+    }
+    for (const moduleData of data.modules ?? []) {
+      const module = moduleGraph.getModuleById(moduleData.id);
+      for (const depId of moduleData.dependencies) {
+        const depData = (data.dependencies ?? []).find(
+          (item) => item.id === depId
+        );
+        const depModule = depData && moduleGraph.getModuleById(depData.originDependency);
+        if (!depData || !depModule) {
+          console.warn(`The connection data ID is empty: ${depId}`);
+          continue;
+        }
+        const dep = module.addDependency(
+          depData.request,
+          depModule,
+          depData.kind,
+          depData.statements.map(getStatement)
+        );
+        if (!dep) {
+          continue;
+        }
+        dep.id = depData.id;
+        moduleGraph.addDependency(dep);
+      }
+      for (const normalModuleId of moduleData.modules ?? []) {
+        const normalModule = moduleGraph.getModuleById(normalModuleId);
+        if (!normalModule) {
+          console.warn(
+            `Add the ordinary module ID as empty: ${normalModuleId}`
+          );
+          continue;
+        }
+        module.addNormalModule(normalModule);
+      }
+      for (const concatenationModuleId of moduleData.concatenationModules ?? []) {
+        const concatenationModule = moduleGraph.getModuleById(
+          concatenationModuleId
+        );
+        if (!concatenationModule) {
+          console.warn(
+            `The aggregation module ID is empty: ${concatenationModule}`
+          );
+          continue;
+        }
+        module.addConcatenationModule(concatenationModule);
+      }
+    }
+    for (const exportData of data.exports ?? []) {
+      const info = new ExportInfo(
+        exportData.name,
+        exportData.identifier ? getStatement(exportData.identifier) : void 0
+      );
+      info.id = exportData.id;
+      moduleGraph.addExportInfo(info);
+    }
+    for (const exportData of data.exports ?? []) {
+      if (exportData.from) {
+        const current = moduleGraph._exportIdMap.get(exportData.id);
+        const from = moduleGraph._exportIdMap.get(exportData.from);
+        if (current && from) {
+          current.setFromExport(from);
+        }
+      }
+    }
+    for (const varData of data.variables ?? []) {
+      const module = moduleGraph.getModuleById(varData.module);
+      if (!module) {
+        console.warn(
+          `The module ID in the variable is empty：${varData.module}`
+        );
+        continue;
+      }
+      const info = new Variable(
+        varData.name,
+        module,
+        varData.usedInfo,
+        getStatement(varData.identifier)
+      );
+      const exportInfo = moduleGraph._exportIdMap.get(varData.exported ?? -1);
+      if (exportInfo) {
+        info.setExportInfo(exportInfo);
+      }
+      info.id = varData.id;
+      moduleGraph.addVariable(info);
+    }
+    for (const sideData of data.sideEffects ?? []) {
+      const module = moduleGraph.getModuleById(sideData.module);
+      if (!module) {
+        console.warn(
+          `The module ID in the side effects is empty：${sideData.module}`
+        );
+        continue;
+      }
+      const info = new SideEffect(
+        sideData.name,
+        module,
+        getStatement(sideData.identifier),
+        sideData.originName
+      );
+      info.isNameSpace = sideData.isNameSpace;
+      info.id = sideData.id;
+      for (const exportId of sideData.exports ?? []) {
+        const exportInfo = moduleGraph._exportIdMap.get(exportId);
+        if (exportInfo) {
+          exportInfo.addSideEffect(info);
+        }
+      }
+      if (sideData.variable) {
+        const varInfo = moduleGraph._varIdMap.get(sideData.variable);
+        if (varInfo) {
+          info._variable = varInfo;
+        }
+      }
+      moduleGraph.addSideEffect(info);
+    }
+    for (const mgmData of data.moduleGraphModules ?? []) {
+      const module = moduleGraph.getModuleById(mgmData.module);
+      if (!module) {
+        console.warn(
+          `The module ID in ModuleGraphModule is empty: ${mgmData.module}`
+        );
+        continue;
+      }
+      const mgm = new ModuleGraphModule(module, moduleGraph, mgmData.dynamic);
+      moduleGraph.addModuleGraphModule(mgm);
+      mgmData.exports.forEach((id) => {
+        const info = moduleGraph._exportIdMap.get(id);
+        if (info) {
+          mgm.addExportInfo(info);
+        }
+      });
+      mgmData.sideEffects.forEach((id) => {
+        const info = moduleGraph._sideEffectIdMap.get(id);
+        if (info) {
+          mgm.addSideEffect(info);
+        }
+      });
+      mgmData.variables.forEach((id) => {
+        const info = moduleGraph._varIdMap.get(id);
+        if (info) {
+          mgm.addVariable(info);
+        }
+      });
+    }
+    ModuleGraph.init();
+    return moduleGraph;
+  }
+  clear() {
+    this._dependenciesIdMap = /* @__PURE__ */ new Map();
+    this._moduleWebpackIdMap = /* @__PURE__ */ new Map();
+    this._moduleIdMap = /* @__PURE__ */ new Map();
+    this._moduleGraphModules = /* @__PURE__ */ new Map();
+    this._exportIdMap = /* @__PURE__ */ new Map();
+    this._sideEffectIdMap = /* @__PURE__ */ new Map();
+    this._varIdMap = /* @__PURE__ */ new Map();
+  }
+  size() {
+    return this._moduleIdMap.size;
+  }
+  fromInstance(data) {
+    this._dependenciesIdMap = new Map(data._dependenciesIdMap);
+    this._moduleWebpackIdMap = new Map(data._moduleWebpackIdMap);
+    this._moduleIdMap = new Map(data._moduleIdMap);
+    this._moduleGraphModules = new Map(data._moduleGraphModules);
+    this._exportIdMap = new Map(data._exportIdMap);
+    this._sideEffectIdMap = new Map(data._sideEffectIdMap);
+    this._varIdMap = new Map(data._varIdMap);
+  }
+  getSubGraphByModule(module) {
+    const map = /* @__PURE__ */ new Set();
+    const result = [module];
+    map.add(module);
+    for (let i = 0; i < result.length; i++) {
+      const current = result[i];
+      for (const { dependency: depModule } of current.getDependencies()) {
+        if (map.has(depModule)) {
+          continue;
+        }
+        map.add(depModule);
+        result.push(depModule);
+      }
+    }
+    return result;
+  }
+  getModules() {
+    return Array.from(this._moduleWebpackIdMap.values());
+  }
+  getDependencies() {
+    return Array.from(this._dependenciesIdMap.values());
+  }
+  getEntryModules() {
+    return this.getModules().filter(
+      (item) => item.isEntry && item.kind !== SDK.ModuleKind.Concatenation
+    );
+  }
+  getModuleById(id) {
+    return this._moduleIdMap.get(id);
+  }
+  getDependencyById(id) {
+    return this._dependenciesIdMap.get(id);
+  }
+  getModuleByWebpackId(id) {
+    return this._moduleWebpackIdMap.get(id);
+  }
+  getModuleByFile(file) {
+    return this.getModules().find((item) => item.path === file);
+  }
+  addModule(...modules) {
+    for (const module of modules) {
+      if (!this._moduleIdMap.has(module.id)) {
+        this._moduleWebpackIdMap.set(module.webpackId, module);
+        this._moduleIdMap.set(module.id, module);
+      }
+    }
+  }
+  addDependency(...deps) {
+    for (const dep of deps) {
+      if (!this._dependenciesIdMap.has(dep.id)) {
+        this._dependenciesIdMap.set(dep.id, dep);
+        this.addModule(dep.module);
+        this.addModule(dep.dependency);
+      }
+    }
+  }
+  removeModule(module) {
+    this._moduleIdMap.delete(module.id);
+    this._moduleWebpackIdMap.delete(module.webpackId);
+    for (const dep of module.getDependencies()) {
+      this.removeDependency(dep);
+      this._dependenciesIdMap.delete(dep.id);
+    }
+    for (const imported of module.getImported()) {
+      imported.removeDependencyByModule(imported);
+    }
+  }
+  removeDependency(dep) {
+    dep.module.removeDependency(dep);
+    dep.dependency.removeImported(dep.module);
+    this._dependenciesIdMap.delete(dep.id);
+  }
+  addModuleGraphModule(mgm) {
+    if (!this._moduleGraphModules.has(mgm.module)) {
+      this._moduleGraphModules.set(mgm.module, mgm);
+    }
+  }
+  getModuleGraphModule(module) {
+    return this._moduleGraphModules.get(module);
+  }
+  getModuleGraphModules() {
+    return Array.from(this._moduleGraphModules.values());
+  }
+  addExportInfo(data) {
+    this._exportIdMap.set(data.id, data);
+  }
+  addSideEffect(data) {
+    this._sideEffectIdMap.set(data.id, data);
+  }
+  addVariable(data) {
+    this._varIdMap.set(data.id, data);
+  }
+  toData(configs) {
+    return {
+      dependencies: this.getDependencies().map((item) => item.toData()),
+      modules: this.getModules().map(
+        (item) => item.toData(configs?.contextPath)
+      ),
+      moduleGraphModules: Array.from(this._moduleGraphModules.values()).map(
+        (item) => item.toData()
+      ),
+      exports: Array.from(this._exportIdMap.values()).map(
+        (item) => item.toData()
+      ),
+      sideEffects: Array.from(this._sideEffectIdMap.values()).map(
+        (item) => item.toData()
+      ),
+      variables: Array.from(this._varIdMap.values()).map(
+        (item) => item.toData()
+      )
+    };
+  }
+  toCodeData(type = SDK.ToDataType.Normal) {
+    const codeMap = {};
+    this.getModules().forEach((item) => {
+      codeMap[item.id] = item.getSource(type);
+    });
+    return codeMap;
+  }
+}
+export {
+  ModuleGraph
+};

package/dist/esm/graph/module-graph/index.js

@@ -0,0 +1,6 @@
+export * from "./dependency";
+export * from "./module";
+export * from "./graph";
+export * from "./statement";
+export * from "./tree-shaking";
+export * from "./types";

package/dist/esm/graph/module-graph/module.js

@@ -0,0 +1,250 @@
+import { SDK } from "@rsdoctor/types";
+import path from "path";
+import { isNumber } from "lodash";
+import { Dependency } from "./dependency";
+import { Statement } from "./statement";
+import { getModuleName } from "./utils";
+let id = 1;
+class Module {
+  constructor(webpackId, path2, isEntry = false, kind = SDK.ModuleKind.Normal) {
+    this.source = {
+      source: "",
+      transformed: "",
+      parsedSource: ""
+    };
+    this.size = {
+      sourceSize: 0,
+      transformedSize: 0,
+      parsedSize: 0
+    };
+    this.chunks = [];
+    this.dependencies = [];
+    this.imported = [];
+    this.modules = [];
+    this.concatenationModules = [];
+    this.meta = {
+      hasSetEsModuleStatement: false,
+      strictHarmonyModule: false
+    };
+    this.id = id++;
+    this.webpackId = webpackId;
+    this.path = path2;
+    this.isEntry = isEntry;
+    this.kind = kind;
+  }
+  static init() {
+    id = 1;
+  }
+  get rootModule() {
+    return this.modules.find((item) => item.path === this.path);
+  }
+  get isPreferSource() {
+    if (typeof this._isPreferSource === "boolean") {
+      return this._isPreferSource;
+    }
+    const result = this.source.source.length > 0 && this.source.source !== "test code" && Boolean(this.sourceMap);
+    this._isPreferSource = result;
+    return result;
+  }
+  getChunks() {
+    return this.chunks.slice();
+  }
+  addChunk(chunk) {
+    if (!this.chunks.includes(chunk)) {
+      this.chunks.push(chunk);
+      chunk.addModule(this);
+    }
+  }
+  removeChunk(chunk) {
+    this.chunks = this.chunks.filter((item) => item !== chunk);
+  }
+  getDependencies() {
+    return this.dependencies.slice();
+  }
+  getDependencyByRequest(request) {
+    return this.dependencies.find((item) => item.request === request);
+  }
+  getDependencyByModule(module) {
+    return this.dependencies.find(
+      (item) => item.originDependency === module || item.dependency === module
+    );
+  }
+  addDependency(request, module, kind, statements) {
+    const dep = new Dependency(request, this, module, kind, statements);
+    if (this.dependencies.every((item) => !item.isSameWithoutStatements(dep))) {
+      this.dependencies.push(dep);
+      module.addImported(this);
+      if (module.rootModule) {
+        module.rootModule.addImported(this);
+      }
+      return dep;
+    }
+  }
+  removeDependency(dep) {
+    this.dependencies = this.dependencies.filter((item) => item === dep);
+  }
+  removeDependencyByModule(module) {
+    const dep = this.getDependencyByModule(module);
+    if (dep) {
+      this.removeDependency(dep);
+    }
+  }
+  getImported() {
+    return this.imported.slice();
+  }
+  addImported(module) {
+    if (!this.imported.includes(module)) {
+      this.imported.push(module);
+    }
+  }
+  removeImported(module) {
+    this.imported = this.imported.filter((item) => item === module);
+  }
+  setProgram(program) {
+    this.program = program;
+  }
+  getProgram() {
+    return this.program;
+  }
+  setSource(input) {
+    const { source } = this;
+    source.source = input.source ?? source.source;
+    source.transformed = input.transformed ?? source.transformed;
+    source.parsedSource = input.parsedSource ?? source.parsedSource;
+  }
+  getSource(type = SDK.ToDataType.Normal) {
+    return type === SDK.ToDataType.Lite ? {
+      source: "",
+      transformed: "",
+      parsedSource: this.source.parsedSource
+    } : this.isPreferSource ? {
+      source: this.source.source,
+      transformed: "",
+      parsedSource: ""
+    } : {
+      source: this.source.source,
+      transformed: this.source.transformed,
+      parsedSource: this.source.parsedSource
+    };
+  }
+  setSourceMap(sourceMap) {
+    this.sourceMap = sourceMap;
+  }
+  getSourceMap() {
+    return this.sourceMap;
+  }
+  setSize(input) {
+    const { size } = this;
+    size.sourceSize = input.sourceSize ?? size.sourceSize;
+    size.transformedSize = input.transformedSize ?? size.transformedSize;
+    size.parsedSize = input.parsedSize ?? size.parsedSize;
+  }
+  getSize() {
+    return { ...this.size };
+  }
+  getStatement(transformed) {
+    return new Statement(this, {
+      source: this.getSourceRange(transformed),
+      transformed: {
+        start: { ...transformed.start },
+        end: transformed.end ? { ...transformed.end } : void 0
+      }
+    });
+  }
+  getSourceRange(transformed) {
+    const { sourceMap } = this;
+    if (!sourceMap) {
+      return;
+    }
+    const source = {
+      start: {}
+    };
+    const startInSource = sourceMap.originalPositionFor({
+      line: transformed.start.line ?? 0,
+      column: transformed.start.column ?? 0,
+      // The largest lower bound.
+      bias: 1
+    });
+    if (isNumber(startInSource.line)) {
+      source.start = {
+        line: startInSource.line,
+        column: startInSource.column ?? void 0
+      };
+    }
+    if (transformed.end) {
+      const endInSource = sourceMap.originalPositionFor({
+        line: transformed.end.line ?? 0,
+        column: transformed.end.column ?? 0
+        // The smallest lower bound
+        // bias: 2,
+      });
+      if (isNumber(endInSource.line)) {
+        source.end = {
+          line: endInSource.line,
+          column: endInSource.column ?? void 0
+        };
+      }
+    }
+    return source;
+  }
+  addNormalModule(module) {
+    if (!this.modules.includes(module)) {
+      this.modules.push(module);
+      module.addConcatenationModule(this);
+    }
+  }
+  getNormalModules() {
+    return this.modules.slice();
+  }
+  addConcatenationModule(module) {
+    if (!this.concatenationModules.includes(module)) {
+      this.concatenationModules.push(module);
+    }
+  }
+  getConcatenationModules() {
+    return this.concatenationModules.slice();
+  }
+  toData(contextPath) {
+    const { isPreferSource } = this;
+    const moduleName = getModuleName(this.webpackId);
+    const data = {
+      id: this.id,
+      webpackId: contextPath && moduleName.indexOf(".") > 0 ? path.relative(contextPath, moduleName) : this.webpackId,
+      path: this.path,
+      isPreferSource,
+      dependencies: this.dependencies.map((item) => item.id),
+      imported: this.imported.map((item) => item.id),
+      chunks: this.chunks.map((item) => item.id),
+      size: this.getSize(),
+      kind: this.kind
+    };
+    if (this.meta.hasSetEsModuleStatement || this.meta.strictHarmonyModule) {
+      data.meta = {};
+      if (this.meta.hasSetEsModuleStatement) {
+        data.meta.hasSetEsModuleStatement = true;
+      }
+      if (this.meta.strictHarmonyModule) {
+        data.meta.strictHarmonyModule = true;
+      }
+    }
+    if (this.isEntry) {
+      data.isEntry = this.isEntry;
+    }
+    if (this.modules.length > 0) {
+      data.modules = this.modules.map((item) => item.id);
+    }
+    if (this.rootModule) {
+      data.rootModule = this.rootModule.id;
+    }
+    if (this.concatenationModules.length > 0) {
+      data.concatenationModules = this.concatenationModules.map(
+        (data2) => data2.id
+      );
+    }
+    return data;
+  }
+}
+Module.kind = SDK.ModuleKind;
+export {
+  Module
+};

package/dist/esm/graph/module-graph/statement.js

@@ -0,0 +1,58 @@
+import { isSameRange } from "./utils";
+class Statement {
+  static getDefaultStatement(module) {
+    const defaultPosition = {
+      line: 1,
+      column: 0
+    };
+    const defaultRange = {
+      start: { ...defaultPosition },
+      end: { ...defaultPosition }
+    };
+    return new Statement(module, {
+      source: { ...defaultRange },
+      transformed: { ...defaultRange }
+    });
+  }
+  constructor(module, position) {
+    this.module = module;
+    this.position = position;
+  }
+  isSame(statement) {
+    return this.module.id === statement.module.id && isSameRange(this.position.transformed, statement.position.transformed);
+  }
+  getSourcePosition() {
+    const { module, position } = this;
+    if (position.source) {
+      return position.source;
+    }
+    if (module.getSourceMap()) {
+      position.source = module.getSourceRange(position.transformed);
+      return position.source;
+    }
+  }
+  getLineCode() {
+    const useSource = this.module.isPreferSource && this.position.source;
+    const sourceCode = this.module.getSource();
+    const source = useSource ? sourceCode.source : sourceCode.transformed;
+    const line = useSource ? this.position.source.start.line : this.position.transformed.start.line;
+    if (typeof line === "number") {
+      return source.split("\n")[line - 1];
+    }
+  }
+  toData() {
+    const position = {
+      transformed: this.position.transformed
+    };
+    if (this.position.source) {
+      position.source = this.position.source;
+    }
+    return {
+      position,
+      module: this.module.id
+    };
+  }
+}
+export {
+  Statement
+};