@bpmnkit/core 0.0.8

package/dist/layout/routing.js

@@ -0,0 +1,439 @@
+import { LABEL_CHAR_WIDTH, LABEL_HEIGHT, LABEL_MIN_WIDTH, LABEL_VERTICAL_OFFSET } from "./types.js";
+const GATEWAY_TYPES = new Set([
+    "exclusiveGateway",
+    "parallelGateway",
+    "inclusiveGateway",
+    "eventBasedGateway",
+]);
+/**
+ * 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).
+ */
+export function resolveTargetPort(source, target, joinGateways) {
+    if (!GATEWAY_TYPES.has(target.type)) {
+        return "left";
+    }
+    // Split/starting gateways always receive from left
+    if (!joinGateways.has(target.id)) {
+        return "left";
+    }
+    // Join/closing gateways: connect based on relative position
+    const srcCy = source.bounds.y + source.bounds.height / 2;
+    const tgtCy = target.bounds.y + target.bounds.height / 2;
+    if (Math.abs(srcCy - tgtCy) <= 1) {
+        return "left";
+    }
+    return srcCy < tgtCy ? "top" : "bottom";
+}
+/**
+ * Assign source ports for outgoing edges of a gateway.
+ * - Single output: right port.
+ * - Odd count: middle (by target y) → right, upper half → top, lower half → bottom.
+ * - Even count: upper half → top, lower half → bottom, no right port.
+ */
+export function assignGatewayPorts(outgoingFlows, nodeMap) {
+    const portMap = new Map();
+    const count = outgoingFlows.length;
+    if (count === 0)
+        return portMap;
+    if (count === 1) {
+        const first = outgoingFlows[0];
+        if (first)
+            portMap.set(first.id, "right");
+        return portMap;
+    }
+    // Sort flows by target's center-y (ascending = topmost first)
+    const sorted = [...outgoingFlows].sort((a, b) => {
+        const targetA = nodeMap.get(a.targetRef);
+        const targetB = nodeMap.get(b.targetRef);
+        const yA = targetA ? targetA.bounds.y + targetA.bounds.height / 2 : 0;
+        const yB = targetB ? targetB.bounds.y + targetB.bounds.height / 2 : 0;
+        return yA - yB;
+    });
+    if (count % 2 === 1) {
+        const midIndex = Math.floor(count / 2);
+        for (let i = 0; i < sorted.length; i++) {
+            const flow = sorted[i];
+            if (!flow)
+                continue;
+            if (i < midIndex) {
+                portMap.set(flow.id, "top");
+            }
+            else if (i === midIndex) {
+                portMap.set(flow.id, "right");
+            }
+            else {
+                portMap.set(flow.id, "bottom");
+            }
+        }
+    }
+    else {
+        const midIndex = count / 2;
+        for (let i = 0; i < sorted.length; i++) {
+            const flow = sorted[i];
+            if (!flow)
+                continue;
+            portMap.set(flow.id, i < midIndex ? "top" : "bottom");
+        }
+    }
+    return portMap;
+}
+/**
+ * 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 function routeEdges(sequenceFlows, nodeMap, backEdges) {
+    const backEdgeIds = new Set(backEdges.map((be) => be.flowId));
+    // Group forward flows by source for gateway port assignment
+    const forwardFlowsBySource = new Map();
+    const forwardIncomingCount = new Map();
+    for (const flow of sequenceFlows) {
+        if (backEdgeIds.has(flow.id))
+            continue;
+        let bucket = forwardFlowsBySource.get(flow.sourceRef);
+        if (!bucket) {
+            bucket = [];
+            forwardFlowsBySource.set(flow.sourceRef, bucket);
+        }
+        bucket.push(flow);
+        forwardIncomingCount.set(flow.targetRef, (forwardIncomingCount.get(flow.targetRef) ?? 0) + 1);
+    }
+    // Identify join gateways (gateways with multiple incoming forward edges)
+    const joinGateways = new Set();
+    for (const [targetId, count] of forwardIncomingCount) {
+        if (count >= 2) {
+            const node = nodeMap.get(targetId);
+            if (node && GATEWAY_TYPES.has(node.type)) {
+                joinGateways.add(targetId);
+            }
+        }
+    }
+    // Assign ports for gateway sources
+    const portAssignments = new Map();
+    for (const [sourceId, flows] of forwardFlowsBySource) {
+        const source = nodeMap.get(sourceId);
+        if (!source || !GATEWAY_TYPES.has(source.type))
+            continue;
+        const ports = assignGatewayPorts(flows, nodeMap);
+        for (const [flowId, port] of ports) {
+            portAssignments.set(flowId, port);
+        }
+    }
+    const edges = [];
+    for (const flow of sequenceFlows) {
+        const source = nodeMap.get(flow.sourceRef);
+        const target = nodeMap.get(flow.targetRef);
+        if (!source || !target)
+            continue;
+        const isBackEdge = backEdgeIds.has(flow.id);
+        let waypoints;
+        if (isBackEdge) {
+            waypoints = routeBackEdge(source, target, nodeMap);
+        }
+        else {
+            const port = portAssignments.get(flow.id);
+            waypoints = port
+                ? routeFromPort(source, target, port, joinGateways)
+                : routeForwardEdge(source, target, joinGateways);
+        }
+        edges.push({
+            id: flow.id,
+            sourceRef: flow.sourceRef,
+            targetRef: flow.targetRef,
+            waypoints,
+            label: flow.name,
+            labelBounds: undefined,
+        });
+    }
+    // Collision-aware label placement
+    placeEdgeLabels(edges, nodeMap);
+    return edges;
+}
+/** Route a forward edge with orthogonal segments, preferring L-shaped over Z-shaped. */
+function routeForwardEdge(source, target, joinGateways) {
+    const targetPort = resolveTargetPort(source, target, joinGateways);
+    if (targetPort === "top" || targetPort === "bottom") {
+        const sourceRight = source.bounds.x + source.bounds.width;
+        const sourceCenterY = source.bounds.y + source.bounds.height / 2;
+        const tgtX = target.bounds.x + target.bounds.width / 2;
+        const tgtY = targetPort === "top" ? target.bounds.y : target.bounds.y + target.bounds.height;
+        return [
+            { x: sourceRight, y: sourceCenterY },
+            { x: tgtX, y: sourceCenterY },
+            { x: tgtX, y: tgtY },
+        ];
+    }
+    const sourceRight = source.bounds.x + source.bounds.width;
+    const sourceCenterY = source.bounds.y + source.bounds.height / 2;
+    const targetLeft = target.bounds.x;
+    const targetCenterY = target.bounds.y + target.bounds.height / 2;
+    // Same vertical position: straight horizontal line
+    if (Math.abs(sourceCenterY - targetCenterY) < 1) {
+        return [
+            { x: sourceRight, y: sourceCenterY },
+            { x: targetLeft, y: targetCenterY },
+        ];
+    }
+    // Different vertical positions: prefer L-shaped routing
+    // L-shape option 1: horizontal to target's X, then vertical down/up
+    // L-shape option 2: vertical to target's Y, then horizontal to target
+    // For left-to-right flow, option 1 (horizontal first, then vertical into target) is cleaner
+    return [
+        { x: sourceRight, y: sourceCenterY },
+        { x: targetLeft, y: sourceCenterY },
+        { x: targetLeft, y: targetCenterY },
+    ];
+}
+/** Count the number of direction changes (bends) in a waypoint sequence. */
+function countBends(waypoints) {
+    let bends = 0;
+    for (let i = 1; i < waypoints.length - 1; i++) {
+        const prev = waypoints[i - 1];
+        const curr = waypoints[i];
+        const next = waypoints[i + 1];
+        if (!prev || !curr || !next)
+            continue;
+        const dx1 = curr.x - prev.x;
+        const dy1 = curr.y - prev.y;
+        const dx2 = next.x - curr.x;
+        const dy2 = next.y - curr.y;
+        // Direction changes when we go from horizontal to vertical or vice versa
+        if ((Math.abs(dx1) > 0.1 && Math.abs(dy2) > 0.1) ||
+            (Math.abs(dy1) > 0.1 && Math.abs(dx2) > 0.1)) {
+            bends++;
+        }
+    }
+    return bends;
+}
+/** Route a forward edge from a specific port side on the source node, choosing minimum bends. */
+function routeFromPort(source, target, port, joinGateways) {
+    if (port === "right") {
+        return routeForwardEdge(source, target, joinGateways);
+    }
+    // Generate candidate routes: assigned port route + right-port alternative
+    const portRoute = routeFromPortDirect(source, target, port, joinGateways);
+    const rightRoute = routeForwardEdge(source, target, joinGateways);
+    const portBends = countBends(portRoute);
+    const rightBends = countBends(rightRoute);
+    // Prefer the assigned port route unless right route has strictly fewer bends
+    return rightBends < portBends ? rightRoute : portRoute;
+}
+/** Route directly from top/bottom port, preferring L-shaped path. */
+function routeFromPortDirect(source, target, port, joinGateways) {
+    const targetPort = resolveTargetPort(source, target, joinGateways);
+    const srcX = source.bounds.x + source.bounds.width / 2;
+    const srcY = port === "top" ? source.bounds.y : source.bounds.y + source.bounds.height;
+    if (targetPort === "top" || targetPort === "bottom") {
+        const tgtX = target.bounds.x + target.bounds.width / 2;
+        const tgtY = targetPort === "top" ? target.bounds.y : target.bounds.y + target.bounds.height;
+        if (Math.abs(srcX - tgtX) < 1) {
+            return [
+                { x: srcX, y: srcY },
+                { x: tgtX, y: tgtY },
+            ];
+        }
+        // L-shape: vertical to target Y, then horizontal to target X
+        return [
+            { x: srcX, y: srcY },
+            { x: srcX, y: tgtY },
+            { x: tgtX, y: tgtY },
+        ];
+    }
+    const targetLeft = target.bounds.x;
+    const targetCenterY = target.bounds.y + target.bounds.height / 2;
+    // Same vertical position as target: straight horizontal
+    if (Math.abs(srcY - targetCenterY) < 1) {
+        return [
+            { x: srcX, y: srcY },
+            { x: targetLeft, y: targetCenterY },
+        ];
+    }
+    // L-shape: vertical to target's center-Y, then horizontal to target
+    return [
+        { x: srcX, y: srcY },
+        { x: srcX, y: targetCenterY },
+        { x: targetLeft, y: targetCenterY },
+    ];
+}
+/**
+ * Route a back-edge (loop) above or below all nodes, choosing the shorter path.
+ */
+function routeBackEdge(source, target, nodeMap) {
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const node of nodeMap.values()) {
+        const top = node.bounds.y - (node.labelBounds ? node.labelBounds.height + 8 : 0);
+        if (top < minY)
+            minY = top;
+        const bottom = node.bounds.y + node.bounds.height;
+        if (bottom > maxY)
+            maxY = bottom;
+    }
+    const sourceRight = source.bounds.x + source.bounds.width;
+    const sourceCenterY = source.bounds.y + source.bounds.height / 2;
+    const targetLeft = target.bounds.x;
+    const targetCenterY = target.bounds.y + target.bounds.height / 2;
+    // Route above
+    const routeAboveY = minY - 30;
+    const aboveRoute = [
+        { x: sourceRight, y: sourceCenterY },
+        { x: sourceRight + 20, y: sourceCenterY },
+        { x: sourceRight + 20, y: routeAboveY },
+        { x: targetLeft - 20, y: routeAboveY },
+        { x: targetLeft - 20, y: targetCenterY },
+        { x: targetLeft, y: targetCenterY },
+    ];
+    // Route below
+    const routeBelowY = maxY + 30;
+    const belowRoute = [
+        { x: sourceRight, y: sourceCenterY },
+        { x: sourceRight + 20, y: sourceCenterY },
+        { x: sourceRight + 20, y: routeBelowY },
+        { x: targetLeft - 20, y: routeBelowY },
+        { x: targetLeft - 20, y: targetCenterY },
+        { x: targetLeft, y: targetCenterY },
+    ];
+    // Compare total path length and pick shorter
+    const aboveLen = pathLength(aboveRoute);
+    const belowLen = pathLength(belowRoute);
+    return belowLen < aboveLen ? belowRoute : aboveRoute;
+}
+function pathLength(waypoints) {
+    let len = 0;
+    for (let i = 1; i < waypoints.length; i++) {
+        const a = waypoints[i - 1];
+        const b = waypoints[i];
+        if (!a || !b)
+            continue;
+        len += Math.abs(b.x - a.x) + Math.abs(b.y - a.y);
+    }
+    return len;
+}
+/** Collision tolerance in pixels — small overlap allowed for rounding. */
+const LABEL_COLLISION_TOLERANCE = 2;
+/** Number of slide steps along a segment when searching for clear space. */
+const LABEL_SLIDE_STEPS = 10;
+function boundsOverlap(a, b) {
+    return !(a.x + a.width + LABEL_COLLISION_TOLERANCE <= b.x ||
+        b.x + b.width + LABEL_COLLISION_TOLERANCE <= a.x ||
+        a.y + a.height + LABEL_COLLISION_TOLERANCE <= b.y ||
+        b.y + b.height + LABEL_COLLISION_TOLERANCE <= a.y);
+}
+/**
+ * Collision-aware edge label placement.
+ * For each labeled edge, generates candidate positions on the longest segment
+ * and picks the first one that doesn't overlap nodes or already-placed labels.
+ */
+function placeEdgeLabels(edges, nodeMap) {
+    const occupied = [];
+    // Collect all node bounds as obstacles
+    for (const node of nodeMap.values()) {
+        occupied.push(node.bounds);
+        if (node.labelBounds)
+            occupied.push(node.labelBounds);
+    }
+    for (const edge of edges) {
+        if (!edge.label)
+            continue;
+        const labelWidth = Math.max(edge.label.length * LABEL_CHAR_WIDTH, LABEL_MIN_WIDTH);
+        const labelHeight = LABEL_HEIGHT;
+        // Find the longest segment
+        const { segStart, segEnd } = findLongestSegment(edge.waypoints);
+        // Generate candidate positions along the segment
+        const candidates = generateLabelCandidates(segStart, segEnd, labelWidth, labelHeight);
+        // Pick the first non-overlapping candidate
+        let placed = false;
+        for (const candidate of candidates) {
+            if (!occupied.some((ob) => boundsOverlap(candidate, ob))) {
+                edge.labelBounds = candidate;
+                occupied.push(candidate);
+                placed = true;
+                break;
+            }
+        }
+        // Fallback: slide along segment to find clear space
+        if (!placed) {
+            const fallback = slideLabelAlongSegment(segStart, segEnd, labelWidth, labelHeight, occupied);
+            if (fallback) {
+                edge.labelBounds = fallback;
+                occupied.push(fallback);
+            }
+            // If no clear position exists, leave labelBounds undefined (text preserved in edge.label)
+        }
+    }
+}
+function findLongestSegment(waypoints) {
+    let bestLen = 0;
+    let bestStart = waypoints[0] ?? { x: 0, y: 0 };
+    let bestEnd = waypoints[1] ?? waypoints[0] ?? { x: 0, y: 0 };
+    for (let i = 1; i < waypoints.length; i++) {
+        const a = waypoints[i - 1];
+        const b = waypoints[i];
+        if (!a || !b)
+            continue;
+        const len = Math.abs(b.x - a.x) + Math.abs(b.y - a.y);
+        if (len > bestLen) {
+            bestLen = len;
+            bestStart = a;
+            bestEnd = b;
+        }
+    }
+    return { segStart: bestStart, segEnd: bestEnd };
+}
+function generateLabelCandidates(segStart, segEnd, labelWidth, labelHeight) {
+    const candidates = [];
+    // Positions along segment: 0.5, 0.25, 0.75, 0.33, 0.67
+    const fractions = [0.5, 0.25, 0.75, 0.33, 0.67];
+    // Perpendicular offsets: above, below
+    const offsets = [-LABEL_VERTICAL_OFFSET - labelHeight, LABEL_VERTICAL_OFFSET];
+    for (const f of fractions) {
+        const px = segStart.x + (segEnd.x - segStart.x) * f;
+        const py = segStart.y + (segEnd.y - segStart.y) * f;
+        for (const offset of offsets) {
+            // Determine perpendicular direction
+            const isHorizontal = Math.abs(segEnd.y - segStart.y) < 1;
+            let lx;
+            let ly;
+            if (isHorizontal) {
+                lx = px - labelWidth / 2;
+                ly = py + offset;
+            }
+            else {
+                lx = px + offset;
+                ly = py - labelHeight / 2;
+            }
+            candidates.push({ x: lx, y: ly, width: labelWidth, height: labelHeight });
+        }
+    }
+    return candidates;
+}
+function slideLabelAlongSegment(segStart, segEnd, labelWidth, labelHeight, occupied) {
+    const isHorizontal = Math.abs(segEnd.y - segStart.y) < 1;
+    for (let step = 0; step <= LABEL_SLIDE_STEPS; step++) {
+        const t = step / LABEL_SLIDE_STEPS;
+        const px = segStart.x + (segEnd.x - segStart.x) * t;
+        const py = segStart.y + (segEnd.y - segStart.y) * t;
+        const candidate = isHorizontal
+            ? {
+                x: px - labelWidth / 2,
+                y: py - labelHeight - LABEL_VERTICAL_OFFSET,
+                width: labelWidth,
+                height: labelHeight,
+            }
+            : {
+                x: px - labelWidth - LABEL_VERTICAL_OFFSET,
+                y: py - labelHeight / 2,
+                width: labelWidth,
+                height: labelHeight,
+            };
+        if (!occupied.some((ob) => boundsOverlap(candidate, ob))) {
+            return candidate;
+        }
+    }
+    // No clear position found — skip label placement rather than forcing an overlap
+    return undefined;
+}
+//# sourceMappingURL=routing.js.map

package/dist/layout/subprocess.d.ts

@@ -0,0 +1,14 @@
+import type { BpmnFlowElement } from "../bpmn/bpmn-model.js";
+import type { LayoutNode, SubProcessChildResult } from "./types.js";
+/**
+ * Check if a node type is a sub-process container.
+ */
+export declare function isSubProcess(type: string): boolean;
+/**
+ * Perform recursive layout for sub-process containers.
+ * Lays out internal elements in local coordinates, then sizes the
+ * sub-process to fit its content with padding, and translates internal
+ * elements into the parent coordinate space.
+ */
+export declare function layoutSubProcesses(layoutNodes: LayoutNode[], nodeIndex: Map<string, BpmnFlowElement>): SubProcessChildResult[];
+//# sourceMappingURL=subprocess.d.ts.map

package/dist/layout/subprocess.js

@@ -0,0 +1,77 @@
+import { layoutFlowNodes } from "./layout-engine.js";
+import { SUBPROCESS_PADDING } from "./types.js";
+/**
+ * Check if a node type is a sub-process container.
+ */
+export function isSubProcess(type) {
+    return type === "subProcess" || type === "adHocSubProcess" || type === "eventSubProcess";
+}
+/**
+ * Perform recursive layout for sub-process containers.
+ * Lays out internal elements in local coordinates, then sizes the
+ * sub-process to fit its content with padding, and translates internal
+ * elements into the parent coordinate space.
+ */
+export function layoutSubProcesses(layoutNodes, nodeIndex) {
+    const childResults = [];
+    for (const layoutNode of layoutNodes) {
+        const bpmnNode = nodeIndex.get(layoutNode.id);
+        if (!bpmnNode || !isSubProcess(bpmnNode.type))
+            continue;
+        const subProcess = bpmnNode;
+        if (!subProcess.flowElements || subProcess.flowElements.length === 0)
+            continue;
+        const childResult = layoutFlowNodes(subProcess.flowElements, subProcess.sequenceFlows ?? []);
+        if (childResult.nodes.length === 0)
+            continue;
+        // Compute bounding box of child elements
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        for (const child of childResult.nodes) {
+            minX = Math.min(minX, child.bounds.x);
+            minY = Math.min(minY, child.bounds.y);
+            maxX = Math.max(maxX, child.bounds.x + child.bounds.width);
+            maxY = Math.max(maxY, child.bounds.y + child.bounds.height);
+        }
+        const contentWidth = maxX - minX;
+        const contentHeight = maxY - minY;
+        // Size the sub-process to fit content with padding
+        const originalCenterY = layoutNode.bounds.y + layoutNode.bounds.height / 2;
+        layoutNode.bounds.width = contentWidth + SUBPROCESS_PADDING * 2;
+        layoutNode.bounds.height = contentHeight + SUBPROCESS_PADDING * 2;
+        layoutNode.isExpanded = true;
+        // Re-center vertically on the original baseline position
+        layoutNode.bounds.y = originalCenterY - layoutNode.bounds.height / 2;
+        // Translate child coordinates into parent space
+        const offsetX = layoutNode.bounds.x + SUBPROCESS_PADDING - minX;
+        const offsetY = layoutNode.bounds.y + SUBPROCESS_PADDING - minY;
+        for (const child of childResult.nodes) {
+            child.bounds.x += offsetX;
+            child.bounds.y += offsetY;
+            if (child.labelBounds) {
+                child.labelBounds.x += offsetX;
+                child.labelBounds.y += offsetY;
+            }
+        }
+        for (const edge of childResult.edges) {
+            for (const wp of edge.waypoints) {
+                wp.x += offsetX;
+                wp.y += offsetY;
+            }
+            if (edge.labelBounds) {
+                edge.labelBounds.x += offsetX;
+                edge.labelBounds.y += offsetY;
+            }
+        }
+        childResults.push({
+            parentId: layoutNode.id,
+            result: childResult,
+            parentX: layoutNode.bounds.x,
+            parentY: layoutNode.bounds.y,
+        });
+    }
+    return childResults;
+}
+//# sourceMappingURL=subprocess.js.map

package/dist/layout/types.d.ts

@@ -0,0 +1,72 @@
+import type { BpmnElementType } from "../bpmn/bpmn-model.js";
+/** Fixed element dimensions by type. */
+export declare const ELEMENT_SIZES: Record<string, {
+    width: number;
+    height: number;
+}>;
+/** Virtual grid cell dimensions for element placement. */
+export declare const GRID_CELL_WIDTH = 130;
+export declare const GRID_CELL_HEIGHT = 140;
+/** Minimum spacing between elements (derived from grid). */
+export declare const HORIZONTAL_SPACING: number;
+export declare const VERTICAL_SPACING: number;
+/** Padding inside sub-process containers. */
+export declare const SUBPROCESS_PADDING = 20;
+/** Edge-label sizing constants (used for placement & collision detection). */
+export declare const LABEL_CHAR_WIDTH = 7;
+export declare const LABEL_MIN_WIDTH = 40;
+export declare const LABEL_HEIGHT = 14;
+export declare const LABEL_VERTICAL_OFFSET = 10;
+/** Axis-aligned bounding box. */
+export interface Bounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A waypoint in an edge route. */
+export interface Waypoint {
+    x: number;
+    y: number;
+}
+/** A node in the layout graph. */
+export interface LayoutNode {
+    id: string;
+    type: BpmnElementType;
+    bounds: Bounds;
+    /** Layer (column) index assigned by Sugiyama algorithm. */
+    layer: number;
+    /** Position within the layer (row index). */
+    position: number;
+    /** Label text for the node. */
+    label?: string;
+    /** Label bounds for overlap checking. */
+    labelBounds?: Bounds;
+    /** Whether this node is an expanded sub-process container. */
+    isExpanded?: boolean;
+}
+/** A routed edge in the layout. */
+export interface LayoutEdge {
+    id: string;
+    sourceRef: string;
+    targetRef: string;
+    waypoints: Waypoint[];
+    /** Label text for the edge. */
+    label?: string;
+    /** Label bounds for overlap checking. */
+    labelBounds?: Bounds;
+}
+/** Result of laying out a sub-process's children, linked to its parent. */
+export interface SubProcessChildResult {
+    parentId: string;
+    result: LayoutResult;
+    /** Subprocess position at the time children were translated to absolute coordinates. */
+    parentX: number;
+    parentY: number;
+}
+/** Complete layout result for a process. */
+export interface LayoutResult {
+    nodes: LayoutNode[];
+    edges: LayoutEdge[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/layout/types.js

@@ -0,0 +1,37 @@
+/** Fixed element dimensions by type. */
+export const ELEMENT_SIZES = {
+    startEvent: { width: 36, height: 36 },
+    endEvent: { width: 36, height: 36 },
+    intermediateThrowEvent: { width: 36, height: 36 },
+    intermediateCatchEvent: { width: 36, height: 36 },
+    boundaryEvent: { width: 36, height: 36 },
+    serviceTask: { width: 100, height: 80 },
+    scriptTask: { width: 100, height: 80 },
+    userTask: { width: 100, height: 80 },
+    sendTask: { width: 100, height: 80 },
+    receiveTask: { width: 100, height: 80 },
+    businessRuleTask: { width: 100, height: 80 },
+    callActivity: { width: 100, height: 80 },
+    exclusiveGateway: { width: 50, height: 50 },
+    parallelGateway: { width: 50, height: 50 },
+    inclusiveGateway: { width: 50, height: 50 },
+    eventBasedGateway: { width: 50, height: 50 },
+    // Sub-processes are sized dynamically
+    subProcess: { width: 100, height: 80 },
+    adHocSubProcess: { width: 100, height: 80 },
+    eventSubProcess: { width: 100, height: 80 },
+};
+/** Virtual grid cell dimensions for element placement. */
+export const GRID_CELL_WIDTH = 130;
+export const GRID_CELL_HEIGHT = 140;
+/** Minimum spacing between elements (derived from grid). */
+export const HORIZONTAL_SPACING = GRID_CELL_WIDTH - 100; // 100 = max element width
+export const VERTICAL_SPACING = GRID_CELL_HEIGHT - 80; // 80 = max element height
+/** Padding inside sub-process containers. */
+export const SUBPROCESS_PADDING = 20;
+/** Edge-label sizing constants (used for placement & collision detection). */
+export const LABEL_CHAR_WIDTH = 7;
+export const LABEL_MIN_WIDTH = 40;
+export const LABEL_HEIGHT = 14;
+export const LABEL_VERTICAL_OFFSET = 10;
+//# sourceMappingURL=types.js.map

package/dist/types/id-generator.d.ts

@@ -0,0 +1,8 @@
+/** Generates a unique ID with the given prefix. */
+export declare function generateId(prefix: string): string;
+/**
+ * Switches to deterministic counter-based IDs and resets the counter.
+ * Call this in test `beforeEach` to get stable, predictable IDs.
+ */
+export declare function resetIdCounter(): void;
+//# sourceMappingURL=id-generator.d.ts.map

package/dist/types/id-generator.js

@@ -0,0 +1,31 @@
+const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const ID_SIZE = 8;
+function nanoId() {
+    const bytes = new Uint8Array(ID_SIZE);
+    crypto.getRandomValues(bytes);
+    let id = "";
+    for (let i = 0; i < ID_SIZE; i++) {
+        id += ALPHABET[bytes[i] % ALPHABET.length];
+    }
+    return id;
+}
+// Counter used only in deterministic test mode (activated by resetIdCounter())
+let _counter = 0;
+let _deterministic = false;
+/** Generates a unique ID with the given prefix. */
+export function generateId(prefix) {
+    if (_deterministic) {
+        _counter++;
+        return `${prefix}_${_counter.toString(36).padStart(7, "0")}`;
+    }
+    return `${prefix}_${nanoId()}`;
+}
+/**
+ * Switches to deterministic counter-based IDs and resets the counter.
+ * Call this in test `beforeEach` to get stable, predictable IDs.
+ */
+export function resetIdCounter() {
+    _counter = 0;
+    _deterministic = true;
+}
+//# sourceMappingURL=id-generator.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { XmlElement } from "./xml-element.js";
+export { generateId, resetIdCounter } from "./id-generator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export { generateId, resetIdCounter } from "./id-generator.js";
+//# sourceMappingURL=index.js.map