@rsdoctor/graph 0.0.2-beta.0

package/dist/esm/graph/module-graph/tree-shaking/export.js

@@ -0,0 +1,83 @@
+let id = 1;
+class ExportInfo {
+  constructor(name, identifier, variable) {
+    this.id = id++;
+    this._sideEffects = [];
+    this.name = name;
+    this.identifier = identifier;
+    this._variable = variable;
+  }
+  static init() {
+    id = 1;
+  }
+  get isReExport() {
+    return Boolean(this.from);
+  }
+  set variable(data) {
+    this._variable = data;
+  }
+  get variable() {
+    if (this._variable) {
+      return this._variable;
+    }
+    if (!this.from || this._variable === false) {
+      this._variable = false;
+      return;
+    }
+    const result = this.getRecursiveExport()?.variable;
+    if (!result) {
+      this._variable = false;
+    }
+    return result;
+  }
+  addSideEffect(info) {
+    if (this._sideEffects.every((item) => item.id !== info.id)) {
+      this._sideEffects.push(info);
+      if (this.from) {
+        this.from.addSideEffect(info);
+      }
+    }
+  }
+  getSideEffects() {
+    return this._sideEffects.slice();
+  }
+  setFromExport(from) {
+    this.from = from;
+  }
+  getRecursiveExport(depth = Infinity) {
+    if (depth === 0) {
+      throw new Error(
+        "`getRecursiveExport` method parameter depth must be greater than 1."
+      );
+    }
+    if (!this.from) {
+      return this;
+    }
+    let currentDepth = 0;
+    let current = this;
+    while (current.from && currentDepth < depth) {
+      currentDepth++;
+      current = current.from;
+    }
+    return current;
+  }
+  toData() {
+    const data = {
+      id: this.id,
+      name: this.name,
+      isReExport: this.isReExport,
+      used: this._sideEffects.map((item) => item.id)
+    };
+    if (this.from) {
+      data.from = this.from.id;
+      data.root = this.getRecursiveExport().id;
+    }
+    if (this.variable) {
+      data.variable = this.variable.id;
+    }
+    return data;
+  }
+}
+export {
+  ExportInfo
+};

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

@@ -0,0 +1,5 @@
+export * from "./module";
+export * from "./export";
+export * from "./variable";
+export * from "./sideEffect";
+export * from "./types";

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

@@ -0,0 +1,74 @@
+import { ExportInfo } from "./export";
+import { SideEffect } from "./sideEffect";
+import { Variable } from "./variable";
+class ModuleGraphModule {
+  constructor(module, graph, dynamic) {
+    this.exports = [];
+    this.sideEffects = [];
+    this.variables = [];
+    this.module = module;
+    this._graph = graph;
+    if (typeof this._dynamic === "boolean") {
+      this._dynamic = dynamic;
+    }
+  }
+  static init() {
+    ExportInfo.init();
+    SideEffect.init();
+    Variable.init();
+  }
+  get dynamic() {
+    if (typeof this._dynamic === "boolean") {
+      return this._dynamic;
+    }
+    return this.module.getImported().map((item) => item.getDependencyByModule(this.module)).some((item) => item && item.meta.exportsType === "dynamic");
+  }
+  addExportInfo(data) {
+    this.exports.push(data);
+    this._graph.addExportInfo(data);
+  }
+  addSideEffect(data) {
+    this.sideEffects.push(data);
+    this._graph.addSideEffect(data);
+  }
+  addVariable(data) {
+    this.variables.push(data);
+    this._graph.addVariable(data);
+  }
+  getExports() {
+    return this.exports.slice();
+  }
+  getSideEffects(name) {
+    if (name) {
+      return this.sideEffects.filter((item) => item.name === name);
+    }
+    return this.sideEffects.slice();
+  }
+  getOwnExports() {
+    return this.exports.filter((item) => !item.isReExport);
+  }
+  getExport(name) {
+    return this.exports.find((item) => item.name === name);
+  }
+  getReExports() {
+    return this.exports.filter((item) => item.isReExport);
+  }
+  getOwnExport(name) {
+    return this.getOwnExports().find((item) => item.name === name);
+  }
+  getReExport(name) {
+    return this.getReExports().find((item) => item.name === name);
+  }
+  toData() {
+    return {
+      module: this.module.id,
+      dynamic: this.dynamic,
+      exports: this.exports.map((item) => item.id),
+      sideEffects: this.sideEffects.map((item) => item.id),
+      variables: this.variables.map((item) => item.id)
+    };
+  }
+}
+export {
+  ModuleGraphModule
+};

package/dist/esm/graph/module-graph/tree-shaking/sideEffect.js

@@ -0,0 +1,70 @@
+let id = 1;
+const _SideEffect = class _SideEffect {
+  constructor(name, module, identifier, fromRequest, originName) {
+    this.id = id++;
+    this._exports = [];
+    this.name = name;
+    this.module = module;
+    this.identifier = identifier;
+    if (fromRequest) {
+      this.fromDependency = this.module.getDependencyByRequest(fromRequest);
+    }
+    if (originName === _SideEffect.NamespaceSymbol) {
+      this.isNameSpace = true;
+    } else {
+      this.isNameSpace = false;
+      this.originName = originName;
+    }
+  }
+  static init() {
+    id = 1;
+  }
+  get variable() {
+    if (typeof this._variable !== "undefined") {
+      if (this._variable) {
+        return this._variable;
+      }
+      return;
+    }
+    const result = this.exports[0]?.getRecursiveExport()?.variable;
+    this._variable = result ?? false;
+    return result;
+  }
+  get exports() {
+    return this._exports?.slice() ?? [];
+  }
+  setModuleExport(mgm) {
+    mgm.getExports().forEach((info) => this.setExportInfo(info));
+  }
+  setExportInfo(info) {
+    this._exports.push(info);
+    info.addSideEffect(this);
+  }
+  toData() {
+    const data = {
+      id: this.id,
+      name: this.name,
+      identifier: this.identifier.toData(),
+      module: this.module.id
+    };
+    if (this.fromDependency) {
+      data.fromDependency = this.fromDependency.id;
+    }
+    if (this.isNameSpace) {
+      data.isNameSpace = this.isNameSpace;
+    }
+    if (this.exports.length > 0) {
+      data.exports = this.exports.map((item) => item.id);
+    }
+    if (this.variable) {
+      data.variable = this.variable.id;
+    }
+    return data;
+  }
+};
+/** Name import tags */
+_SideEffect.NamespaceSymbol = Symbol("namespace");
+let SideEffect = _SideEffect;
+export {
+  SideEffect
+};

package/dist/esm/graph/module-graph/tree-shaking/variable.js

@@ -0,0 +1,39 @@
+let id = 1;
+class Variable {
+  constructor(name, module, usedInfo, identifier) {
+    this.id = id++;
+    this.name = name;
+    this.module = module;
+    this.usedInfo = usedInfo;
+    this.identifier = identifier;
+  }
+  static init() {
+    id = 1;
+  }
+  get isUsed() {
+    return this._exported ? this._exported.getSideEffects().length > 0 : false;
+  }
+  setExportInfo(info) {
+    this._exported = info;
+    info.variable = this;
+  }
+  getExportInfo() {
+    return this._exported;
+  }
+  toData() {
+    const data = {
+      id: this.id,
+      name: this.name,
+      module: this.module.id,
+      identifier: this.identifier.toData(),
+      usedInfo: this.usedInfo
+    };
+    if (this._exported) {
+      data.exported = this._exported.id;
+    }
+    return data;
+  }
+}
+export {
+  Variable
+};

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

@@ -0,0 +1,39 @@
+import { last, isUndefined, isNil } from "lodash";
+function isSamePosition(po1, po2) {
+  return po1.line === po2.line && po1.column === po2.column;
+}
+function isSameRange(po1, po2) {
+  if (!isSamePosition(po1.start, po2.start)) {
+    return false;
+  }
+  if (!isNil(po1.end) && !isNil(po2.end)) {
+    return isSamePosition(po1.end, po2.end);
+  }
+  return isUndefined(po1.end) && isUndefined(po2.end);
+}
+const NAME_WITH_LOADERS = /!/;
+const NAME_WITH_MODULES = /\s\+\s\d*\smodules$/;
+const INVALID_CSS_PREFIX = /^css\s.*node_modules(?!\/)/;
+function getModuleName(name) {
+  if (!name) {
+    return "";
+  }
+  if (NAME_WITH_LOADERS.test(name)) {
+    const normalizedName = last(name.split(NAME_WITH_LOADERS));
+    if (normalizedName?.trim()) {
+      return normalizedName;
+    }
+  }
+  if (NAME_WITH_MODULES.test(name)) {
+    return name.replace(NAME_WITH_MODULES, "");
+  }
+  if (INVALID_CSS_PREFIX.test(name)) {
+    return name.replace(INVALID_CSS_PREFIX, "");
+  }
+  return name;
+}
+export {
+  getModuleName,
+  isSamePosition,
+  isSameRange
+};

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

@@ -0,0 +1,32 @@
+let id = 1;
+class PackageDependency {
+  constructor(pack, dep, refDependency) {
+    this.id = id++;
+    this.package = pack;
+    this.dependency = dep;
+    this.refDependency = refDependency;
+  }
+  get name() {
+    return this.dependency.name;
+  }
+  get version() {
+    return this.dependency.version;
+  }
+  get root() {
+    return this.dependency.root;
+  }
+  isSame(dep) {
+    return this.refDependency === dep.refDependency && this.dependency.isSame(dep.dependency);
+  }
+  toData() {
+    return {
+      id: this.id,
+      dependency: this.dependency.id,
+      package: this.package.id,
+      refDependency: this.refDependency.id
+    };
+  }
+}
+export {
+  PackageDependency
+};

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

@@ -0,0 +1,149 @@
+import { unionBy } from "lodash";
+import { dirname, join, resolve } from "path";
+import { SDK } from "@rsdoctor/types";
+import { Package as PackageUtil } from "@rsdoctor/utils/common";
+import { Package } from "./package";
+import { PackageDependency } from "./dependency";
+class PackageGraph {
+  constructor(root) {
+    this._dependencies = [];
+    this._packages = [];
+    this._pkgNameMap = /* @__PURE__ */ new Map();
+    this._pkgFileMap = /* @__PURE__ */ new Map();
+    this._root = root;
+  }
+  static fromModuleGraph(graph, root, getPackageFile) {
+    const pkgGraph = new PackageGraph(root);
+    const modules = graph.getModules().filter((item) => item.kind === SDK.ModuleKind.Normal);
+    for (const item of modules) {
+      const pkg = pkgGraph.getPackageByModule(item, getPackageFile);
+      if (pkg) {
+        pkgGraph.addPackage(pkg);
+        pkg.addModule(item);
+      }
+    }
+    for (const dep of graph.getDependencies()) {
+      const modulePkg = pkgGraph.getPackageByFile(dep.module.path);
+      const dependencyPkg = pkgGraph.getPackageByFile(dep.dependency.path);
+      if (modulePkg && dependencyPkg && !modulePkg.isSame(dependencyPkg)) {
+        const pkgDep = new PackageDependency(modulePkg, dependencyPkg, dep);
+        pkgGraph.addDependency(pkgDep);
+        modulePkg.addDependency(pkgDep);
+      }
+    }
+    return pkgGraph;
+  }
+  getPackages() {
+    return this._packages.slice();
+  }
+  getPackageByModule(module, readFile) {
+    const { path: file, meta } = module;
+    const { _pkgFileMap: pkgsMap } = this;
+    const getPackageByData = (data2) => {
+      return this.getPackageByData(data2) ?? new Package(data2.name, data2.root, data2.version);
+    };
+    if (pkgsMap.has(file)) {
+      return pkgsMap.get(file);
+    }
+    if (meta.packageData) {
+      const pkg2 = getPackageByData(meta.packageData);
+      pkgsMap.set(file, pkg2);
+      return pkg2;
+    }
+    const readPackageJson = (file2, readFile2) => {
+      let result;
+      let current = file2;
+      while (current !== "/" && !result) {
+        if (dirname(current) === current) {
+          break;
+        }
+        current = dirname(current);
+        if (readFile2) {
+          result = readFile2(join(current, "package.json")) || PackageUtil.getPackageMetaFromModulePath(file2);
+        }
+        if (!readFile2) {
+          result = PackageUtil.getPackageMetaFromModulePath(file2);
+        } else if (!result?.name) {
+          result = void 0;
+        }
+      }
+      if (!result) {
+        return;
+      }
+      if (readFile2 && (!result.name || !result.version)) {
+        return readPackageJson(dirname(current), readFile2);
+      }
+      return {
+        ...result,
+        root: current
+      };
+    };
+    const cache = this.getPackageContainFile(file);
+    if (cache) {
+      pkgsMap.set(file, cache);
+      return cache;
+    }
+    const data = readPackageJson(file, readFile);
+    if (!data) {
+      return;
+    }
+    if (data.root.startsWith(".")) {
+      data.root = resolve(this._root, data.root);
+    }
+    const pkg = getPackageByData(data);
+    this.addPackage(pkg);
+    pkgsMap.set(file, pkg);
+    return pkg;
+  }
+  getPackageByFile(file) {
+    return this._pkgFileMap.get(file);
+  }
+  getPackageContainFile(file) {
+    return this._packages.find((pkg) => pkg.contain(file));
+  }
+  getPackagesByName(name) {
+    return this._pkgNameMap.get(name) ?? [];
+  }
+  getPackageByData(data) {
+    return this._pkgNameMap.get(data.name)?.find(
+      (item) => item.version === data.version && item.root === data.root
+    );
+  }
+  addPackage(pkg) {
+    if (this._packages.every((item) => !item.isSame(pkg))) {
+      this._packages.push(pkg);
+      const { _pkgNameMap: map } = this;
+      const arr = map.get(pkg.name) ?? [];
+      if (arr.every((item) => !item.isSame(pkg))) {
+        arr.push(pkg);
+        map.set(pkg.name, arr);
+      }
+    }
+  }
+  getDependenciesFromPackage(pkg) {
+    return this._dependencies.filter((dep) => dep.dependency === pkg);
+  }
+  addDependency(dep) {
+    if (this._dependencies.every((item) => !item.isSame(dep))) {
+      this._dependencies.push(dep);
+    }
+  }
+  getDependenciesFromOrigin() {
+    return this._dependencies.filter((item) => !item.package);
+  }
+  getDuplicatePackages() {
+    return unionBy(
+      Array.from(this._pkgNameMap.values()).filter((pkgs) => pkgs.length > 1),
+      (pkgs) => pkgs[0].name
+    );
+  }
+  toData() {
+    return {
+      packages: this._packages.map((e) => e.toData()),
+      dependencies: this._dependencies.map((d) => d.toData())
+    };
+  }
+}
+export {
+  PackageGraph
+};

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

@@ -0,0 +1,4 @@
+export * from "./dependency";
+export * from "./graph";
+export * from "./package";
+export * from "./types";

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

@@ -0,0 +1,97 @@
+import { relative } from "path";
+import { isPackagePath } from "./utils";
+let id = 1;
+class Package {
+  constructor(name, root, version) {
+    this.id = id++;
+    this._modules = [];
+    this._dependencies = [];
+    this._imported = [];
+    this.name = name;
+    this.root = root;
+    this.version = version;
+  }
+  getModules() {
+    return this._modules.slice();
+  }
+  getDependencies() {
+    return this._dependencies.slice();
+  }
+  getImported() {
+    return this._imported.slice();
+  }
+  addModule(module) {
+    if (!this._modules.includes(module)) {
+      this._modules.push(module);
+    }
+  }
+  addDependency(dep) {
+    if (this._dependencies.every((item) => !item.isSame(dep))) {
+      this._dependencies.push(dep);
+      dep.dependency.addImported(this);
+    }
+  }
+  getDependenciesChain(graph) {
+    function getImported(pkg, ans) {
+      const dependencies = graph.getDependenciesFromPackage(pkg);
+      for (const dep of dependencies) {
+        if (!dep.refDependency) {
+          continue;
+        }
+        if (ans.some((dep2) => dep2.dependency === pkg)) {
+          continue;
+        }
+        if (!dep.package) {
+          return ans.concat(dep);
+        }
+        return getImported(dep.package, ans.concat(dep));
+      }
+      return ans;
+    }
+    return getImported(this, []);
+  }
+  addImported(pkg) {
+    if (!this._imported.includes(pkg)) {
+      this._imported.push(pkg);
+    }
+  }
+  contain(file) {
+    const subPath = relative(this.root, file);
+    if (subPath.startsWith("..")) {
+      return false;
+    }
+    return !isPackagePath(subPath);
+  }
+  isSame(pkg) {
+    return this.root === pkg.root && this.version === pkg.version && this.name === pkg.name;
+  }
+  getSize() {
+    return this._modules.reduce(
+      (ans, item) => {
+        const size = item.getSize();
+        ans.sourceSize += size.sourceSize;
+        ans.transformedSize += size.transformedSize;
+        ans.parsedSize += size.parsedSize;
+        return ans;
+      },
+      {
+        sourceSize: 0,
+        transformedSize: 0,
+        parsedSize: 0
+      }
+    );
+  }
+  toData() {
+    return {
+      id: this.id,
+      name: this.name,
+      root: this.root,
+      version: this.version,
+      modules: this.getModules().map((e) => e.id),
+      size: this.getSize()
+    };
+  }
+}
+export {
+  Package
+};

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

@@ -0,0 +1,6 @@
+function isPackagePath(path) {
+  return /(^|[/\\])node_modules[/\\]/.test(path);
+}
+export {
+  isPackagePath
+};

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from "./graph";

package/dist/type/graph/chunk-graph/asset.d.ts

@@ -0,0 +1,10 @@
+import { SDK } from '@rsdoctor/types';
+import { Chunk } from './chunk';
+export declare class Asset implements SDK.AssetInstance {
+  path: string;
+  size: number;
+  content: string;
+  chunks: Chunk[];
+  constructor(path: string, size: number, chunks: Chunk[], content: string);
+  toData(types: SDK.ToDataType): SDK.AssetData;
+}

package/dist/type/graph/chunk-graph/chunk.d.ts

@@ -0,0 +1,30 @@
+import { SDK } from '@rsdoctor/types';
+import { Module } from '../module-graph';
+import { Asset } from './asset';
+export declare class Chunk implements SDK.ChunkInstance {
+  readonly id: string;
+  readonly name: string;
+  readonly size: number;
+  readonly initial: boolean;
+  readonly entry: boolean;
+  private _assets;
+  private _modules;
+  private _dependencies;
+  private _imported;
+  private _parsedSize;
+  constructor(id: string, name: string, size: number, initial: boolean, entry: boolean);
+  isEntry(): boolean;
+  isChunkEntryModule(module: Module): boolean;
+  hasModule(module: Module): boolean;
+  addModule(module: Module): void;
+  addAsset(asset: Asset): void;
+  addModules(modules: Module[]): void;
+  addDependency(dep: Chunk): void;
+  addImported(imported: Chunk): void;
+  getAssets(): Asset[];
+  getModules(): Module[];
+  getDependencies(): Chunk[];
+  getImported(): Chunk[];
+  setParsedSize(parsedSize: number): void;
+  toData(): SDK.ChunkData;
+}

package/dist/type/graph/chunk-graph/entrypoint.d.ts

@@ -0,0 +1,12 @@
+import { SDK } from '@rsdoctor/types';
+import type { Asset } from './asset';
+import type { Chunk } from './chunk';
+export declare class EntryPoint implements SDK.EntryPointInstance {
+  readonly name: string;
+  constructor(name: string);
+  private _chunks;
+  private _assets;
+  addChunk(chunk: Chunk): void;
+  addAsset(asset: Asset): void;
+  toData(): SDK.EntryPointData;
+}

package/dist/type/graph/chunk-graph/graph.d.ts

@@ -0,0 +1,22 @@
+import { SDK } from '@rsdoctor/types';
+import type { Asset } from './asset';
+import type { Chunk } from './chunk';
+import type { Module } from '../module-graph';
+import type { EntryPoint } from './entrypoint';
+export declare class ChunkGraph implements SDK.ChunkGraphInstance {
+  private _assets;
+  private _chunks;
+  private _entrypoints;
+  getAssets(): Asset[];
+  getChunks(): Chunk[];
+  addAsset(...assets: Asset[]): void;
+  addChunk(...chunks: Chunk[]): void;
+  getChunkById(id: string): Chunk | undefined;
+  getChunkByModule(module: Module): Chunk | undefined;
+  getAssetByPath(path: string): Asset | undefined;
+  getAssetsByChunk(chunk: Chunk): Asset[] | undefined;
+  getEntryPoints(): EntryPoint[];
+  addEntryPoint(...entrypoints: EntryPoint[]): void;
+  /** output the chunk graph data */
+  toData(type: SDK.ToDataType): SDK.ChunkGraphData;
+}