@bpmnkit/core 0.0.27 → 0.1.0

package/dist/layout/crossing.d.ts

@@ -1,8 +0,0 @@
-import type { DirectedGraph } from "./graph.js";
-/**
- * Minimize edge crossings using the barycenter heuristic.
- * For each layer, order nodes by the average position of their neighbors
- * in the adjacent layer. Iterates a fixed number of passes.
- */
-export declare function minimizeCrossings(layerGroups: string[][], graph: DirectedGraph, iterations?: number): string[][];
-//# sourceMappingURL=crossing.d.ts.map

package/dist/layout/crossing.js

@@ -1,60 +0,0 @@
-/**
- * Minimize edge crossings using the barycenter heuristic.
- * For each layer, order nodes by the average position of their neighbors
- * in the adjacent layer. Iterates a fixed number of passes.
- */
-export function minimizeCrossings(layerGroups, graph, iterations = 4) {
-    const result = layerGroups.map((layer) => [...layer]);
-    for (let iter = 0; iter < iterations; iter++) {
-        // Forward sweep (left to right): order by predecessor positions
-        for (let i = 1; i < result.length; i++) {
-            orderByBarycenter(result, i, graph, "predecessors");
-        }
-        // Backward sweep (right to left): order by successor positions
-        for (let i = result.length - 2; i >= 0; i--) {
-            orderByBarycenter(result, i, graph, "successors");
-        }
-    }
-    return result;
-}
-function orderByBarycenter(layers, layerIndex, graph, direction) {
-    const layer = layers[layerIndex];
-    if (!layer)
-        return;
-    const adjacentLayer = direction === "predecessors" ? layers[layerIndex - 1] : layers[layerIndex + 1];
-    if (!adjacentLayer || adjacentLayer.length === 0)
-        return;
-    // Build position index for the adjacent layer
-    const posIndex = new Map();
-    for (let i = 0; i < adjacentLayer.length; i++) {
-        const adjNode = adjacentLayer[i];
-        if (!adjNode)
-            continue;
-        posIndex.set(adjNode, i);
-    }
-    // Compute barycenter for each node in current layer
-    const barycenters = new Map();
-    for (const nodeId of layer) {
-        const neighbors = direction === "predecessors"
-            ? (graph.predecessors.get(nodeId) ?? [])
-            : (graph.successors.get(nodeId) ?? []);
-        const adjacentPositions = [];
-        for (const neighbor of neighbors) {
-            const pos = posIndex.get(neighbor);
-            if (pos !== undefined) {
-                adjacentPositions.push(pos);
-            }
-        }
-        if (adjacentPositions.length > 0) {
-            const sum = adjacentPositions.reduce((a, b) => a + b, 0);
-            barycenters.set(nodeId, sum / adjacentPositions.length);
-        }
-        else {
-            // Keep original position for nodes without connections
-            barycenters.set(nodeId, layer.indexOf(nodeId));
-        }
-    }
-    // Sort by barycenter, preserving relative order for equal values
-    layer.sort((a, b) => (barycenters.get(a) ?? 0) - (barycenters.get(b) ?? 0));
-}
-//# sourceMappingURL=crossing.js.map

package/dist/layout/graph.d.ts

@@ -1,28 +0,0 @@
-import type { BpmnFlowElement, BpmnSequenceFlow } from "../bpmn/bpmn-model.js";
-/** Adjacency list representation of a directed graph. */
-export interface DirectedGraph {
-    /** Node IDs. */
-    nodes: string[];
-    /** Adjacency: nodeId → list of successor nodeIds. */
-    successors: Map<string, string[]>;
-    /** Reverse adjacency: nodeId → list of predecessor nodeIds. */
-    predecessors: Map<string, string[]>;
-}
-/** Back-edge detected during DFS. */
-export interface BackEdge {
-    flowId: string;
-    sourceRef: string;
-    targetRef: string;
-}
-/** Build a directed graph from BPMN flow nodes and sequence flows. */
-export declare function buildGraph(flowNodes: BpmnFlowElement[], sequenceFlows: BpmnSequenceFlow[]): DirectedGraph;
-/**
- * Detect back-edges via DFS.
- * A back-edge is an edge where the target is an ancestor of the source in the DFS tree.
- */
-export declare function detectBackEdges(graph: DirectedGraph, sequenceFlows: BpmnSequenceFlow[]): BackEdge[];
-/** Reverse back-edges in the graph to make it a DAG. Returns the modified graph. */
-export declare function reverseBackEdges(graph: DirectedGraph, backEdges: BackEdge[]): DirectedGraph;
-/** Topological sort of a DAG. Throws if cycles remain. */
-export declare function topologicalSort(graph: DirectedGraph): string[];
-//# sourceMappingURL=graph.d.ts.map

package/dist/layout/graph.js

@@ -1,126 +0,0 @@
-/** Build a directed graph from BPMN flow nodes and sequence flows. */
-export function buildGraph(flowNodes, sequenceFlows) {
-    const nodes = flowNodes.map((n) => n.id);
-    const successors = new Map();
-    const predecessors = new Map();
-    for (const id of nodes) {
-        successors.set(id, []);
-        predecessors.set(id, []);
-    }
-    for (const flow of sequenceFlows) {
-        const succs = successors.get(flow.sourceRef);
-        if (succs)
-            succs.push(flow.targetRef);
-        const preds = predecessors.get(flow.targetRef);
-        if (preds)
-            preds.push(flow.sourceRef);
-    }
-    return { nodes, successors, predecessors };
-}
-/**
- * Detect back-edges via DFS.
- * A back-edge is an edge where the target is an ancestor of the source in the DFS tree.
- */
-export function detectBackEdges(graph, sequenceFlows) {
-    const WHITE = 0;
-    const GRAY = 1;
-    const BLACK = 2;
-    const color = new Map();
-    for (const id of graph.nodes) {
-        color.set(id, WHITE);
-    }
-    const backEdges = [];
-    const flowIndex = new Map();
-    for (const flow of sequenceFlows) {
-        flowIndex.set(`${flow.sourceRef}->${flow.targetRef}`, flow);
-    }
-    function dfs(nodeId) {
-        color.set(nodeId, GRAY);
-        const succs = graph.successors.get(nodeId) ?? [];
-        for (const succ of succs) {
-            const c = color.get(succ);
-            if (c === GRAY) {
-                const flow = flowIndex.get(`${nodeId}->${succ}`);
-                if (flow) {
-                    backEdges.push({
-                        flowId: flow.id,
-                        sourceRef: nodeId,
-                        targetRef: succ,
-                    });
-                }
-            }
-            else if (c === WHITE) {
-                dfs(succ);
-            }
-        }
-        color.set(nodeId, BLACK);
-    }
-    for (const id of graph.nodes) {
-        if (color.get(id) === WHITE) {
-            dfs(id);
-        }
-    }
-    return backEdges;
-}
-/** Reverse back-edges in the graph to make it a DAG. Returns the modified graph. */
-export function reverseBackEdges(graph, backEdges) {
-    const successors = new Map();
-    const predecessors = new Map();
-    for (const id of graph.nodes) {
-        successors.set(id, [...(graph.successors.get(id) ?? [])]);
-        predecessors.set(id, [...(graph.predecessors.get(id) ?? [])]);
-    }
-    for (const be of backEdges) {
-        // Remove forward direction
-        const succs = successors.get(be.sourceRef);
-        if (succs) {
-            const idx = succs.indexOf(be.targetRef);
-            if (idx >= 0)
-                succs.splice(idx, 1);
-        }
-        const preds = predecessors.get(be.targetRef);
-        if (preds) {
-            const idx = preds.indexOf(be.sourceRef);
-            if (idx >= 0)
-                preds.splice(idx, 1);
-        }
-        // Add reversed direction
-        const revSuccs = successors.get(be.targetRef);
-        if (revSuccs)
-            revSuccs.push(be.sourceRef);
-        const revPreds = predecessors.get(be.sourceRef);
-        if (revPreds)
-            revPreds.push(be.targetRef);
-    }
-    return { nodes: [...graph.nodes], successors, predecessors };
-}
-/** Topological sort of a DAG. Throws if cycles remain. */
-export function topologicalSort(graph) {
-    const inDegree = new Map();
-    for (const id of graph.nodes) {
-        inDegree.set(id, (graph.predecessors.get(id) ?? []).length);
-    }
-    const queue = [];
-    for (const [id, deg] of inDegree) {
-        if (deg === 0)
-            queue.push(id);
-    }
-    const sorted = [];
-    while (queue.length > 0) {
-        const node = queue.shift();
-        if (!node)
-            break;
-        sorted.push(node);
-        for (const succ of graph.successors.get(node) ?? []) {
-            const newDeg = (inDegree.get(succ) ?? 1) - 1;
-            inDegree.set(succ, newDeg);
-            if (newDeg === 0)
-                queue.push(succ);
-        }
-    }
-    if (sorted.length !== graph.nodes.length) {
-        throw new Error(`Layout error: graph contains cycles after back-edge reversal (sorted ${sorted.length} of ${graph.nodes.length} nodes)`);
-    }
-    return sorted;
-}
-//# sourceMappingURL=graph.js.map

package/dist/layout/layers.d.ts

@@ -1,13 +0,0 @@
-import type { DirectedGraph } from "./graph.js";
-/**
- * Assign layers using longest-path algorithm.
- * Each node gets a layer equal to the longest path from any source to it.
- * This produces a left-to-right layout where layers represent columns.
- */
-export declare function assignLayers(graph: DirectedGraph): Map<string, number>;
-/**
- * Group nodes by their assigned layer.
- * Returns an array of arrays, where index = layer number.
- */
-export declare function groupByLayer(layers: Map<string, number>): string[][];
-//# sourceMappingURL=layers.d.ts.map

package/dist/layout/layers.js

@@ -1,49 +0,0 @@
-import { topologicalSort } from "./graph.js";
-/**
- * Assign layers using longest-path algorithm.
- * Each node gets a layer equal to the longest path from any source to it.
- * This produces a left-to-right layout where layers represent columns.
- */
-export function assignLayers(graph) {
-    const sorted = topologicalSort(graph);
-    const layers = new Map();
-    // Initialize all nodes at layer 0
-    for (const id of sorted) {
-        layers.set(id, 0);
-    }
-    // Forward pass: each node's layer = max(predecessor layers) + 1
-    for (const id of sorted) {
-        const preds = graph.predecessors.get(id) ?? [];
-        if (preds.length > 0) {
-            let maxPredLayer = 0;
-            for (const pred of preds) {
-                const predLayer = layers.get(pred) ?? 0;
-                if (predLayer >= maxPredLayer) {
-                    maxPredLayer = predLayer + 1;
-                }
-            }
-            layers.set(id, maxPredLayer);
-        }
-    }
-    return layers;
-}
-/**
- * Group nodes by their assigned layer.
- * Returns an array of arrays, where index = layer number.
- */
-export function groupByLayer(layers) {
-    let maxLayer = 0;
-    for (const layer of layers.values()) {
-        if (layer > maxLayer)
-            maxLayer = layer;
-    }
-    const groups = [];
-    for (let i = 0; i <= maxLayer; i++) {
-        groups.push([]);
-    }
-    for (const [id, layer] of layers) {
-        groups[layer]?.push(id);
-    }
-    return groups;
-}
-//# sourceMappingURL=layers.js.map

package/dist/layout/routing.d.ts

@@ -1,33 +0,0 @@
-import type { BpmnSequenceFlow } from "../bpmn/bpmn-model.js";
-import type { BackEdge } from "./graph.js";
-import type { LayoutEdge, LayoutNode } from "./types.js";
-/** Port side for gateway edge connection. */
-export type PortSide = "right" | "top" | "bottom";
-/**
- * Determine which side of the target a forward edge should connect to.
- * Non-gateway targets always receive edges from the left side.
- * Split gateways (starting): incoming always from the left.
- * Join gateways (closing): incoming based on relative position (top/bottom/left).
- *
- * Uses gridRow (integer row index) when available for exact comparison;
- * falls back to pixel-Y with PORT_SAME_Y_TOLERANCE for nodes without gridRow.
- */
-export declare function resolveTargetPort(source: LayoutNode, target: LayoutNode, joinGateways: ReadonlySet<string>): "left" | "top" | "bottom";
-/**
- * Assign source ports for outgoing edges of a gateway.
- * Uses absolute direction: target above → top, below → bottom, same level → right.
- * Single output always exits from the right port.
- */
-export declare function assignGatewayPorts(outgoingFlows: BpmnSequenceFlow[], nodeMap: Map<string, LayoutNode>): Map<string, PortSide>;
-/**
- * Route edges with orthogonal (horizontal + vertical) segments.
- * Forward edges go left-to-right; back-edges route above or below.
- * Gateway sources use port-based routing (top/right/bottom).
- */
-export declare function routeEdges(sequenceFlows: BpmnSequenceFlow[], nodeMap: Map<string, LayoutNode>, backEdges: BackEdge[]): LayoutEdge[];
-/**
- * Post-process routed edges to avoid crossing through intermediate shapes.
- * For each segment that passes through a shape, adds detour waypoints around it.
- */
-export declare function resolveEdgeCrossings(edges: LayoutEdge[], nodeMap: Map<string, LayoutNode>): void;
-//# sourceMappingURL=routing.d.ts.map