TypeScript Graph.inEdges方法代碼示例

export function generateOrder(proj: project.Project) {
	const inputGraph = new Graph<FileInput, {}>({ directed: true });

	for (const file of proj.files) {
		inputGraph.setNode(file.filename, {
			file,
			groupName: undefined
		});
	}

	for (const file of proj.files) {
		for (const dependency of file.dependencies) {
			inputGraph.setEdge(file.filename, dependency.filename);
		}
	}

	const acyclicGraph = new Graph<FileGroup, {}>({ directed: true });

	for (const group of alg.tarjan(inputGraph)) {
		acyclicGraph.setNode(group[0], {
			filenames: group
		});

		for (const member of group) {
			inputGraph.node(member).groupName = group[0];
		}
	}

	for (const filename of inputGraph.nodes()) {
		const groupName = inputGraph.node(filename).groupName;
		for (const edge of inputGraph.inEdges(filename)) {
			const otherGroup = inputGraph.node(edge.w).groupName;
			if (groupName !== otherGroup) acyclicGraph.setEdge(groupName, otherGroup);
		}
	}

	const order = alg.topsort(acyclicGraph);
	let index = 0;

	for (const groupName of order) {
		const group = acyclicGraph.node(groupName);
		const component: file.SourceFile[] = [];
		const cyclic = group.filenames.length !== 1;
		for (const filename of group.filenames) {
			const file = inputGraph.node(filename).file;
			if (cyclic) {
				file.hasCircularDependencies = true;
				file.connectedComponent = component;
				component.push(file);
			} else {
				file.hasCircularDependencies = false;
			}
			file.orderIndex = index++;
			proj.orderFiles.push(file);
		}
	}
}

  private removeFromGraph(relativePath) {
    let normalizedPath = this.pathByNamespace(relativePath);
    let id = normalizedPath.id;

    let inEdges = this.graph.inEdges(id) || []
    let inVertices = inEdges.map(edge => edge.v);
    let outEdges = this.graph.outEdges(id) || [];
    let outVertices = outEdges.map(edge => edge.w) || [];

    if (inVertices.length === 0) {
      this.graph.removeNode(id);
      outVertices.forEach(node => {
        if (this.graph.node(node)) {
          this.removeFromGraph(this.graph.node(node).relativePath);
        }
      });
    }
  }

    return patchImports.map(patch => {
      let operation = patch[0];
      let importPath = patch[1];
      if (this.graph.node(importPath)) {
        if (operation === 'connect') {
          this.graph.setEdge(relativePath, importPath);

          let inEdges = this.graph.outEdges(importPath);
          let inEdgePaths = inEdges.map(edge => this.graph.node(edge.v).inputPath);

          return [inputPath, ...inEdgePaths];
        } else if (operation === 'disconnect') {
          this.graph.removeEdge(normalizedPath.id, importPath);

          let inEdges = this.graph.inEdges(importPath);

          return null;
        }
      }
      // TODO we need to handle things coming out of node_modules
    }).filter(Boolean);