@rsdoctor/graph 0.0.0-next-20240620044732

package/dist/cjs/graph/package-graph/graph.js

@@ -0,0 +1,175 @@
+"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 graph_exports = {};
+__export(graph_exports, {
+  PackageGraph: () => PackageGraph
+});
+module.exports = __toCommonJS(graph_exports);
+var import_lodash = require("lodash");
+var import_path = require("path");
+var import_types = require("@rsdoctor/types");
+var import_common = require("@rsdoctor/utils/common");
+var import_package = require("./package");
+var import_dependency = require("./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 === import_types.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 import_dependency.PackageDependency(modulePkg, dependencyPkg, dep);
+        pkgGraph.addDependency(pkgDep);
+        modulePkg.addDependency(pkgDep);
+      }
+    }
+    return pkgGraph;
+  }
+  getPackages() {
+    return this._packages.slice();
+  }
+  getPackageByModule(module2, readFile) {
+    const { path: file, meta } = module2;
+    const { _pkgFileMap: pkgsMap } = this;
+    const getPackageByData = (data2) => {
+      return this.getPackageByData(data2) ?? new import_package.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 ((0, import_path.dirname)(current) === current) {
+          break;
+        }
+        current = (0, import_path.dirname)(current);
+        if (readFile2) {
+          result = readFile2((0, import_path.join)(current, "package.json"));
+        }
+        if (!readFile2) {
+          result = import_common.Package.getPackageMetaFromModulePath(file2);
+        } else if (!result?.name) {
+          result = void 0;
+        }
+      }
+      if (!result) {
+        return;
+      }
+      if (readFile2 && (!result.name || !result.version)) {
+        return readPackageJson((0, import_path.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 = (0, import_path.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 (0, import_lodash.unionBy)(
+      Array.from(this._pkgNameMap.values()).map((pkgs) => {
+        return (0, import_lodash.unionBy)(pkgs, "version");
+      }).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())
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PackageGraph
+});

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

@@ -0,0 +1,28 @@
+"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 package_graph_exports = {};
+module.exports = __toCommonJS(package_graph_exports);
+__reExport(package_graph_exports, require("./dependency"), module.exports);
+__reExport(package_graph_exports, require("./graph"), module.exports);
+__reExport(package_graph_exports, require("./package"), module.exports);
+__reExport(package_graph_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./dependency"),
+  ...require("./graph"),
+  ...require("./package"),
+  ...require("./types")
+});

package/dist/cjs/graph/package-graph/package.js

@@ -0,0 +1,121 @@
+"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 package_exports = {};
+__export(package_exports, {
+  Package: () => Package
+});
+module.exports = __toCommonJS(package_exports);
+var import_path = require("path");
+var import_utils = require("./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(module2) {
+    if (!this._modules.includes(module2)) {
+      this._modules.push(module2);
+    }
+  }
+  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 = (0, import_path.relative)(this.root, file);
+    if (subPath.startsWith("..")) {
+      return false;
+    }
+    return !(0, import_utils.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()
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Package
+});

package/dist/cjs/graph/package-graph/types.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,30 @@
+"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, {
+  isPackagePath: () => isPackagePath
+});
+module.exports = __toCommonJS(utils_exports);
+function isPackagePath(path) {
+  return /(^|[/\\])node_modules[/\\]/.test(path);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPackagePath
+});

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

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

@@ -0,0 +1,20 @@
+import { SDK } from "@rsdoctor/types";
+class Asset {
+  constructor(path, size, chunks, content) {
+    this.path = path;
+    this.size = size;
+    this.chunks = chunks;
+    this.content = content;
+  }
+  toData(types) {
+    return {
+      path: this.path,
+      size: this.size,
+      chunks: this.chunks?.map((ck) => ck.id),
+      content: types === SDK.ToDataType.LiteAndNoAsset ? "" : this.content
+    };
+  }
+}
+export {
+  Asset
+};

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

@@ -0,0 +1,81 @@
+class Chunk {
+  constructor(id, name, size, initial, entry) {
+    this._assets = [];
+    this._modules = [];
+    this._dependencies = [];
+    this._imported = [];
+    this.id = id;
+    this.name = name;
+    this.size = size;
+    this.initial = initial;
+    this.entry = entry;
+  }
+  isEntry() {
+    return this.entry;
+  }
+  isChunkEntryModule(module) {
+    return module.isEntry || module.getImported().every((item) => !this.hasModule(item));
+  }
+  hasModule(module) {
+    return this._modules.includes(module);
+  }
+  addModule(module) {
+    if (!this.hasModule(module)) {
+      this._modules.push(module);
+      module.addChunk(this);
+    }
+  }
+  addAsset(asset) {
+    this._assets.push(asset);
+  }
+  addModules(modules) {
+    modules.forEach((module) => {
+      if (!this.hasModule(module)) {
+        this._modules.push(module);
+        module.addChunk(this);
+      }
+    });
+  }
+  addDependency(dep) {
+    if (!this._dependencies.includes(dep)) {
+      this._dependencies.push(dep);
+    }
+  }
+  addImported(imported) {
+    if (!this._imported.includes(imported)) {
+      this._imported.push(imported);
+    }
+  }
+  getAssets() {
+    return this._assets.slice();
+  }
+  getModules() {
+    return this._modules.slice();
+  }
+  getDependencies() {
+    return this._dependencies.slice();
+  }
+  getImported() {
+    return this._imported.slice();
+  }
+  setParsedSize(parsedSize) {
+    this._parsedSize = parsedSize;
+  }
+  toData() {
+    return {
+      id: this.id,
+      name: this.name,
+      initial: this.initial,
+      size: this.size,
+      parsedSize: this._parsedSize || 0,
+      entry: this.isEntry(),
+      assets: this._assets.map(({ path }) => path),
+      modules: this._modules.map(({ id }) => id),
+      dependencies: this._dependencies.map(({ id }) => id),
+      imported: this._imported.map(({ id }) => id)
+    };
+  }
+}
+export {
+  Chunk
+};

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

@@ -0,0 +1,28 @@
+class EntryPoint {
+  constructor(name) {
+    this.name = name;
+    this._chunks = [];
+    this._assets = [];
+  }
+  addChunk(chunk) {
+    if (this._chunks.includes(chunk))
+      return;
+    this._chunks.push(chunk);
+  }
+  addAsset(asset) {
+    if (this._assets.includes(asset))
+      return;
+    this._assets.push(asset);
+  }
+  toData() {
+    return {
+      name: this.name,
+      chunks: this._chunks.map((e) => e.id),
+      assets: this._assets.map((e) => e.path),
+      size: this._assets.length ? this._assets.reduce((t, e) => t + e.size, 0) : 0
+    };
+  }
+}
+export {
+  EntryPoint
+};

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

@@ -0,0 +1,64 @@
+class ChunkGraph {
+  constructor() {
+    this._assets = [];
+    this._chunks = [];
+    this._entrypoints = [];
+  }
+  getAssets() {
+    return this._assets.slice();
+  }
+  getChunks() {
+    return this._chunks.slice();
+  }
+  addAsset(...assets) {
+    assets.forEach((asset) => {
+      if (!this._assets.includes(asset)) {
+        this._assets.push(asset);
+      }
+    });
+  }
+  addChunk(...chunks) {
+    chunks.forEach((chunk) => {
+      if (!this._chunks.includes(chunk)) {
+        this._chunks.push(chunk);
+      }
+    });
+  }
+  getChunkById(id) {
+    return this._chunks.find((item) => item.id === id);
+  }
+  getChunkByModule(module) {
+    return this._chunks.find((item) => item.hasModule(module));
+  }
+  getAssetByPath(path) {
+    return this._assets.find((item) => item.path === path);
+  }
+  getAssetsByChunk(chunk) {
+    return this._assets.filter((item) => {
+      const _chunk = item.chunks.find((ck) => ck.id === chunk.id);
+      if (_chunk)
+        return true;
+    });
+  }
+  getEntryPoints() {
+    return this._entrypoints.slice();
+  }
+  addEntryPoint(...entrypoints) {
+    entrypoints.forEach((entrypoint) => {
+      if (!this._entrypoints.includes(entrypoint)) {
+        this._entrypoints.push(entrypoint);
+      }
+    });
+  }
+  /** output the chunk graph data */
+  toData(type) {
+    return {
+      assets: this._assets.map((item) => item.toData(type)),
+      chunks: this._chunks.map((item) => item.toData()),
+      entrypoints: this._entrypoints.map((item) => item.toData())
+    };
+  }
+}
+export {
+  ChunkGraph
+};

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

@@ -0,0 +1,4 @@
+export * from "./chunk";
+export * from "./graph";
+export * from "./asset";
+export * from "./entrypoint";

package/dist/esm/graph/index.js

@@ -0,0 +1,3 @@
+export * from "./chunk-graph";
+export * from "./module-graph";
+export * from "./package-graph";

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

@@ -0,0 +1,67 @@
+import { SDK } from "@rsdoctor/types";
+let id = 1;
+class Dependency {
+  constructor(request, module, dependency, kind, statements) {
+    this.statements = [];
+    this.meta = {
+      exportsType: "default-with-named"
+    };
+    this.id = id++;
+    this.request = request;
+    this.module = module;
+    this._originDependency = dependency;
+    this.kind = kind;
+    this.statements = statements ?? [];
+  }
+  static init() {
+    id = 1;
+  }
+  get resolvedRequest() {
+    return this.dependency.path;
+  }
+  get dependency() {
+    return this.originDependency.rootModule ?? this.originDependency;
+  }
+  get originDependency() {
+    return this._originDependency;
+  }
+  get kindString() {
+    return SDK.DependencyKind[this.kind];
+  }
+  get resolveConcatenationModule() {
+    return this.dependency.kind === SDK.ModuleKind.Concatenation;
+  }
+  isSameWithoutStatements(dep) {
+    return this.request === dep.request && this.kind === dep.kind && this.module.id === dep.module.id && this.dependency.id === dep.dependency.id;
+  }
+  addStatement(statement) {
+    if (!this.hasStatement(statement)) {
+      this.statements.push(statement);
+    }
+  }
+  hasStatement(statement) {
+    return this.statements.some((item) => item.isSame(statement));
+  }
+  setBuildMeta(data) {
+    this.meta = {
+      ...this.meta,
+      ...data
+    };
+  }
+  toData() {
+    return {
+      id: this.id,
+      request: this.request,
+      resolvedRequest: this.resolvedRequest,
+      kind: this.kind,
+      module: this.module.id,
+      dependency: this.dependency.id,
+      originDependency: this.originDependency.id,
+      statements: this.statements.map((item) => item.toData())
+    };
+  }
+}
+Dependency.kind = SDK.DependencyKind;
+export {
+  Dependency
+};