@rsconcept/domain 1.0.0

package/dist/graph/graph.js

@@ -0,0 +1,385 @@
+// 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;
+  }
+};
+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
+};
+//# sourceMappingURL=graph.js.map

package/dist/graph/graph.js.map

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

package/dist/graph/index.d.ts

@@ -0,0 +1 @@
+export { Graph } from './graph.js';