@rsconcept/domain 1.0.0 → 1.2.0

package/dist/graph/graph.js

@@ -1,385 +1,342 @@
-// src/graph/graph.ts
-var GraphNode = class _GraphNode {
-  /** Unique identifier of the node. */
-  id;
-  /** List of outgoing nodes. */
-  outputs;
-  /** List of incoming nodes. */
-  inputs;
-  constructor(id) {
-    this.id = id;
-    this.outputs = [];
-    this.inputs = [];
-  }
-  clone() {
-    const result = new _GraphNode(this.id);
-    result.outputs = [...this.outputs];
-    result.inputs = [...this.inputs];
-    return result;
-  }
-  addOutput(node) {
-    this.outputs.push(node);
-  }
-  addInput(node) {
-    this.inputs.push(node);
-  }
-  removeInput(target) {
-    const index = this.inputs.findIndex((node) => node === target);
-    return index > -1 ? this.inputs.splice(index, 1)[0] : null;
-  }
-  removeOutput(target) {
-    const index = this.outputs.findIndex((node) => node === target);
-    return index > -1 ? this.outputs.splice(index, 1)[0] : null;
-  }
+//#region src/graph/graph.ts
+/**
+* Module: Custom graph data structure.
+*/
+/** Represents single node of a {@link Graph}, as implemented by storing outgoing and incoming connections. */
+var GraphNode = class GraphNode {
+	/** Unique identifier of the node. */
+	id;
+	/** List of outgoing nodes. */
+	outputs;
+	/** List of incoming nodes. */
+	inputs;
+	constructor(id) {
+		this.id = id;
+		this.outputs = [];
+		this.inputs = [];
+	}
+	clone() {
+		const result = new GraphNode(this.id);
+		result.outputs = [...this.outputs];
+		result.inputs = [...this.inputs];
+		return result;
+	}
+	addOutput(node) {
+		this.outputs.push(node);
+	}
+	addInput(node) {
+		this.inputs.push(node);
+	}
+	removeInput(target) {
+		const index = this.inputs.findIndex((node) => node === target);
+		return index > -1 ? this.inputs.splice(index, 1)[0] : null;
+	}
+	removeOutput(target) {
+		const index = this.outputs.findIndex((node) => node === target);
+		return index > -1 ? this.outputs.splice(index, 1)[0] : null;
+	}
 };
-var Graph = class _Graph {
-  /** Map of nodes. */
-  nodes = /* @__PURE__ */ new Map();
-  constructor(arr) {
-    if (!arr) {
-      return;
-    }
-    arr.forEach((edge) => {
-      if (edge.length === 1) {
-        this.addNode(edge[0]);
-      } else {
-        this.addEdge(edge[0], edge[1]);
-      }
-    });
-  }
-  clone() {
-    const result = new _Graph();
-    this.nodes.forEach((node) => result.nodes.set(node.id, node.clone()));
-    return result;
-  }
-  at(target) {
-    return this.nodes.get(target);
-  }
-  addNode(target) {
-    let node = this.nodes.get(target);
-    if (!node) {
-      node = new GraphNode(target);
-      this.nodes.set(target, node);
-    }
-    return node;
-  }
-  hasNode(target) {
-    return !!this.nodes.get(target);
-  }
-  removeNode(target) {
-    this.nodes.forEach((node) => {
-      node.removeInput(target);
-      node.removeOutput(target);
-    });
-    this.nodes.delete(target);
-  }
-  foldNode(target) {
-    const nodeToRemove = this.nodes.get(target);
-    if (!nodeToRemove) {
-      return;
-    }
-    nodeToRemove.inputs.forEach((input) => {
-      nodeToRemove.outputs.forEach((output) => {
-        this.addEdge(input, output);
-      });
-    });
-    this.removeNode(target);
-  }
-  removeIsolated() {
-    const result = [];
-    this.nodes.forEach((node) => {
-      if (node.outputs.length === 0 && node.inputs.length === 0) {
-        result.push(node);
-        this.nodes.delete(node.id);
-      }
-    });
-    return result;
-  }
-  addEdge(source, destination) {
-    if (this.hasEdge(source, destination)) {
-      return;
-    }
-    const sourceNode = this.addNode(source);
-    const destinationNode = this.addNode(destination);
-    sourceNode.addOutput(destinationNode.id);
-    destinationNode.addInput(sourceNode.id);
-  }
-  removeEdge(source, destination) {
-    const sourceNode = this.nodes.get(source);
-    const destinationNode = this.nodes.get(destination);
-    if (sourceNode && destinationNode) {
-      sourceNode.removeOutput(destination);
-      destinationNode.removeInput(source);
-    }
-  }
-  hasEdge(source, destination) {
-    const sourceNode = this.nodes.get(source);
-    if (!sourceNode) {
-      return false;
-    }
-    return !!sourceNode.outputs.find((id) => id === destination);
-  }
-  isReachable(source, destination) {
-    return this.expandAllOutputs([source]).includes(destination);
-  }
-  rootNodes() {
-    return [...this.nodes.keys()].filter((id) => !this.nodes.get(id)?.inputs.length);
-  }
-  expandOutputs(origin) {
-    const result = [];
-    origin.forEach((id) => {
-      const node = this.nodes.get(id);
-      if (node) {
-        node.outputs.forEach((child) => {
-          if (!origin.includes(child) && !result.includes(child)) {
-            result.push(child);
-          }
-        });
-      }
-    });
-    return result;
-  }
-  expandInputs(origin) {
-    const result = [];
-    origin.forEach((id) => {
-      const node = this.nodes.get(id);
-      if (node) {
-        node.inputs.forEach((child) => {
-          if (!origin.includes(child) && !result.includes(child)) {
-            result.push(child);
-          }
-        });
-      }
-    });
-    return result;
-  }
-  expandAllOutputs(origin) {
-    const result = this.expandOutputs(origin);
-    if (result.length === 0) {
-      return [];
-    }
-    const marked = /* @__PURE__ */ new Map();
-    origin.forEach((id) => marked.set(id, true));
-    let position = 0;
-    while (position < result.length) {
-      const node = this.nodes.get(result[position]);
-      if (node && !marked.get(node.id)) {
-        marked.set(node.id, true);
-        node.outputs.forEach((child) => {
-          if (!marked.get(child) && !result.find((id) => id === child)) {
-            result.push(child);
-          }
-        });
-      }
-      position += 1;
-    }
-    return result;
-  }
-  expandAllInputs(origin) {
-    const result = this.expandInputs(origin);
-    if (result.length === 0) {
-      return [];
-    }
-    const marked = /* @__PURE__ */ new Map();
-    origin.forEach((id) => marked.set(id, true));
-    let position = 0;
-    while (position < result.length) {
-      const node = this.nodes.get(result[position]);
-      if (node && !marked.get(node.id)) {
-        marked.set(node.id, true);
-        node.inputs.forEach((child) => {
-          if (!marked.get(child) && !result.find((id) => id === child)) {
-            result.push(child);
-          }
-        });
-      }
-      position += 1;
-    }
-    return result;
-  }
-  maximizePart(origin) {
-    const outputs = this.expandAllOutputs(origin);
-    const result = [...origin];
-    this.topologicalOrder().filter((id) => outputs.includes(id)).forEach((id) => {
-      const node = this.nodes.get(id);
-      if (node?.inputs.every((parent) => result.includes(parent))) {
-        result.push(id);
-      }
-    });
-    return result;
-  }
-  topologicalOrder() {
-    const result = [];
-    const marked = /* @__PURE__ */ new Set();
-    const nodeStack = [];
-    this.nodes.forEach((node) => {
-      if (marked.has(node.id)) {
-        return;
-      }
-      nodeStack.push(node.id);
-      while (nodeStack.length > 0) {
-        const item = nodeStack[nodeStack.length - 1];
-        if (marked.has(item)) {
-          if (!result.find((id) => id === item)) {
-            result.push(item);
-          }
-          nodeStack.pop();
-        } else {
-          marked.add(item);
-          const itemNode = this.nodes.get(item);
-          if (itemNode && itemNode.outputs.length > 0) {
-            itemNode.outputs.forEach((child) => {
-              if (!marked.has(child)) {
-                nodeStack.push(child);
-              }
-            });
-          }
-        }
-      }
-    });
-    return result.reverse();
-  }
-  /**
-   * Stably reorders the given node ids so that, for this DAG, no node appears before a transitive
-   * successor (edges: source → dependent; {@link GraphNode.outputs} lists dependents).
-   */
-  sortStable(target) {
-    if (target.length <= 1) {
-      return [...target];
-    }
-    const reachable = this.buildTransitiveClosureForSort();
-    const testSet = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const nodeId of [...target].reverse()) {
-      const nodeReachable = reachable.get(nodeId) ?? /* @__PURE__ */ new Set();
-      const needMove = testSet.has(nodeId);
-      for (const childId of nodeReachable) {
-        testSet.add(childId);
-      }
-      if (!needMove) {
-        result.push(nodeId);
-        continue;
-      }
-      let inserted = false;
-      for (let index = 0; index < result.length; index++) {
-        const parent = result[index];
-        const parentReachable = reachable.get(parent) ?? /* @__PURE__ */ new Set();
-        if (nodeReachable.has(parent)) {
-          if (parentReachable.has(nodeId)) {
-            result.push(nodeId);
-          } else {
-            result.splice(index, 0, nodeId);
-          }
-          inserted = true;
-          break;
-        }
-      }
-      if (!inserted) {
-        result.push(nodeId);
-      }
-    }
-    result.reverse();
-    return result;
-  }
-  buildTransitiveClosureForSort() {
-    const closure = /* @__PURE__ */ new Map();
-    for (const node of this.nodes.values()) {
-      closure.set(node.id, new Set(node.outputs));
-    }
-    const order = this.topologicalOrder();
-    for (const nodeId of [...order].reverse()) {
-      const node = this.at(nodeId);
-      if (!node) {
-        continue;
-      }
-      const nodeClosure = closure.get(nodeId) ?? /* @__PURE__ */ new Set();
-      for (const parentId of node.inputs) {
-        const parentClosure = closure.get(parentId) ?? /* @__PURE__ */ new Set();
-        for (const childId of nodeClosure) {
-          parentClosure.add(childId);
-        }
-        closure.set(parentId, parentClosure);
-      }
-    }
-    return closure;
-  }
-  transitiveReduction() {
-    const order = this.topologicalOrder();
-    const marked = /* @__PURE__ */ new Map();
-    order.forEach((nodeID) => {
-      if (marked.get(nodeID)) {
-        return;
-      }
-      const stack = [];
-      stack.push({ id: nodeID, parents: [] });
-      while (stack.length > 0) {
-        const item = stack.splice(0, 1)[0];
-        const node = this.nodes.get(item.id);
-        if (node) {
-          node.outputs.forEach((child) => {
-            item.parents.forEach((parent) => this.removeEdge(parent, child));
-            stack.push({ id: child, parents: [item.id, ...item.parents] });
-          });
-        }
-        marked.set(item.id, true);
-      }
-    });
-  }
-  /**
-   * Finds a cycle in the graph.
-   *
-   * @returns {NodeID[] | null} The cycle if found, otherwise `null`.
-   * Uses non-recursive DFS.
-   */
-  findCycle() {
-    const visited = /* @__PURE__ */ new Set();
-    const nodeStack = /* @__PURE__ */ new Set();
-    const parents = /* @__PURE__ */ new Map();
-    for (const nodeId of this.nodes.keys()) {
-      if (visited.has(nodeId)) {
-        continue;
-      }
-      const callStack = [];
-      callStack.push({ nodeId, parentId: null });
-      while (callStack.length > 0) {
-        const { nodeId: nodeId2, parentId } = callStack[callStack.length - 1];
-        if (visited.has(nodeId2)) {
-          nodeStack.delete(nodeId2);
-          callStack.pop();
-          continue;
-        }
-        visited.add(nodeId2);
-        nodeStack.add(nodeId2);
-        if (parentId !== null) {
-          parents.set(nodeId2, parentId);
-        }
-        const currentNode = this.nodes.get(nodeId2);
-        for (const child of currentNode.outputs) {
-          if (!visited.has(child)) {
-            callStack.push({ nodeId: child, parentId: nodeId2 });
-            continue;
-          }
-          if (!nodeStack.has(child)) {
-            continue;
-          }
-          const cycle = [];
-          let current = nodeId2;
-          cycle.push(child);
-          while (current !== child) {
-            cycle.push(current);
-            current = parents.get(current);
-          }
-          cycle.push(child);
-          cycle.reverse();
-          return cycle;
-        }
-      }
-    }
-    return null;
-  }
-};
-export {
-  Graph,
-  GraphNode
+/**
+* Represents a Graph.
+*
+* This class is optimized for TermGraph use case and not supposed to be used as generic graph implementation.
+*/
+var Graph = class Graph {
+	/** Map of nodes. */
+	nodes = /* @__PURE__ */ new Map();
+	constructor(arr) {
+		if (!arr) return;
+		arr.forEach((edge) => {
+			if (edge.length === 1) this.addNode(edge[0]);
+			else this.addEdge(edge[0], edge[1]);
+		});
+	}
+	clone() {
+		const result = new Graph();
+		this.nodes.forEach((node) => result.nodes.set(node.id, node.clone()));
+		return result;
+	}
+	at(target) {
+		return this.nodes.get(target);
+	}
+	addNode(target) {
+		let node = this.nodes.get(target);
+		if (!node) {
+			node = new GraphNode(target);
+			this.nodes.set(target, node);
+		}
+		return node;
+	}
+	hasNode(target) {
+		return !!this.nodes.get(target);
+	}
+	removeNode(target) {
+		this.nodes.forEach((node) => {
+			node.removeInput(target);
+			node.removeOutput(target);
+		});
+		this.nodes.delete(target);
+	}
+	foldNode(target) {
+		const nodeToRemove = this.nodes.get(target);
+		if (!nodeToRemove) return;
+		nodeToRemove.inputs.forEach((input) => {
+			nodeToRemove.outputs.forEach((output) => {
+				this.addEdge(input, output);
+			});
+		});
+		this.removeNode(target);
+	}
+	removeIsolated() {
+		const result = [];
+		this.nodes.forEach((node) => {
+			if (node.outputs.length === 0 && node.inputs.length === 0) {
+				result.push(node);
+				this.nodes.delete(node.id);
+			}
+		});
+		return result;
+	}
+	addEdge(source, destination) {
+		if (this.hasEdge(source, destination)) return;
+		const sourceNode = this.addNode(source);
+		const destinationNode = this.addNode(destination);
+		sourceNode.addOutput(destinationNode.id);
+		destinationNode.addInput(sourceNode.id);
+	}
+	removeEdge(source, destination) {
+		const sourceNode = this.nodes.get(source);
+		const destinationNode = this.nodes.get(destination);
+		if (sourceNode && destinationNode) {
+			sourceNode.removeOutput(destination);
+			destinationNode.removeInput(source);
+		}
+	}
+	hasEdge(source, destination) {
+		const sourceNode = this.nodes.get(source);
+		if (!sourceNode) return false;
+		return !!sourceNode.outputs.find((id) => id === destination);
+	}
+	isReachable(source, destination) {
+		return this.expandAllOutputs([source]).includes(destination);
+	}
+	rootNodes() {
+		return [...this.nodes.keys()].filter((id) => !this.nodes.get(id)?.inputs.length);
+	}
+	expandOutputs(origin) {
+		const result = [];
+		origin.forEach((id) => {
+			const node = this.nodes.get(id);
+			if (node) node.outputs.forEach((child) => {
+				if (!origin.includes(child) && !result.includes(child)) result.push(child);
+			});
+		});
+		return result;
+	}
+	expandInputs(origin) {
+		const result = [];
+		origin.forEach((id) => {
+			const node = this.nodes.get(id);
+			if (node) node.inputs.forEach((child) => {
+				if (!origin.includes(child) && !result.includes(child)) result.push(child);
+			});
+		});
+		return result;
+	}
+	expandAllOutputs(origin) {
+		const result = this.expandOutputs(origin);
+		if (result.length === 0) return [];
+		const marked = /* @__PURE__ */ new Map();
+		origin.forEach((id) => marked.set(id, true));
+		let position = 0;
+		while (position < result.length) {
+			const node = this.nodes.get(result[position]);
+			if (node && !marked.get(node.id)) {
+				marked.set(node.id, true);
+				node.outputs.forEach((child) => {
+					if (!marked.get(child) && !result.find((id) => id === child)) result.push(child);
+				});
+			}
+			position += 1;
+		}
+		return result;
+	}
+	expandAllInputs(origin) {
+		const result = this.expandInputs(origin);
+		if (result.length === 0) return [];
+		const marked = /* @__PURE__ */ new Map();
+		origin.forEach((id) => marked.set(id, true));
+		let position = 0;
+		while (position < result.length) {
+			const node = this.nodes.get(result[position]);
+			if (node && !marked.get(node.id)) {
+				marked.set(node.id, true);
+				node.inputs.forEach((child) => {
+					if (!marked.get(child) && !result.find((id) => id === child)) result.push(child);
+				});
+			}
+			position += 1;
+		}
+		return result;
+	}
+	maximizePart(origin) {
+		const outputs = this.expandAllOutputs(origin);
+		const result = [...origin];
+		this.topologicalOrder().filter((id) => outputs.includes(id)).forEach((id) => {
+			if (this.nodes.get(id)?.inputs.every((parent) => result.includes(parent))) result.push(id);
+		});
+		return result;
+	}
+	topologicalOrder() {
+		const result = [];
+		const marked = /* @__PURE__ */ new Set();
+		const nodeStack = [];
+		this.nodes.forEach((node) => {
+			if (marked.has(node.id)) return;
+			nodeStack.push(node.id);
+			while (nodeStack.length > 0) {
+				const item = nodeStack[nodeStack.length - 1];
+				if (marked.has(item)) {
+					if (!result.find((id) => id === item)) result.push(item);
+					nodeStack.pop();
+				} else {
+					marked.add(item);
+					const itemNode = this.nodes.get(item);
+					if (itemNode && itemNode.outputs.length > 0) itemNode.outputs.forEach((child) => {
+						if (!marked.has(child)) nodeStack.push(child);
+					});
+				}
+			}
+		});
+		return result.reverse();
+	}
+	/**
+	* Stably reorders the given node ids so that, for this DAG, no node appears before a transitive
+	* successor (edges: source → dependent; {@link GraphNode.outputs} lists dependents).
+	*/
+	sortStable(target) {
+		if (target.length <= 1) return [...target];
+		const reachable = this.buildTransitiveClosureForSort();
+		const testSet = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const nodeId of [...target].reverse()) {
+			const nodeReachable = reachable.get(nodeId) ?? /* @__PURE__ */ new Set();
+			const needMove = testSet.has(nodeId);
+			for (const childId of nodeReachable) testSet.add(childId);
+			if (!needMove) {
+				result.push(nodeId);
+				continue;
+			}
+			let inserted = false;
+			for (let index = 0; index < result.length; index++) {
+				const parent = result[index];
+				const parentReachable = reachable.get(parent) ?? /* @__PURE__ */ new Set();
+				if (nodeReachable.has(parent)) {
+					if (parentReachable.has(nodeId)) result.push(nodeId);
+					else result.splice(index, 0, nodeId);
+					inserted = true;
+					break;
+				}
+			}
+			if (!inserted) result.push(nodeId);
+		}
+		result.reverse();
+		return result;
+	}
+	buildTransitiveClosureForSort() {
+		const closure = /* @__PURE__ */ new Map();
+		for (const node of this.nodes.values()) closure.set(node.id, new Set(node.outputs));
+		const order = this.topologicalOrder();
+		for (const nodeId of [...order].reverse()) {
+			const node = this.at(nodeId);
+			if (!node) continue;
+			const nodeClosure = closure.get(nodeId) ?? /* @__PURE__ */ new Set();
+			for (const parentId of node.inputs) {
+				const parentClosure = closure.get(parentId) ?? /* @__PURE__ */ new Set();
+				for (const childId of nodeClosure) parentClosure.add(childId);
+				closure.set(parentId, parentClosure);
+			}
+		}
+		return closure;
+	}
+	transitiveReduction() {
+		const order = this.topologicalOrder();
+		const marked = /* @__PURE__ */ new Map();
+		order.forEach((nodeID) => {
+			if (marked.get(nodeID)) return;
+			const stack = [];
+			stack.push({
+				id: nodeID,
+				parents: []
+			});
+			while (stack.length > 0) {
+				const item = stack.splice(0, 1)[0];
+				const node = this.nodes.get(item.id);
+				if (node) node.outputs.forEach((child) => {
+					item.parents.forEach((parent) => this.removeEdge(parent, child));
+					stack.push({
+						id: child,
+						parents: [item.id, ...item.parents]
+					});
+				});
+				marked.set(item.id, true);
+			}
+		});
+	}
+	/**
+	* Finds a cycle in the graph.
+	*
+	* @returns {NodeID[] | null} The cycle if found, otherwise `null`.
+	* Uses non-recursive DFS.
+	*/
+	findCycle() {
+		const visited = /* @__PURE__ */ new Set();
+		const nodeStack = /* @__PURE__ */ new Set();
+		const parents = /* @__PURE__ */ new Map();
+		for (const nodeId of this.nodes.keys()) {
+			if (visited.has(nodeId)) continue;
+			const callStack = [];
+			callStack.push({
+				nodeId,
+				parentId: null
+			});
+			while (callStack.length > 0) {
+				const { nodeId, parentId } = callStack[callStack.length - 1];
+				if (visited.has(nodeId)) {
+					nodeStack.delete(nodeId);
+					callStack.pop();
+					continue;
+				}
+				visited.add(nodeId);
+				nodeStack.add(nodeId);
+				if (parentId !== null) parents.set(nodeId, parentId);
+				const currentNode = this.nodes.get(nodeId);
+				for (const child of currentNode.outputs) {
+					if (!visited.has(child)) {
+						callStack.push({
+							nodeId: child,
+							parentId: nodeId
+						});
+						continue;
+					}
+					if (!nodeStack.has(child)) continue;
+					const cycle = [];
+					let current = nodeId;
+					cycle.push(child);
+					while (current !== child) {
+						cycle.push(current);
+						current = parents.get(current);
+					}
+					cycle.push(child);
+					cycle.reverse();
+					return cycle;
+				}
+			}
+		}
+		return null;
+	}
 };
+//#endregion
+export { Graph, GraphNode };
+
 //# sourceMappingURL=graph.js.map