@teambit/graph 0.0.0-351b8797f220d8d6c242cfc30d4ecebaee07da45

package/component-graph/component-graph.ts

@@ -0,0 +1,118 @@
+import { Component, ComponentID } from '@teambit/component';
+import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
+
+import { Dependency } from '../model/dependency';
+import { DuplicateDependency, VersionSubgraph } from '../duplicate-dependency';
+
+export const DEPENDENCIES_TYPES = ['dependencies', 'devDependencies'];
+
+type ComponentNode = Node<Component>;
+type DependencyEdge = Edge<Dependency>;
+
+export class ComponentGraph extends Graph<Component, Dependency> {
+  seederIds: ComponentID[] = []; // component IDs that started the graph. (if from workspace, the .bitmap ids normally)
+  constructor(nodes: ComponentNode[] = [], edges: DependencyEdge[] = []) {
+    super(nodes, edges);
+  }
+
+  protected create(nodes: ComponentNode[] = [], edges: DependencyEdge[] = []): this {
+    return new ComponentGraph(nodes, edges) as this;
+  }
+
+  /**
+   * @deprecate use graph.getGraphIds().findCycles()
+   */
+  findCycles(graph?: this): string[][] {
+    const cycles = super.findCycles(graph);
+    if (!this.shouldLimitToSeedersOnly()) {
+      return cycles;
+    }
+    const seederIdsStr = this.seederIds.map((id) => id.toString());
+    const cyclesWithSeeders = cycles.filter((cycle) => {
+      return cycle.some((cycleIdStr) => seederIdsStr.includes(cycleIdStr));
+    });
+    return cyclesWithSeeders;
+  }
+
+  findDuplicateDependencies(): Map<string, DuplicateDependency> {
+    const versionMap = this.calculateVersionMap();
+    const seederIdsNoVersions = this.seederIds.map((id) => id.toStringWithoutVersion());
+    const duplicateDependencies: Map<string, DuplicateDependency> = new Map();
+    for (const [compFullName, versions] of versionMap) {
+      if (versions.allVersionNodes.length > 1) {
+        const versionSubgraphs: VersionSubgraph[] = [];
+        const notLatestVersions = versions.allVersionNodes.filter((version) => version !== versions.latestVersionNode);
+        notLatestVersions.forEach((version) => {
+          const predecessors = this.predecessorsSubgraph(version);
+          const immediatePredecessors = this.predecessors(version).map((predecessor) => predecessor.id);
+          const subGraph = this.buildFromCleargraph(predecessors);
+          const versionSubgraph: VersionSubgraph = {
+            versionId: version,
+            subGraph,
+            // TODO: validate that this is working correctly
+            immediateDependents: immediatePredecessors,
+          };
+          versionSubgraphs.push(versionSubgraph);
+        });
+        const isSeeder = seederIdsNoVersions.includes(compFullName);
+        const shouldDisplayDueToBeingSeeder = !this.shouldLimitToSeedersOnly() || isSeeder;
+        if (shouldDisplayDueToBeingSeeder && versionSubgraphs.length > 0) {
+          const duplicateDep = new DuplicateDependency(versions.latestVersionNode, versionSubgraphs);
+          duplicateDependencies.set(compFullName, duplicateDep);
+        }
+      }
+    }
+    return duplicateDependencies;
+  }
+
+  buildFromCleargraph(graph: Graph<Component, Dependency>): ComponentGraph {
+    return this.create(graph.nodes, graph.edges);
+  }
+
+  runtimeOnly(componentIds: string[]) {
+    return this.successorsSubgraph(componentIds, {
+      edgeFilter: (edge: DependencyEdge) => edge.attr.type === 'runtime',
+    });
+  }
+
+  private shouldLimitToSeedersOnly() {
+    return this.seederIds.length;
+  }
+
+  private calculateVersionMap(): Map<string, { allVersionNodes: string[]; latestVersionNode: string }> {
+    const versionMap: Map<string, { allVersionNodes: string[]; latestVersionNode: string }> = new Map();
+    for (const node of this.nodes) {
+      const comp = node.attr;
+      const compKey = node.id;
+      const compFullName = comp.id.toStringWithoutVersion();
+      if (!versionMap.has(compFullName)) {
+        versionMap.set(compFullName, {
+          allVersionNodes: [compKey],
+          latestVersionNode: compKey,
+        });
+      } else {
+        const value = versionMap.get(compFullName);
+        if (value) {
+          if (Object.prototype.hasOwnProperty.call(value, 'allVersionNodes')) {
+            value.allVersionNodes.push(compKey);
+          }
+          const currentComp = comp;
+          const latestComp = this.node(value.latestVersionNode)?.attr;
+          // @todo: this check won't work when the component doesn't have head.
+          // it happens when a dependency is needed in an old version (not head). which Bit doesn't fetch the head
+          // Version object, and as a result, the `Component.head` is empty.
+          // for now it's probably good enough because it's used only for `findDuplicateDependencies`, which only
+          // checks the components on the workspace.
+          if (
+            currentComp.head &&
+            latestComp?.head &&
+            new Date(currentComp.head.timestamp) > new Date(latestComp.head.timestamp)
+          ) {
+            value.latestVersionNode = compKey;
+          }
+        }
+      }
+    }
+    return versionMap;
+  }
+}

package/component-graph/index.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/no-cycle
+export { ComponentGraph } from './component-graph';

package/dist/component-graph/component-graph.d.ts

@@ -0,0 +1,22 @@
+import { Component, ComponentID } from '@teambit/component';
+import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
+import { Dependency } from '../model/dependency';
+import { DuplicateDependency } from '../duplicate-dependency';
+export declare const DEPENDENCIES_TYPES: string[];
+type ComponentNode = Node<Component>;
+type DependencyEdge = Edge<Dependency>;
+export declare class ComponentGraph extends Graph<Component, Dependency> {
+    seederIds: ComponentID[];
+    constructor(nodes?: ComponentNode[], edges?: DependencyEdge[]);
+    protected create(nodes?: ComponentNode[], edges?: DependencyEdge[]): this;
+    /**
+     * @deprecate use graph.getGraphIds().findCycles()
+     */
+    findCycles(graph?: this): string[][];
+    findDuplicateDependencies(): Map<string, DuplicateDependency>;
+    buildFromCleargraph(graph: Graph<Component, Dependency>): ComponentGraph;
+    runtimeOnly(componentIds: string[]): this;
+    private shouldLimitToSeedersOnly;
+    private calculateVersionMap;
+}
+export {};

package/dist/component-graph/component-graph.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEPENDENCIES_TYPES = exports.ComponentGraph = void 0;
+function _graph() {
+  const data = require("@teambit/graph.cleargraph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _duplicateDependency() {
+  const data = require("../duplicate-dependency");
+  _duplicateDependency = function () {
+    return data;
+  };
+  return data;
+}
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const DEPENDENCIES_TYPES = exports.DEPENDENCIES_TYPES = ['dependencies', 'devDependencies'];
+class ComponentGraph extends _graph().Graph {
+  // component IDs that started the graph. (if from workspace, the .bitmap ids normally)
+  constructor(nodes = [], edges = []) {
+    super(nodes, edges);
+    _defineProperty(this, "seederIds", []);
+  }
+  create(nodes = [], edges = []) {
+    return new ComponentGraph(nodes, edges);
+  }
+
+  /**
+   * @deprecate use graph.getGraphIds().findCycles()
+   */
+  findCycles(graph) {
+    const cycles = super.findCycles(graph);
+    if (!this.shouldLimitToSeedersOnly()) {
+      return cycles;
+    }
+    const seederIdsStr = this.seederIds.map(id => id.toString());
+    const cyclesWithSeeders = cycles.filter(cycle => {
+      return cycle.some(cycleIdStr => seederIdsStr.includes(cycleIdStr));
+    });
+    return cyclesWithSeeders;
+  }
+  findDuplicateDependencies() {
+    const versionMap = this.calculateVersionMap();
+    const seederIdsNoVersions = this.seederIds.map(id => id.toStringWithoutVersion());
+    const duplicateDependencies = new Map();
+    for (const [compFullName, versions] of versionMap) {
+      if (versions.allVersionNodes.length > 1) {
+        const versionSubgraphs = [];
+        const notLatestVersions = versions.allVersionNodes.filter(version => version !== versions.latestVersionNode);
+        notLatestVersions.forEach(version => {
+          const predecessors = this.predecessorsSubgraph(version);
+          const immediatePredecessors = this.predecessors(version).map(predecessor => predecessor.id);
+          const subGraph = this.buildFromCleargraph(predecessors);
+          const versionSubgraph = {
+            versionId: version,
+            subGraph,
+            // TODO: validate that this is working correctly
+            immediateDependents: immediatePredecessors
+          };
+          versionSubgraphs.push(versionSubgraph);
+        });
+        const isSeeder = seederIdsNoVersions.includes(compFullName);
+        const shouldDisplayDueToBeingSeeder = !this.shouldLimitToSeedersOnly() || isSeeder;
+        if (shouldDisplayDueToBeingSeeder && versionSubgraphs.length > 0) {
+          const duplicateDep = new (_duplicateDependency().DuplicateDependency)(versions.latestVersionNode, versionSubgraphs);
+          duplicateDependencies.set(compFullName, duplicateDep);
+        }
+      }
+    }
+    return duplicateDependencies;
+  }
+  buildFromCleargraph(graph) {
+    return this.create(graph.nodes, graph.edges);
+  }
+  runtimeOnly(componentIds) {
+    return this.successorsSubgraph(componentIds, {
+      edgeFilter: edge => edge.attr.type === 'runtime'
+    });
+  }
+  shouldLimitToSeedersOnly() {
+    return this.seederIds.length;
+  }
+  calculateVersionMap() {
+    const versionMap = new Map();
+    for (const node of this.nodes) {
+      const comp = node.attr;
+      const compKey = node.id;
+      const compFullName = comp.id.toStringWithoutVersion();
+      if (!versionMap.has(compFullName)) {
+        versionMap.set(compFullName, {
+          allVersionNodes: [compKey],
+          latestVersionNode: compKey
+        });
+      } else {
+        const value = versionMap.get(compFullName);
+        if (value) {
+          if (Object.prototype.hasOwnProperty.call(value, 'allVersionNodes')) {
+            value.allVersionNodes.push(compKey);
+          }
+          const currentComp = comp;
+          const latestComp = this.node(value.latestVersionNode)?.attr;
+          // @todo: this check won't work when the component doesn't have head.
+          // it happens when a dependency is needed in an old version (not head). which Bit doesn't fetch the head
+          // Version object, and as a result, the `Component.head` is empty.
+          // for now it's probably good enough because it's used only for `findDuplicateDependencies`, which only
+          // checks the components on the workspace.
+          if (currentComp.head && latestComp?.head && new Date(currentComp.head.timestamp) > new Date(latestComp.head.timestamp)) {
+            value.latestVersionNode = compKey;
+          }
+        }
+      }
+    }
+    return versionMap;
+  }
+}
+exports.ComponentGraph = ComponentGraph;
+
+//# sourceMappingURL=component-graph.js.map

package/dist/component-graph/component-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_graph","data","require","_duplicateDependency","_defineProperty","e","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","DEPENDENCIES_TYPES","exports","ComponentGraph","Graph","constructor","nodes","edges","create","findCycles","graph","cycles","shouldLimitToSeedersOnly","seederIdsStr","seederIds","map","id","toString","cyclesWithSeeders","filter","cycle","some","cycleIdStr","includes","findDuplicateDependencies","versionMap","calculateVersionMap","seederIdsNoVersions","toStringWithoutVersion","duplicateDependencies","Map","compFullName","versions","allVersionNodes","length","versionSubgraphs","notLatestVersions","version","latestVersionNode","forEach","predecessors","predecessorsSubgraph","immediatePredecessors","predecessor","subGraph","buildFromCleargraph","versionSubgraph","versionId","immediateDependents","push","isSeeder","shouldDisplayDueToBeingSeeder","duplicateDep","DuplicateDependency","set","runtimeOnly","componentIds","successorsSubgraph","edgeFilter","edge","attr","type","node","comp","compKey","has","get","prototype","hasOwnProperty","currentComp","latestComp","head","Date","timestamp"],"sources":["component-graph.ts"],"sourcesContent":["import { Component, ComponentID } from '@teambit/component';\nimport { Graph, Node, Edge } from '@teambit/graph.cleargraph';\n\nimport { Dependency } from '../model/dependency';\nimport { DuplicateDependency, VersionSubgraph } from '../duplicate-dependency';\n\nexport const DEPENDENCIES_TYPES = ['dependencies', 'devDependencies'];\n\ntype ComponentNode = Node<Component>;\ntype DependencyEdge = Edge<Dependency>;\n\nexport class ComponentGraph extends Graph<Component, Dependency> {\n  seederIds: ComponentID[] = []; // component IDs that started the graph. (if from workspace, the .bitmap ids normally)\n  constructor(nodes: ComponentNode[] = [], edges: DependencyEdge[] = []) {\n    super(nodes, edges);\n  }\n\n  protected create(nodes: ComponentNode[] = [], edges: DependencyEdge[] = []): this {\n    return new ComponentGraph(nodes, edges) as this;\n  }\n\n  /**\n   * @deprecate use graph.getGraphIds().findCycles()\n   */\n  findCycles(graph?: this): string[][] {\n    const cycles = super.findCycles(graph);\n    if (!this.shouldLimitToSeedersOnly()) {\n      return cycles;\n    }\n    const seederIdsStr = this.seederIds.map((id) => id.toString());\n    const cyclesWithSeeders = cycles.filter((cycle) => {\n      return cycle.some((cycleIdStr) => seederIdsStr.includes(cycleIdStr));\n    });\n    return cyclesWithSeeders;\n  }\n\n  findDuplicateDependencies(): Map<string, DuplicateDependency> {\n    const versionMap = this.calculateVersionMap();\n    const seederIdsNoVersions = this.seederIds.map((id) => id.toStringWithoutVersion());\n    const duplicateDependencies: Map<string, DuplicateDependency> = new Map();\n    for (const [compFullName, versions] of versionMap) {\n      if (versions.allVersionNodes.length > 1) {\n        const versionSubgraphs: VersionSubgraph[] = [];\n        const notLatestVersions = versions.allVersionNodes.filter((version) => version !== versions.latestVersionNode);\n        notLatestVersions.forEach((version) => {\n          const predecessors = this.predecessorsSubgraph(version);\n          const immediatePredecessors = this.predecessors(version).map((predecessor) => predecessor.id);\n          const subGraph = this.buildFromCleargraph(predecessors);\n          const versionSubgraph: VersionSubgraph = {\n            versionId: version,\n            subGraph,\n            // TODO: validate that this is working correctly\n            immediateDependents: immediatePredecessors,\n          };\n          versionSubgraphs.push(versionSubgraph);\n        });\n        const isSeeder = seederIdsNoVersions.includes(compFullName);\n        const shouldDisplayDueToBeingSeeder = !this.shouldLimitToSeedersOnly() || isSeeder;\n        if (shouldDisplayDueToBeingSeeder && versionSubgraphs.length > 0) {\n          const duplicateDep = new DuplicateDependency(versions.latestVersionNode, versionSubgraphs);\n          duplicateDependencies.set(compFullName, duplicateDep);\n        }\n      }\n    }\n    return duplicateDependencies;\n  }\n\n  buildFromCleargraph(graph: Graph<Component, Dependency>): ComponentGraph {\n    return this.create(graph.nodes, graph.edges);\n  }\n\n  runtimeOnly(componentIds: string[]) {\n    return this.successorsSubgraph(componentIds, {\n      edgeFilter: (edge: DependencyEdge) => edge.attr.type === 'runtime',\n    });\n  }\n\n  private shouldLimitToSeedersOnly() {\n    return this.seederIds.length;\n  }\n\n  private calculateVersionMap(): Map<string, { allVersionNodes: string[]; latestVersionNode: string }> {\n    const versionMap: Map<string, { allVersionNodes: string[]; latestVersionNode: string }> = new Map();\n    for (const node of this.nodes) {\n      const comp = node.attr;\n      const compKey = node.id;\n      const compFullName = comp.id.toStringWithoutVersion();\n      if (!versionMap.has(compFullName)) {\n        versionMap.set(compFullName, {\n          allVersionNodes: [compKey],\n          latestVersionNode: compKey,\n        });\n      } else {\n        const value = versionMap.get(compFullName);\n        if (value) {\n          if (Object.prototype.hasOwnProperty.call(value, 'allVersionNodes')) {\n            value.allVersionNodes.push(compKey);\n          }\n          const currentComp = comp;\n          const latestComp = this.node(value.latestVersionNode)?.attr;\n          // @todo: this check won't work when the component doesn't have head.\n          // it happens when a dependency is needed in an old version (not head). which Bit doesn't fetch the head\n          // Version object, and as a result, the `Component.head` is empty.\n          // for now it's probably good enough because it's used only for `findDuplicateDependencies`, which only\n          // checks the components on the workspace.\n          if (\n            currentComp.head &&\n            latestComp?.head &&\n            new Date(currentComp.head.timestamp) > new Date(latestComp.head.timestamp)\n          ) {\n            value.latestVersionNode = compKey;\n          }\n        }\n      }\n    }\n    return versionMap;\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,OAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,MAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAGA,SAAAE,qBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,oBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA+E,SAAAG,gBAAAC,CAAA,EAAAC,CAAA,EAAAC,CAAA,YAAAD,CAAA,GAAAE,cAAA,CAAAF,CAAA,MAAAD,CAAA,GAAAI,MAAA,CAAAC,cAAA,CAAAL,CAAA,EAAAC,CAAA,IAAAK,KAAA,EAAAJ,CAAA,EAAAK,UAAA,MAAAC,YAAA,MAAAC,QAAA,UAAAT,CAAA,CAAAC,CAAA,IAAAC,CAAA,EAAAF,CAAA;AAAA,SAAAG,eAAAD,CAAA,QAAAQ,CAAA,GAAAC,YAAA,CAAAT,CAAA,uCAAAQ,CAAA,GAAAA,CAAA,GAAAA,CAAA;AAAA,SAAAC,aAAAT,CAAA,EAAAD,CAAA,2BAAAC,CAAA,KAAAA,CAAA,SAAAA,CAAA,MAAAF,CAAA,GAAAE,CAAA,CAAAU,MAAA,CAAAC,WAAA,kBAAAb,CAAA,QAAAU,CAAA,GAAAV,CAAA,CAAAc,IAAA,CAAAZ,CAAA,EAAAD,CAAA,uCAAAS,CAAA,SAAAA,CAAA,YAAAK,SAAA,yEAAAd,CAAA,GAAAe,MAAA,GAAAC,MAAA,EAAAf,CAAA;AAExE,MAAMgB,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,CAAC,cAAc,EAAE,iBAAiB,CAAC;AAK9D,MAAME,cAAc,SAASC,cAAK,CAAwB;EAChC;EAC/BC,WAAWA,CAACC,KAAsB,GAAG,EAAE,EAAEC,KAAuB,GAAG,EAAE,EAAE;IACrE,KAAK,CAACD,KAAK,EAAEC,KAAK,CAAC;IAACzB,eAAA,oBAFK,EAAE;EAG7B;EAEU0B,MAAMA,CAACF,KAAsB,GAAG,EAAE,EAAEC,KAAuB,GAAG,EAAE,EAAQ;IAChF,OAAO,IAAIJ,cAAc,CAACG,KAAK,EAAEC,KAAK,CAAC;EACzC;;EAEA;AACF;AACA;EACEE,UAAUA,CAACC,KAAY,EAAc;IACnC,MAAMC,MAAM,GAAG,KAAK,CAACF,UAAU,CAACC,KAAK,CAAC;IACtC,IAAI,CAAC,IAAI,CAACE,wBAAwB,CAAC,CAAC,EAAE;MACpC,OAAOD,MAAM;IACf;IACA,MAAME,YAAY,GAAG,IAAI,CAACC,SAAS,CAACC,GAAG,CAAEC,EAAE,IAAKA,EAAE,CAACC,QAAQ,CAAC,CAAC,CAAC;IAC9D,MAAMC,iBAAiB,GAAGP,MAAM,CAACQ,MAAM,CAAEC,KAAK,IAAK;MACjD,OAAOA,KAAK,CAACC,IAAI,CAAEC,UAAU,IAAKT,YAAY,CAACU,QAAQ,CAACD,UAAU,CAAC,CAAC;IACtE,CAAC,CAAC;IACF,OAAOJ,iBAAiB;EAC1B;EAEAM,yBAAyBA,CAAA,EAAqC;IAC5D,MAAMC,UAAU,GAAG,IAAI,CAACC,mBAAmB,CAAC,CAAC;IAC7C,MAAMC,mBAAmB,GAAG,IAAI,CAACb,SAAS,CAACC,GAAG,CAAEC,EAAE,IAAKA,EAAE,CAACY,sBAAsB,CAAC,CAAC,CAAC;IACnF,MAAMC,qBAAuD,GAAG,IAAIC,GAAG,CAAC,CAAC;IACzE,KAAK,MAAM,CAACC,YAAY,EAAEC,QAAQ,CAAC,IAAIP,UAAU,EAAE;MACjD,IAAIO,QAAQ,CAACC,eAAe,CAACC,MAAM,GAAG,CAAC,EAAE;QACvC,MAAMC,gBAAmC,GAAG,EAAE;QAC9C,MAAMC,iBAAiB,GAAGJ,QAAQ,CAACC,eAAe,CAACd,MAAM,CAAEkB,OAAO,IAAKA,OAAO,KAAKL,QAAQ,CAACM,iBAAiB,CAAC;QAC9GF,iBAAiB,CAACG,OAAO,CAAEF,OAAO,IAAK;UACrC,MAAMG,YAAY,GAAG,IAAI,CAACC,oBAAoB,CAACJ,OAAO,CAAC;UACvD,MAAMK,qBAAqB,GAAG,IAAI,CAACF,YAAY,CAACH,OAAO,CAAC,CAACtB,GAAG,CAAE4B,WAAW,IAAKA,WAAW,CAAC3B,EAAE,CAAC;UAC7F,MAAM4B,QAAQ,GAAG,IAAI,CAACC,mBAAmB,CAACL,YAAY,CAAC;UACvD,MAAMM,eAAgC,GAAG;YACvCC,SAAS,EAAEV,OAAO;YAClBO,QAAQ;YACR;YACAI,mBAAmB,EAAEN;UACvB,CAAC;UACDP,gBAAgB,CAACc,IAAI,CAACH,eAAe,CAAC;QACxC,CAAC,CAAC;QACF,MAAMI,QAAQ,GAAGvB,mBAAmB,CAACJ,QAAQ,CAACQ,YAAY,CAAC;QAC3D,MAAMoB,6BAA6B,GAAG,CAAC,IAAI,CAACvC,wBAAwB,CAAC,CAAC,IAAIsC,QAAQ;QAClF,IAAIC,6BAA6B,IAAIhB,gBAAgB,CAACD,MAAM,GAAG,CAAC,EAAE;UAChE,MAAMkB,YAAY,GAAG,KAAIC,0CAAmB,EAACrB,QAAQ,CAACM,iBAAiB,EAAEH,gBAAgB,CAAC;UAC1FN,qBAAqB,CAACyB,GAAG,CAACvB,YAAY,EAAEqB,YAAY,CAAC;QACvD;MACF;IACF;IACA,OAAOvB,qBAAqB;EAC9B;EAEAgB,mBAAmBA,CAACnC,KAAmC,EAAkB;IACvE,OAAO,IAAI,CAACF,MAAM,CAACE,KAAK,CAACJ,KAAK,EAAEI,KAAK,CAACH,KAAK,CAAC;EAC9C;EAEAgD,WAAWA,CAACC,YAAsB,EAAE;IAClC,OAAO,IAAI,CAACC,kBAAkB,CAACD,YAAY,EAAE;MAC3CE,UAAU,EAAGC,IAAoB,IAAKA,IAAI,CAACC,IAAI,CAACC,IAAI,KAAK;IAC3D,CAAC,CAAC;EACJ;EAEQjD,wBAAwBA,CAAA,EAAG;IACjC,OAAO,IAAI,CAACE,SAAS,CAACoB,MAAM;EAC9B;EAEQR,mBAAmBA,CAAA,EAA0E;IACnG,MAAMD,UAAiF,GAAG,IAAIK,GAAG,CAAC,CAAC;IACnG,KAAK,MAAMgC,IAAI,IAAI,IAAI,CAACxD,KAAK,EAAE;MAC7B,MAAMyD,IAAI,GAAGD,IAAI,CAACF,IAAI;MACtB,MAAMI,OAAO,GAAGF,IAAI,CAAC9C,EAAE;MACvB,MAAMe,YAAY,GAAGgC,IAAI,CAAC/C,EAAE,CAACY,sBAAsB,CAAC,CAAC;MACrD,IAAI,CAACH,UAAU,CAACwC,GAAG,CAAClC,YAAY,CAAC,EAAE;QACjCN,UAAU,CAAC6B,GAAG,CAACvB,YAAY,EAAE;UAC3BE,eAAe,EAAE,CAAC+B,OAAO,CAAC;UAC1B1B,iBAAiB,EAAE0B;QACrB,CAAC,CAAC;MACJ,CAAC,MAAM;QACL,MAAM3E,KAAK,GAAGoC,UAAU,CAACyC,GAAG,CAACnC,YAAY,CAAC;QAC1C,IAAI1C,KAAK,EAAE;UACT,IAAIF,MAAM,CAACgF,SAAS,CAACC,cAAc,CAACvE,IAAI,CAACR,KAAK,EAAE,iBAAiB,CAAC,EAAE;YAClEA,KAAK,CAAC4C,eAAe,CAACgB,IAAI,CAACe,OAAO,CAAC;UACrC;UACA,MAAMK,WAAW,GAAGN,IAAI;UACxB,MAAMO,UAAU,GAAG,IAAI,CAACR,IAAI,CAACzE,KAAK,CAACiD,iBAAiB,CAAC,EAAEsB,IAAI;UAC3D;UACA;UACA;UACA;UACA;UACA,IACES,WAAW,CAACE,IAAI,IAChBD,UAAU,EAAEC,IAAI,IAChB,IAAIC,IAAI,CAACH,WAAW,CAACE,IAAI,CAACE,SAAS,CAAC,GAAG,IAAID,IAAI,CAACF,UAAU,CAACC,IAAI,CAACE,SAAS,CAAC,EAC1E;YACApF,KAAK,CAACiD,iBAAiB,GAAG0B,OAAO;UACnC;QACF;MACF;IACF;IACA,OAAOvC,UAAU;EACnB;AACF;AAACvB,OAAA,CAAAC,cAAA,GAAAA,cAAA","ignoreList":[]}

package/dist/component-graph/index.d.ts

@@ -0,0 +1 @@
+export { ComponentGraph } from './component-graph';

package/dist/component-graph/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ComponentGraph", {
+  enumerable: true,
+  get: function () {
+    return _componentGraph().ComponentGraph;
+  }
+});
+function _componentGraph() {
+  const data = require("./component-graph");
+  _componentGraph = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/component-graph/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_componentGraph","data","require"],"sources":["index.ts"],"sourcesContent":["// eslint-disable-next-line import/no-cycle\nexport { ComponentGraph } from './component-graph';\n"],"mappings":";;;;;;;;;;;AACA,SAAAA,gBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,eAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}

package/dist/component-id-graph.d.ts

@@ -0,0 +1,49 @@
+import { ComponentID } from '@teambit/component-id';
+import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
+import type { DependenciesInfo } from '@teambit/legacy.dependency-graph';
+import GraphLib from 'graphlib';
+export type DepEdgeType = 'prod' | 'dev' | 'ext' | 'peer';
+type ComponentIdNode = Node<ComponentID>;
+type DependencyEdge = Edge<DepEdgeType>;
+export type CompIdGraph = Graph<ComponentID, DepEdgeType>;
+export declare class ComponentIdGraph extends Graph<ComponentID, DepEdgeType> {
+    private _graphLib;
+    seederIds: ComponentID[];
+    constructor(nodes?: ComponentIdNode[], edges?: DependencyEdge[]);
+    get graphLib(): GraphLib.Graph;
+    protected create(nodes?: ComponentIdNode[], edges?: DependencyEdge[]): this;
+    /**
+     * check all the routes from the sources to targets and return the components found during this traversal.
+     * e.g.
+     * A -> B -> C -> N.
+     * A -> E -> N.
+     * B -> F -> G.
+     * given source: A, targets: N. The results will be: [B, C, E].
+     *
+     * if through is provided, it will only return the components that are connected to the through components.
+     * with the example above, if through is B, the results will be: [B, C].
+     */
+    findIdsFromSourcesToTargets(sources: ComponentID[], targets: ComponentID[], through?: ComponentID[]): ComponentID[];
+    /**
+     * check all the routes from the sources to targets and return the components found during this traversal.
+     * e.g.
+     * A -> B -> C -> N.
+     * A -> E -> N.
+     * B -> F -> G.
+     * given source: A, targets: N. The results will be: [B, C, E].
+     *
+     * if through is provided, it will only return the components that are connected to the through components.
+     * with the example above, if through is B, the results will be: [B, C].
+     */
+    findAllPathsFromSourcesToTargets(sources: ComponentID[], targets: ComponentID[], through?: ComponentID[]): string[][];
+    /**
+     * overrides the super class to eliminate non-seeders components
+     */
+    findCycles(graph?: this, includeDeps?: boolean): string[][];
+    buildFromCleargraph(graph: Graph<ComponentID, DepEdgeType>): ComponentIdGraph;
+    runtimeOnly(componentIds: string[]): this;
+    getDependenciesInfo(id: ComponentID): DependenciesInfo[];
+    getDependenciesAsObjectTree(idStr: string): Record<string, any>;
+    private shouldLimitToSeedersOnly;
+}
+export {};

package/dist/component-id-graph.js

@@ -0,0 +1,252 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ComponentIdGraph = void 0;
+function _componentId() {
+  const data = require("@teambit/component-id");
+  _componentId = function () {
+    return data;
+  };
+  return data;
+}
+function _graph() {
+  const data = require("@teambit/graph.cleargraph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _graphlib() {
+  const data = _interopRequireDefault(require("graphlib"));
+  _graphlib = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class ComponentIdGraph extends _graph().Graph {
+  // component IDs that started the graph. (if from workspace, the .bitmap ids normally)
+  constructor(nodes = [], edges = []) {
+    super(nodes, edges);
+    _defineProperty(this, "_graphLib", void 0);
+    _defineProperty(this, "seederIds", []);
+  }
+  get graphLib() {
+    if (!this._graphLib) {
+      // convert clearGraph to graphLib
+      this._graphLib = new (_graphlib().default.Graph)();
+      this.nodes.forEach(node => {
+        this._graphLib.setNode(node.id.toString());
+      });
+      this.edges.forEach(edge => {
+        this._graphLib.setEdge(edge.sourceId.toString(), edge.targetId.toString(), edge.attr);
+      });
+    }
+    return this._graphLib;
+  }
+  create(nodes = [], edges = []) {
+    return new ComponentIdGraph(nodes, edges);
+  }
+
+  /**
+   * check all the routes from the sources to targets and return the components found during this traversal.
+   * e.g.
+   * A -> B -> C -> N.
+   * A -> E -> N.
+   * B -> F -> G.
+   * given source: A, targets: N. The results will be: [B, C, E].
+   *
+   * if through is provided, it will only return the components that are connected to the through components.
+   * with the example above, if through is B, the results will be: [B, C].
+   */
+  findIdsFromSourcesToTargets(sources, targets, through) {
+    const removeVerFromIdStr = idStr => idStr.split('@')[0];
+    const sourcesStr = sources.map(s => s.toStringWithoutVersion());
+    const targetsStr = targets.map(t => t.toStringWithoutVersion());
+    const allFlattened = sources.map(source => this.successors(source.toString())).flat();
+    const allFlattenedIds = (0, _lodash().uniq)(allFlattened.map(f => f.id));
+    const results = [];
+    allFlattenedIds.forEach(id => {
+      const idWithNoVer = removeVerFromIdStr(id);
+      if (sourcesStr.includes(idWithNoVer) || targetsStr.includes(idWithNoVer)) return;
+      const allSuccessors = this.successors(id);
+      const allSuccessorsWithNoVersion = allSuccessors.map(s => removeVerFromIdStr(s.id));
+      if (allSuccessorsWithNoVersion.find(s => targetsStr.includes(s))) results.push(id);
+    });
+    const componentIds = this.getNodes(results).map(n => n.attr);
+    if (!through?.length) {
+      return componentIds;
+    }
+    const resultsWithThrough = [];
+    const throughStr = through.map(t => t.toStringWithoutVersion());
+    componentIds.forEach(id => {
+      const allGraph = this.subgraph(id.toString()).nodes.map(n => n.id); // successors and predecessors
+      const allGraphWithNoVersion = allGraph.map(s => removeVerFromIdStr(s));
+      if (throughStr.every(t => allGraphWithNoVersion.includes(t))) resultsWithThrough.push(id);
+    });
+    return resultsWithThrough;
+  }
+
+  /**
+   * check all the routes from the sources to targets and return the components found during this traversal.
+   * e.g.
+   * A -> B -> C -> N.
+   * A -> E -> N.
+   * B -> F -> G.
+   * given source: A, targets: N. The results will be: [B, C, E].
+   *
+   * if through is provided, it will only return the components that are connected to the through components.
+   * with the example above, if through is B, the results will be: [B, C].
+   */
+  findAllPathsFromSourcesToTargets(sources, targets, through) {
+    const removeVerFromIdStr = idStr => idStr.split('@')[0];
+    const findAllPathsBFS = (start, end) => {
+      const paths = [];
+      const visited = new Set();
+      const queue = [];
+      start.forEach(s => queue.push({
+        node: s,
+        path: [s]
+      }));
+      while (queue.length) {
+        const {
+          node,
+          path
+        } = queue.shift();
+        if (end.includes(removeVerFromIdStr(node))) {
+          paths.push([...path]);
+        } else {
+          visited.add(node);
+          const successors = this.outEdges(node).map(e => e.targetId);
+          for (const successor of successors) {
+            if (!visited.has(successor)) {
+              queue.push({
+                node: successor,
+                path: [...path, successor]
+              });
+            }
+          }
+        }
+      }
+      return paths;
+    };
+    const targetsStr = targets.map(t => t.toStringWithoutVersion());
+    const sourcesStr = sources.map(s => s.toString());
+    let allPaths = findAllPathsBFS(sourcesStr, targetsStr);
+    if (through?.length) {
+      allPaths = allPaths.filter(pathWithVer => {
+        const pathWithoutVer = pathWithVer.map(p => removeVerFromIdStr(p));
+        return through.every(t => pathWithoutVer.includes(t.toStringWithoutVersion()));
+      });
+    }
+    const filtered = allPaths.filter(path => {
+      if (path.length < 3) {
+        // if length is 1, the source and target are the same.
+        // if length is 2, the target is a direct dependency of the source. we don't care about it.
+        return false;
+      }
+      const [, firstDep] = path;
+      if (sourcesStr.includes(firstDep)) {
+        // the first item is the source. the second item "firstDep" can be a direct dependency of one of the sources.
+        // if this is the case, we have already an exact path without this firstDep.
+        return true;
+      }
+      return true;
+    });
+    return filtered.sort((a, b) => a.length - b.length);
+  }
+
+  /**
+   * overrides the super class to eliminate non-seeders components
+   */
+  findCycles(graph = this, includeDeps = false) {
+    const cycles = super.findCycles(graph);
+    // reverse the order to show a more intuitive cycle order. from the dependent to the dependency.
+    cycles.forEach(cycle => cycle.reverse());
+    if (!this.shouldLimitToSeedersOnly() || includeDeps) {
+      return cycles;
+    }
+    const seederIdsStr = this.seederIds.map(id => id.toString());
+    const cyclesWithSeeders = cycles.filter(cycle => {
+      return cycle.some(cycleIdStr => seederIdsStr.includes(cycleIdStr));
+    });
+    return cyclesWithSeeders;
+  }
+  buildFromCleargraph(graph) {
+    return this.create(graph.nodes, graph.edges);
+  }
+  runtimeOnly(componentIds) {
+    return this.successorsSubgraph(componentIds, {
+      edgeFilter: edge => edge.attr === 'prod'
+    });
+  }
+  getDependenciesInfo(id) {
+    const dijkstraResults = _graphlib().default.alg.dijkstra(this.graphLib, id.toString());
+    const dependencies = [];
+    Object.keys(dijkstraResults).forEach(idStr => {
+      const distance = dijkstraResults[idStr].distance;
+      if (distance === Infinity || distance === 0) {
+        // there is no dependency or it's the same component (distance zero)
+        return;
+      }
+      const predecessor = dijkstraResults[idStr].predecessor;
+      const dependencyType = this.edge(predecessor, idStr);
+      dependencies.push({
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        id: this.node(idStr).attr,
+        depth: distance,
+        parent: predecessor,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        dependencyType: dependencyType.attr
+      });
+    });
+    dependencies.sort((a, b) => a.depth - b.depth);
+    return dependencies;
+  }
+  getDependenciesAsObjectTree(idStr) {
+    const depsInfo = this.getDependenciesInfo(_componentId().ComponentID.fromString(idStr));
+    const populateTreeItems = (id, treeItems) => {
+      const children = depsInfo.filter(depInfo => depInfo.parent === id);
+      if (!children || children.length === 0) {
+        return;
+      }
+      children.forEach(child => {
+        const {
+          id: compId
+        } = child;
+        const label = compId.toString();
+        const currentNodes = [];
+        treeItems.push({
+          label,
+          nodes: currentNodes
+        });
+        populateTreeItems(label, currentNodes);
+      });
+    };
+    const currentNodes = [];
+    const tree = {
+      label: idStr,
+      nodes: currentNodes
+    };
+    populateTreeItems(idStr, currentNodes);
+    return tree;
+  }
+  shouldLimitToSeedersOnly() {
+    return this.seederIds.length;
+  }
+}
+exports.ComponentIdGraph = ComponentIdGraph;
+
+//# sourceMappingURL=component-id-graph.js.map