@rsdoctor/graph 0.0.2-beta.0

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

@@ -0,0 +1,82 @@
+"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 statement_exports = {};
+__export(statement_exports, {
+  Statement: () => Statement
+});
+module.exports = __toCommonJS(statement_exports);
+var import_utils = require("./utils");
+class Statement {
+  static getDefaultStatement(module2) {
+    const defaultPosition = {
+      line: 1,
+      column: 0
+    };
+    const defaultRange = {
+      start: { ...defaultPosition },
+      end: { ...defaultPosition }
+    };
+    return new Statement(module2, {
+      source: { ...defaultRange },
+      transformed: { ...defaultRange }
+    });
+  }
+  constructor(module2, position) {
+    this.module = module2;
+    this.position = position;
+  }
+  isSame(statement) {
+    return this.module.id === statement.module.id && (0, import_utils.isSameRange)(this.position.transformed, statement.position.transformed);
+  }
+  getSourcePosition() {
+    const { module: module2, position } = this;
+    if (position.source) {
+      return position.source;
+    }
+    if (module2.getSourceMap()) {
+      position.source = module2.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
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Statement
+});

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

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

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

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

@@ -0,0 +1,98 @@
+"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 module_exports = {};
+__export(module_exports, {
+  ModuleGraphModule: () => ModuleGraphModule
+});
+module.exports = __toCommonJS(module_exports);
+var import_export = require("./export");
+var import_sideEffect = require("./sideEffect");
+var import_variable = require("./variable");
+class ModuleGraphModule {
+  constructor(module2, graph, dynamic) {
+    this.exports = [];
+    this.sideEffects = [];
+    this.variables = [];
+    this.module = module2;
+    this._graph = graph;
+    if (typeof this._dynamic === "boolean") {
+      this._dynamic = dynamic;
+    }
+  }
+  static init() {
+    import_export.ExportInfo.init();
+    import_sideEffect.SideEffect.init();
+    import_variable.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)
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModuleGraphModule
+});

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

@@ -0,0 +1,94 @@
+"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 sideEffect_exports = {};
+__export(sideEffect_exports, {
+  SideEffect: () => SideEffect
+});
+module.exports = __toCommonJS(sideEffect_exports);
+let id = 1;
+const _SideEffect = class _SideEffect {
+  constructor(name, module2, identifier, fromRequest, originName) {
+    this.id = id++;
+    this._exports = [];
+    this.name = name;
+    this.module = module2;
+    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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SideEffect
+});

package/dist/cjs/graph/module-graph/tree-shaking/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/module-graph/tree-shaking/variable.js

@@ -0,0 +1,63 @@
+"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 variable_exports = {};
+__export(variable_exports, {
+  Variable: () => Variable
+});
+module.exports = __toCommonJS(variable_exports);
+let id = 1;
+class Variable {
+  constructor(name, module2, usedInfo, identifier) {
+    this.id = id++;
+    this.name = name;
+    this.module = module2;
+    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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Variable
+});

package/dist/cjs/graph/module-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/module-graph/utils.js

@@ -0,0 +1,65 @@
+"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, {
+  getModuleName: () => getModuleName,
+  isSamePosition: () => isSamePosition,
+  isSameRange: () => isSameRange
+});
+module.exports = __toCommonJS(utils_exports);
+var import_lodash = require("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 (!(0, import_lodash.isNil)(po1.end) && !(0, import_lodash.isNil)(po2.end)) {
+    return isSamePosition(po1.end, po2.end);
+  }
+  return (0, import_lodash.isUndefined)(po1.end) && (0, import_lodash.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 = (0, import_lodash.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModuleName,
+  isSamePosition,
+  isSameRange
+});

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

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