@rsdoctor/graph 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/cjs/graph/chunk-graph/asset.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 asset_exports = {};
+__export(asset_exports, {
+  Asset: () => Asset
+});
+module.exports = __toCommonJS(asset_exports);
+var import_types = require("@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 === import_types.SDK.ToDataType.LiteAndNoAsset ? "" : this.content
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Asset
+});

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

@@ -0,0 +1,105 @@
+"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 chunk_exports = {};
+__export(chunk_exports, {
+  Chunk: () => Chunk
+});
+module.exports = __toCommonJS(chunk_exports);
+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(module2) {
+    return module2.isEntry || module2.getImported().every((item) => !this.hasModule(item));
+  }
+  hasModule(module2) {
+    return this._modules.includes(module2);
+  }
+  addModule(module2) {
+    if (!this.hasModule(module2)) {
+      this._modules.push(module2);
+      module2.addChunk(this);
+    }
+  }
+  addAsset(asset) {
+    this._assets.push(asset);
+  }
+  addModules(modules) {
+    modules.forEach((module2) => {
+      if (!this.hasModule(module2)) {
+        this._modules.push(module2);
+        module2.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)
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Chunk
+});

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

@@ -0,0 +1,52 @@
+"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 entrypoint_exports = {};
+__export(entrypoint_exports, {
+  EntryPoint: () => EntryPoint
+});
+module.exports = __toCommonJS(entrypoint_exports);
+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
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EntryPoint
+});

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

@@ -0,0 +1,88 @@
+"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, {
+  ChunkGraph: () => ChunkGraph
+});
+module.exports = __toCommonJS(graph_exports);
+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(module2) {
+    return this._chunks.find((item) => item.hasModule(module2));
+  }
+  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())
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkGraph
+});

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

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

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

@@ -0,0 +1,91 @@
+"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 dependency_exports = {};
+__export(dependency_exports, {
+  Dependency: () => Dependency
+});
+module.exports = __toCommonJS(dependency_exports);
+var import_types = require("@rsdoctor/types");
+let id = 1;
+class Dependency {
+  constructor(request, module2, dependency, kind, statements) {
+    this.statements = [];
+    this.meta = {
+      exportsType: "default-with-named"
+    };
+    this.id = id++;
+    this.request = request;
+    this.module = module2;
+    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 import_types.SDK.DependencyKind[this.kind];
+  }
+  get resolveConcatenationModule() {
+    return this.dependency.kind === import_types.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 = import_types.SDK.DependencyKind;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Dependency
+});