@eggjs/tegg-common-util 4.0.2-beta.19 → 4.0.2-beta.20

package/dist/Graph.d.ts

@@ -37,8 +37,17 @@ declare class Graph<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
   addVertex(node: GraphNode<T, M>): boolean;
   addEdge(from: GraphNode<T, M>, to: GraphNode<T, M>, meta?: M): boolean;
   findToNode(id: string, meta: M): GraphNode<T, M> | undefined;
+  /**
+  * @deprecated Use loopPath() instead. This method is kept for compatibility.
+  */
   appendVertexToPath(node: GraphNode<T, M>, accessPath: GraphPath<T, M>, meta?: M): boolean;
+  private buildLoopPath;
+  private findLoopPath;
   loopPath(): GraphPath<T, M> | undefined;
+  private accessNodeWithSet;
+  /**
+  * @deprecated Prefer sort(), which uses Set-based traversal directly.
+  */
   accessNode(node: GraphNode<T, M>, nodes: Array<GraphNode<T, M>>, accessed: boolean[], res: Array<GraphNode<T, M>>): void;
   sort(): Array<GraphNode<T, M>>;
 }

package/dist/Graph.js

@@ -82,37 +82,74 @@ var Graph = class {
 		if (!node) return void 0;
 		for (const { node: toNode, meta: edgeMeta } of node.toNodeMap.values()) if (edgeMeta && meta.equal(edgeMeta)) return toNode;
 	}
+	/**
+	* @deprecated Use loopPath() instead. This method is kept for compatibility.
+	*/
 	appendVertexToPath(node, accessPath, meta) {
 		if (!accessPath.pushVertex(node, meta)) return false;
 		for (const toNode of node.toNodeMap.values()) if (!this.appendVertexToPath(toNode.node, accessPath, toNode.meta)) return false;
 		accessPath.popVertex();
 		return true;
 	}
-	loopPath() {
+	buildLoopPath(stack, node, meta) {
 		const accessPath = new GraphPath();
+		for (const pathNode of stack) accessPath.pushVertex(pathNode.node, pathNode.meta);
+		accessPath.pushVertex(node, meta);
+		return accessPath;
+	}
+	findLoopPath(node, visiting, visited, stack, meta) {
+		if (visited.has(node.id)) return;
+		if (visiting.has(node.id)) return this.buildLoopPath(stack, node, meta);
+		visiting.add(node.id);
+		stack.push({
+			node,
+			meta
+		});
+		for (const toNode of node.toNodeMap.values()) {
+			const loopPath = this.findLoopPath(toNode.node, visiting, visited, stack, toNode.meta);
+			if (loopPath) return loopPath;
+		}
+		stack.pop();
+		visiting.delete(node.id);
+		visited.add(node.id);
+	}
+	loopPath() {
+		const visiting = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [];
 		const nodes = Array.from(this.nodes.values());
-		for (const node of nodes) if (!this.appendVertexToPath(node, accessPath)) return accessPath;
+		for (const node of nodes) {
+			const loopPath = this.findLoopPath(node, visiting, visited, stack);
+			if (loopPath) return loopPath;
+		}
 	}
-	accessNode(node, nodes, accessed, res) {
-		if (accessed[nodes.indexOf(node)]) return;
-		if (!node.toNodeMap.size) {
-			accessed[nodes.indexOf(node)] = true;
-			res.push(node);
-			return;
+	accessNodeWithSet(node, accessed, visiting, res) {
+		if (accessed.has(node)) return;
+		if (visiting.has(node)) throw new Error("graph has recursive deps: " + node);
+		visiting.add(node);
+		try {
+			for (const toNode of node.toNodeMap.values()) this.accessNodeWithSet(toNode.node, accessed, visiting, res);
+		} finally {
+			visiting.delete(node);
 		}
-		for (const toNode of node.toNodeMap.values()) this.accessNode(toNode.node, nodes, accessed, res);
-		accessed[nodes.indexOf(node)] = true;
+		accessed.add(node);
 		res.push(node);
 	}
+	/**
+	* @deprecated Prefer sort(), which uses Set-based traversal directly.
+	*/
+	accessNode(node, nodes, accessed, res) {
+		const accessedSet = /* @__PURE__ */ new Set();
+		for (let i = 0; i < nodes.length; ++i) if (accessed[i]) accessedSet.add(nodes[i]);
+		this.accessNodeWithSet(node, accessedSet, /* @__PURE__ */ new Set(), res);
+		for (let i = 0; i < nodes.length; ++i) accessed[i] = accessedSet.has(nodes[i]);
+	}
 	sort() {
 		const res = [];
 		const nodes = Array.from(this.nodes.values());
-		const accessed = [];
-		for (let i = 0; i < nodes.length; ++i) accessed.push(false);
-		for (let i = 0; i < nodes.length; ++i) {
-			const node = nodes[i];
-			this.accessNode(node, nodes, accessed, res);
-		}
+		const accessed = /* @__PURE__ */ new Set();
+		const visiting = /* @__PURE__ */ new Set();
+		for (const node of nodes) this.accessNodeWithSet(node, accessed, visiting, res);
 		return res;
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/tegg-common-util",
-  "version": "4.0.2-beta.19",
+  "version": "4.0.2-beta.20",
   "description": "common util for tegg",
   "keywords": [
     "collection",
@@ -41,8 +41,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@eggjs/tegg-types": "4.0.2-beta.19",
-    "@eggjs/utils": "5.0.2-beta.19",
+    "@eggjs/tegg-types": "4.0.2-beta.20",
+    "@eggjs/utils": "5.0.2-beta.20",
     "extend2": "^4.0.0",
     "globby": "^11.0.2",
     "js-yaml": "^4.1.1",