@3plate/graph-core 0.1.0 → 0.1.4

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@3plate/graph-core",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "type": "module",
   "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/3plt/graph",
+    "directory": "packages/core"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     }
@@ -24,12 +30,13 @@
   },
   "dependencies": {
     "immutable": "^5.1.4",
+    "jsx-dom": "^8.1.6",
     "winston": "^3.18.3",
     "winston-transport": "^4.9.0"
   },
   "scripts": {
-    "build": "tsup src/index.js --format cjs,esm",
-    "dev": "tsup src/index.js --format cjs,esm --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "test": "vitest run",
     "test:watch": "vitest"
   }

package/dist/index.d.mts

@@ -1,51 +0,0 @@
-interface EdgeProps {
-    sourceId: string;
-    targetId: string;
-    label?: string;
-    sourcePort?: string;
-    targetPort?: string;
-}
-type EdgeExtractor<E> = (edge: E) => EdgeProps;
-declare class GraphEdge<N, E> {
-    id: string;
-    props: EdgeProps;
-    data: E;
-    source: GraphNode<N, E>;
-    target: GraphNode<N, E>;
-    constructor(props: EdgeProps, data: E, source: GraphNode<N, E>, target: GraphNode<N, E>);
-}
-
-interface NodeProps {
-    id: string;
-    inPorts?: string[];
-    outPorts?: string[];
-}
-type NodeExtractor<N> = (node: N) => NodeProps;
-declare class GraphNode<N, E> {
-    props: NodeProps;
-    data: N;
-    pred: Map<GraphEdge<N, E>, GraphNode<N, E> | null> | undefined;
-    succ: Map<GraphEdge<N, E>, GraphNode<N, E> | null> | undefined;
-    prior: GraphNode<N, E> | undefined;
-    constructor(props: NodeProps, data: N);
-}
-
-declare class Graph<N, E> {
-    nodeMap: Map<string, GraphNode<N, E> | null> | undefined;
-    edgeMap: Map<string, GraphEdge<N, E> | null> | undefined;
-    prior: Graph<N, E> | undefined;
-    complete: boolean;
-    numNodes: number;
-    numEdges: number;
-    constructor();
-    isEmpty(): boolean;
-    _walk<T>(mapFn: (graph: Graph<N, E>) => Map<string, T | null> | undefined): IterableIterator<T>;
-    nodes(): IterableIterator<GraphNode<N, E>>;
-    edges(): IterableIterator<GraphEdge<N, E>>;
-    getNode(id: string): GraphNode<N, E> | undefined;
-    getEdge(id: string): GraphEdge<N, E> | undefined;
-    hasNode(id: string): boolean;
-    hasEdge(id: string): boolean;
-}
-
-export { type EdgeExtractor, type EdgeProps, Graph, GraphEdge, GraphNode, type NodeExtractor, type NodeProps };

package/dist/index.mjs

@@ -1,323 +0,0 @@
-// src/node.js
-var GraphNode = class {
-  constructor(props, data) {
-    this.props = props;
-    this.data = data;
-    this.sourceMap = /* @__PURE__ */ new Map();
-    this.targetMap = /* @__PURE__ */ new Map();
-    this.complete = true;
-  }
-  *_walk(mapFn) {
-    let current = this;
-    const seen = /* @__PURE__ */ new Set();
-    while (current) {
-      const map = mapFn(current);
-      if (map) {
-        for (const [edge, node] of map) {
-          if (!seen.has(edge.id)) {
-            seen.add(edge.id);
-            if (node !== null) {
-              yield edge;
-            }
-          }
-        }
-      }
-      if (current.complete) break;
-      current = current.prior;
-    }
-  }
-  sourceEdges() {
-    return this._walk((node) => node.sourceMap);
-  }
-  targetEdges() {
-    return this._walk((node) => node.targetMap);
-  }
-  *sourceNodes() {
-    for (const edge of this.sourceEdges()) {
-      yield edge.source;
-    }
-  }
-  *targetNodes() {
-    for (const edge of this.targetEdges()) {
-      yield edge.target;
-    }
-  }
-};
-
-// src/edge.js
-var GraphEdge = class {
-  constructor(props, data, source, target) {
-    this.id = `${props.sourceId}-${props.targetId}`;
-    this.props = props;
-    this.data = data;
-    this.source = source;
-    this.target = target;
-  }
-};
-
-// src/graph.js
-var Graph = class {
-  constructor() {
-    this.nodeMap = /* @__PURE__ */ new Map();
-    this.edgeMap = /* @__PURE__ */ new Map();
-    this.numNodes = 0;
-    this.numEdges = 0;
-    this.complete = true;
-  }
-  isEmpty() {
-    return this.numNodes === 0 && this.numEdges === 0;
-  }
-  *_walk(mapFn) {
-    const seen = /* @__PURE__ */ new Set();
-    let current = this;
-    while (current) {
-      const map = mapFn(current);
-      if (map) {
-        for (const [id, node] of map) {
-          if (!seen.has(id)) {
-            seen.add(id);
-            if (node !== null) {
-              yield node;
-            }
-          }
-        }
-      }
-      if (current.complete) break;
-      current = current.prior;
-    }
-  }
-  nodes() {
-    return this._walk((graph) => graph.nodeMap);
-  }
-  edges() {
-    return this._walk((graph) => graph.edgeMap);
-  }
-  getNode(id) {
-    let current = this;
-    while (current) {
-      const node = current.nodeMap?.get(id);
-      if (node === null) return void 0;
-      else if (node !== void 0) return node;
-      if (current.complete) break;
-      current = current.prior;
-    }
-    return void 0;
-  }
-  getEdge(id) {
-    let current = this;
-    while (current) {
-      const edge = current.edgeMap?.get(id);
-      if (edge === null) return void 0;
-      else if (edge !== void 0) return edge;
-      if (current.complete) break;
-      current = current.prior;
-    }
-    return void 0;
-  }
-  hasNode(id) {
-    const node = this.getNode(id);
-    return node !== void 0;
-  }
-  hasEdge(id) {
-    const edge = this.getEdge(id);
-    return edge !== void 0;
-  }
-};
-
-// src/topo-sort.js
-var TopoSort = class {
-  constructor(graph, prior) {
-    this.graph = graph;
-    this.prior = prior;
-    this.dirty = true;
-  }
-  computeIncremental() {
-    if (!this.prior || this.graph.complete) {
-      return false;
-    }
-    this.levelMap = /* @__PURE__ */ new Map();
-    const addedNodes = /* @__PURE__ */ new Set();
-    const deletedNodes = /* @__PURE__ */ new Set();
-    const affectedNodes = /* @__PURE__ */ new Set();
-    if (this.graph.nodeMap) {
-      for (const [id, node] of this.graph.nodeMap) {
-        if (node === null) {
-          deletedNodes.add(id);
-          this.levelMap.delete(id);
-        } else if (!this.levelMap.has(id)) {
-          addedNodes.add(id);
-        }
-      }
-    }
-    const totalNodes = Array.from(this.graph.nodes()).length;
-    const changeRatio = (addedNodes.size + deletedNodes.size) / totalNodes;
-    if (changeRatio > 0.3 || totalNodes < 20) {
-      return false;
-    }
-    for (const nodeId of deletedNodes) {
-      const priorNode = this.graph.prior.getNode(nodeId);
-      if (priorNode) {
-        for (const targetNode of priorNode.targetNodes()) {
-          affectedNodes.add(targetNode.props.id);
-        }
-      }
-    }
-    for (const nodeId of addedNodes) {
-      const node = this.graph.getNode(nodeId);
-      if (!node) continue;
-      let maxPredLevel = -1;
-      for (const sourceNode of node.sourceNodes()) {
-        const sourceLevel = this.levelMap.get(sourceNode.props.id);
-        if (sourceLevel !== void 0) {
-          maxPredLevel = Math.max(maxPredLevel, sourceLevel);
-        }
-      }
-      this.levelMap.set(nodeId, maxPredLevel + 1);
-      for (const targetNode of node.targetNodes()) {
-        affectedNodes.add(targetNode.props.id);
-      }
-    }
-    const queue = Array.from(affectedNodes);
-    const visited = /* @__PURE__ */ new Set();
-    while (queue.length > 0) {
-      const nodeId = queue.shift();
-      if (visited.has(nodeId)) continue;
-      visited.add(nodeId);
-      const node = this.graph.getNode(nodeId);
-      if (!node) continue;
-      let maxPredLevel = -1;
-      for (const sourceNode of node.sourceNodes()) {
-        const sourceLevel = this.levelMap.get(sourceNode.props.id);
-        if (sourceLevel !== void 0) {
-          maxPredLevel = Math.max(maxPredLevel, sourceLevel);
-        }
-      }
-      const oldLevel = this.levelMap.get(nodeId) ?? -1;
-      const newLevel = maxPredLevel + 1;
-      if (newLevel !== oldLevel) {
-        this.levelMap.set(nodeId, newLevel);
-        for (const targetNode of node.targetNodes()) {
-          if (!visited.has(targetNode.props.id)) {
-            queue.push(targetNode.props.id);
-          }
-        }
-      }
-    }
-    return true;
-  }
-  computeFull() {
-    this.levelMap = /* @__PURE__ */ new Map();
-    const inDegree = /* @__PURE__ */ new Map();
-    const queue = [];
-    for (const node of this.graph.nodes()) {
-      let degree = 0;
-      for (const _ of node.sourceEdges()) {
-        degree++;
-      }
-      inDegree.set(node.props.id, degree);
-      if (degree === 0) {
-        this.levelMap.set(node.props.id, 0);
-        queue.push(node);
-      }
-    }
-    let processed = 0;
-    while (queue.length > 0) {
-      const node = queue.shift();
-      const currentLevel = this.levelMap.get(node.props.id);
-      processed++;
-      for (const targetNode of node.targetNodes()) {
-        const targetId = targetNode.props.id;
-        const degree = inDegree.get(targetId) - 1;
-        inDegree.set(targetId, degree);
-        if (degree === 0) {
-          this.levelMap.set(targetId, currentLevel + 1);
-          queue.push(targetNode);
-        }
-      }
-    }
-    const totalNodes = Array.from(this.graph.nodes()).length;
-    if (processed !== totalNodes) {
-      throw new Error("Graph contains a cycle - topological sort not possible");
-    }
-    this.dirty = false;
-  }
-  compute() {
-    if (this.computeIncremental()) {
-      this.dirty = false;
-      return;
-    }
-    this.computeFull();
-  }
-  getLevel(nodeId) {
-    if (this.dirty) {
-      this.compute();
-    }
-    return this.levelMap?.get(nodeId);
-  }
-  getLevels() {
-    if (this.dirty) {
-      this.compute();
-    }
-    return new Map(this.levelMap);
-  }
-  *nodes() {
-    if (this.dirty) {
-      this.compute();
-    }
-    const nodesByLevel = /* @__PURE__ */ new Map();
-    for (const node of this.graph.nodes()) {
-      const level = this.levelMap?.get(node.props.id);
-      if (level !== void 0) {
-        if (!nodesByLevel.has(level)) {
-          nodesByLevel.set(level, []);
-        }
-        nodesByLevel.get(level).push(node);
-      }
-    }
-    const levels = Array.from(nodesByLevel.keys()).sort((a, b) => a - b);
-    for (const level of levels) {
-      for (const node of nodesByLevel.get(level)) {
-        yield node;
-      }
-    }
-  }
-  getNodesByLevel() {
-    if (this.dirty) {
-      this.compute();
-    }
-    const result = [];
-    for (const node of this.graph.nodes()) {
-      const level = this.levelMap?.get(node.props.id);
-      if (level !== void 0) {
-        if (!result[level]) {
-          result[level] = [];
-        }
-        result[level].push(node);
-      }
-    }
-    return result;
-  }
-  invalidate() {
-    this.dirty = true;
-  }
-  hasCycle() {
-    try {
-      if (this.dirty) {
-        this.compute();
-      }
-      return false;
-    } catch (e) {
-      return true;
-    }
-  }
-};
-function createTopoSort(graph, priorTopo) {
-  return new TopoSort(graph, priorTopo);
-}
-export {
-  Graph,
-  GraphEdge,
-  GraphNode,
-  TopoSort,
-  createTopoSort
-};