@bpmnkit/core 0.0.27 → 0.1.0

package/dist/layout/annotations.js

@@ -0,0 +1,251 @@
+const ANN_WIDTH = 200; // fixed annotation width
+const FONT_CHAR_WIDTH = 6.4; // approximate avg char width @ 12px Arial
+const FONT_LINE_HEIGHT = 14.4; // line-height @ 12px
+const PADDING_X = 18; // 9px each side
+const PADDING_Y = 14; // top + bottom
+const ANN_GAP = 20; // min gap between two annotations
+const ELEMENT_GAP = 30; // min gap between annotation and a non-annotation shape
+const PREFERRED_OFFSET = 50; // preferred gap to associated element
+const MIN_HEIGHT = 30;
+const HORIZONTAL_SHIFTS = [0, 60, -60, 120, -120, 180, -180, 240, -240];
+function computeHeight(text, width) {
+    if (!text || !text.trim())
+        return MIN_HEIGHT;
+    const inner = Math.max(40, width - PADDING_X);
+    const cpl = Math.max(1, Math.floor(inner / FONT_CHAR_WIDTH));
+    let totalLines = 0;
+    for (const para of text.split(/\r?\n/)) {
+        const words = para.split(/\s+/).filter(Boolean);
+        if (words.length === 0) {
+            totalLines += 1;
+            continue;
+        }
+        let lineLen = 0;
+        let lines = 1;
+        for (const w of words) {
+            let len = w.length;
+            // Hard-break very long words
+            while (len > cpl) {
+                if (lineLen > 0) {
+                    lines += 1;
+                    lineLen = 0;
+                }
+                lines += 1;
+                len -= cpl;
+            }
+            if (lineLen === 0)
+                lineLen = len;
+            else if (lineLen + 1 + len <= cpl)
+                lineLen += 1 + len;
+            else {
+                lines += 1;
+                lineLen = len;
+            }
+        }
+        totalLines += lines;
+    }
+    return Math.max(MIN_HEIGHT, Math.ceil(totalLines * FONT_LINE_HEIGHT + PADDING_Y));
+}
+function center(b) {
+    return { cx: b.x + b.width / 2, cy: b.y + b.height / 2 };
+}
+function clampX(x, b) {
+    return Math.max(b.x, Math.min(x, b.x + b.width));
+}
+function clampY(y, b) {
+    return Math.max(b.y, Math.min(y, b.y + b.height));
+}
+/** Modal (most-common, 20px-bucketed) center-Y of large (task-sized) nodes. */
+function computeMainFlowY(layoutNodes) {
+    const cys = layoutNodes
+        .filter((n) => n.bounds.height >= 60)
+        .map((n) => n.bounds.y + n.bounds.height / 2);
+    if (cys.length === 0)
+        return 370;
+    const buckets = new Map();
+    for (const cy of cys) {
+        const k = Math.round(cy / 20) * 20;
+        buckets.set(k, (buckets.get(k) ?? 0) + 1);
+    }
+    const sortedKeys = [...buckets.keys()].sort((a, b) => a - b);
+    let bestKey = sortedKeys[0];
+    let bestCount = -1;
+    for (const k of sortedKeys) {
+        const count = buckets.get(k);
+        if (count > bestCount) {
+            bestCount = count;
+            bestKey = k;
+        }
+    }
+    return bestKey;
+}
+/** Elements at or above the main flow keep their annotation "above"; elements clearly below get "below". */
+function naturalSide(elemBounds, mainFlowY) {
+    const cy = elemBounds.y + elemBounds.height / 2;
+    return cy > mainFlowY + 60 ? "below" : "above";
+}
+function overlapsPadded(a, others, padding) {
+    for (const b of others) {
+        if (a.x - padding < b.x + b.width &&
+            a.x + a.width + padding > b.x &&
+            a.y - padding < b.y + b.height &&
+            a.y + a.height + padding > b.y)
+            return true;
+    }
+    return false;
+}
+/**
+ * Sizes and packs text annotations around their linked elements without
+ * overlapping each other or any other layout node (incl. node labels).
+ * Returns final Bounds per annotation id; annotations with no resolvable
+ * association target (no association at all, or the linked element isn't
+ * in `layoutNodes`) still get an entry — they're placed at a fixed fallback
+ * origin and pushed clear of everything else already placed, mirroring the
+ * pre-port fallback in auto-layout.ts's computeAnnotationLocalBounds.
+ */
+export function packAnnotations(process, layoutNodes) {
+    const result = new Map();
+    if (process.textAnnotations.length === 0)
+        return result;
+    const annotationIds = new Set(process.textAnnotations.map((a) => a.id));
+    const elementForAnnotation = new Map();
+    for (const assoc of process.associations) {
+        if (annotationIds.has(assoc.targetRef))
+            elementForAnnotation.set(assoc.targetRef, assoc.sourceRef);
+        else if (annotationIds.has(assoc.sourceRef))
+            elementForAnnotation.set(assoc.sourceRef, assoc.targetRef);
+    }
+    const nodeById = new Map(layoutNodes.map((n) => [n.id, n]));
+    const mainFlowY = computeMainFlowY(layoutNodes);
+    const items = [];
+    const unlinked = [];
+    for (const ann of process.textAnnotations) {
+        const linkedId = elementForAnnotation.get(ann.id);
+        const linked = linkedId ? nodeById.get(linkedId) : undefined;
+        const width = ANN_WIDTH;
+        const height = computeHeight(ann.text ?? "", width);
+        if (!linked) {
+            unlinked.push({ id: ann.id, width, height });
+            continue;
+        }
+        const side = naturalSide(linked.bounds, mainFlowY);
+        const lc = center(linked.bounds);
+        items.push({
+            id: ann.id,
+            bounds: { x: Math.round(lc.cx - width / 2), y: 0, width, height },
+            side,
+            linked,
+        });
+    }
+    const obstacles = [];
+    for (const n of layoutNodes) {
+        obstacles.push(n.bounds);
+        if (n.labelBounds)
+            obstacles.push(n.labelBounds);
+    }
+    function packSide(side) {
+        const list = items
+            .filter((it) => it.side === side)
+            .sort((a, b) => center(a.linked.bounds).cx - center(b.linked.bounds).cx);
+        const placed = [];
+        for (const item of list) {
+            const linked = item.linked;
+            const lc = center(linked.bounds);
+            const naturalX = Math.round(lc.cx - item.bounds.width / 2);
+            const naturalY = side === "above"
+                ? linked.bounds.y - PREFERRED_OFFSET - item.bounds.height
+                : linked.bounds.y + linked.bounds.height + PREFERRED_OFFSET;
+            let best = { x: naturalX, y: naturalY, cost: Number.POSITIVE_INFINITY };
+            for (const dx of HORIZONTAL_SHIFTS) {
+                const candidateX = naturalX + dx;
+                const ax1 = candidateX;
+                const ax2 = candidateX + item.bounds.width;
+                const intervals = [];
+                for (const other of placed) {
+                    const ox1 = other.bounds.x;
+                    const ox2 = ox1 + other.bounds.width;
+                    if (ax2 + ANN_GAP <= ox1 || ox2 + ANN_GAP <= ax1)
+                        continue;
+                    intervals.push({
+                        top: other.bounds.y - ANN_GAP,
+                        bottom: other.bounds.y + other.bounds.height + ANN_GAP,
+                    });
+                }
+                for (const sh of obstacles) {
+                    const sx1 = sh.x;
+                    const sx2 = sx1 + sh.width;
+                    if (ax2 + ELEMENT_GAP <= sx1 || sx2 + ELEMENT_GAP <= ax1)
+                        continue;
+                    intervals.push({ top: sh.y - ELEMENT_GAP, bottom: sh.y + sh.height + ELEMENT_GAP });
+                }
+                let y = naturalY;
+                let changed = true;
+                while (changed) {
+                    changed = false;
+                    for (const iv of intervals) {
+                        if (y + item.bounds.height > iv.top && y < iv.bottom) {
+                            y = side === "above" ? iv.top - item.bounds.height : iv.bottom;
+                            changed = true;
+                        }
+                    }
+                }
+                const cost = Math.hypot(candidateX - naturalX, y - naturalY);
+                if (cost < best.cost)
+                    best = { x: candidateX, y, cost };
+            }
+            item.bounds.x = Math.round(best.x);
+            item.bounds.y = Math.round(best.y);
+            placed.push(item);
+        }
+    }
+    packSide("above");
+    packSide("below");
+    for (const item of items)
+        result.set(item.id, item.bounds);
+    // Fallback placement for annotations with no resolvable linked element:
+    // start at a fixed origin and push straight down until clear of every
+    // node/label obstacle and every already-placed annotation (linked or
+    // unlinked), so they never overlap anything.
+    const annObstacles = items.map((it) => it.bounds);
+    for (const u of unlinked) {
+        const bounds = { x: 0, y: 0, width: u.width, height: u.height };
+        while (overlapsPadded(bounds, obstacles, ELEMENT_GAP) ||
+            overlapsPadded(bounds, annObstacles, ANN_GAP)) {
+            bounds.y += u.height + ANN_GAP;
+        }
+        annObstacles.push(bounds);
+        result.set(u.id, bounds);
+    }
+    return result;
+}
+/**
+ * Edge-to-edge, clamped association waypoints between a linked element and
+ * its annotation. Port of `chooseWaypoints` (tmp/01-annotation-layouting.cjs:365-389).
+ */
+export function associationWaypoints(elementBounds, annotationBounds) {
+    const ec = center(elementBounds);
+    const ac = center(annotationBounds);
+    if (annotationBounds.y + annotationBounds.height <= elementBounds.y) {
+        return {
+            pElem: { x: clampX(ac.cx, elementBounds), y: elementBounds.y },
+            pAnn: { x: clampX(ec.cx, annotationBounds), y: annotationBounds.y + annotationBounds.height },
+        };
+    }
+    if (annotationBounds.y >= elementBounds.y + elementBounds.height) {
+        return {
+            pElem: { x: clampX(ac.cx, elementBounds), y: elementBounds.y + elementBounds.height },
+            pAnn: { x: clampX(ec.cx, annotationBounds), y: annotationBounds.y },
+        };
+    }
+    if (annotationBounds.x >= elementBounds.x + elementBounds.width) {
+        return {
+            pElem: { x: elementBounds.x + elementBounds.width, y: clampY(ac.cy, elementBounds) },
+            pAnn: { x: annotationBounds.x, y: clampY(ec.cy, annotationBounds) },
+        };
+    }
+    return {
+        pElem: { x: elementBounds.x, y: clampY(ac.cy, elementBounds) },
+        pAnn: { x: annotationBounds.x + annotationBounds.width, y: clampY(ec.cy, annotationBounds) },
+    };
+}
+//# sourceMappingURL=annotations.js.map

package/dist/layout/grid/edge-labels.d.ts

@@ -0,0 +1,8 @@
+import type { LayoutEdge, LayoutNode } from "../types.js";
+/**
+ * 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.
+ */
+export declare function placeEdgeLabels(edges: LayoutEdge[], nodeMap: Map<string, LayoutNode>): void;
+//# sourceMappingURL=edge-labels.d.ts.map

package/dist/layout/grid/edge-labels.js

@@ -0,0 +1,126 @@
+import { LABEL_CHAR_WIDTH, LABEL_HEIGHT, LABEL_MIN_WIDTH, LABEL_VERTICAL_OFFSET } from "../types.js";
+/** 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.
+ */
+export 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=edge-labels.js.map

package/dist/layout/grid/flow-graph.d.ts

@@ -0,0 +1,25 @@
+import type { BpmnBoundaryEvent, BpmnFlowElement, BpmnSequenceFlow } from "../../bpmn/bpmn-model.js";
+/** Resolved adjacency for one nesting level of a process. */
+export interface FlowGraph {
+    /** Grid-placeable elements — boundary events are excluded (they ride on their host). */
+    elements: BpmnFlowElement[];
+    byId: Map<string, BpmnFlowElement>;
+    outgoing: Map<string, BpmnSequenceFlow[]>;
+    incoming: Map<string, BpmnSequenceFlow[]>;
+    /** hostId → boundary events attached to it, in document order. */
+    attachers: Map<string, BpmnBoundaryEvent[]>;
+}
+/** bpmn:Task subtypes — used for the "right-align before a task-only fan-out" rule. */
+export declare function isTaskLike(type: string): boolean;
+export declare function buildFlowGraph(flowNodes: BpmnFlowElement[], sequenceFlows: BpmnSequenceFlow[]): FlowGraph;
+/**
+ * True iff the element has a "real" predecessor — an incoming flow that is
+ * neither a self-loop nor sourced from a boundary event / its own attacher.
+ * Elements without one become traversal starting points.
+ */
+export declare function hasOtherIncoming(el: BpmnFlowElement, graph: FlowGraph): boolean;
+/** True iff el is a join (>1 incoming) with at least one not-yet-visited feeder. */
+export declare function isFutureIncoming(el: BpmnFlowElement, visited: Set<string>, graph: FlowGraph): boolean;
+/** True iff some unvisited feeder of el is reachable downstream FROM el (a cycle). */
+export declare function formsLoop(el: BpmnFlowElement, visited: Set<string>, graph: FlowGraph): boolean;
+//# sourceMappingURL=flow-graph.d.ts.map

package/dist/layout/grid/flow-graph.js

@@ -0,0 +1,99 @@
+const TASK_TYPES = new Set([
+    "task",
+    "userTask",
+    "serviceTask",
+    "scriptTask",
+    "sendTask",
+    "receiveTask",
+    "businessRuleTask",
+    "manualTask",
+]);
+/** bpmn:Task subtypes — used for the "right-align before a task-only fan-out" rule. */
+export function isTaskLike(type) {
+    return TASK_TYPES.has(type);
+}
+export function buildFlowGraph(flowNodes, sequenceFlows) {
+    const byId = new Map();
+    for (const n of flowNodes)
+        byId.set(n.id, n);
+    const outgoing = new Map();
+    const incoming = new Map();
+    for (const f of sequenceFlows) {
+        if (!outgoing.has(f.sourceRef))
+            outgoing.set(f.sourceRef, []);
+        outgoing.get(f.sourceRef)?.push(f);
+        if (!incoming.has(f.targetRef))
+            incoming.set(f.targetRef, []);
+        incoming.get(f.targetRef)?.push(f);
+    }
+    const attachers = new Map();
+    const elements = [];
+    for (const n of flowNodes) {
+        if (n.type === "boundaryEvent") {
+            const be = n;
+            if (!attachers.has(be.attachedToRef))
+                attachers.set(be.attachedToRef, []);
+            attachers.get(be.attachedToRef)?.push(be);
+        }
+        else {
+            elements.push(n);
+        }
+    }
+    return { elements, byId, outgoing, incoming, attachers };
+}
+function isBoundaryAttachedTo(source, elId) {
+    return source?.type === "boundaryEvent" && source.attachedToRef === elId;
+}
+/**
+ * True iff the element has a "real" predecessor — an incoming flow that is
+ * neither a self-loop nor sourced from a boundary event / its own attacher.
+ * Elements without one become traversal starting points.
+ */
+export function hasOtherIncoming(el, graph) {
+    const flows = graph.incoming.get(el.id) ?? [];
+    for (const f of flows) {
+        if (f.sourceRef === el.id)
+            continue;
+        const source = graph.byId.get(f.sourceRef);
+        if (source?.type !== "boundaryEvent")
+            return true;
+        if (!isBoundaryAttachedTo(source, el.id))
+            return true;
+    }
+    return false;
+}
+/** True iff el is a join (>1 incoming) with at least one not-yet-visited feeder. */
+export function isFutureIncoming(el, visited, graph) {
+    const flows = graph.incoming.get(el.id) ?? [];
+    if (flows.length <= 1)
+        return false;
+    return flows.some((f) => !visited.has(f.sourceRef));
+}
+/** True iff some unvisited feeder of el is reachable downstream FROM el (a cycle). */
+export function formsLoop(el, visited, graph) {
+    const unvisitedFeeders = (graph.incoming.get(el.id) ?? [])
+        .map((f) => f.sourceRef)
+        .filter((id) => !visited.has(id));
+    for (const feeder of unvisitedFeeders) {
+        if (isReachable(el.id, feeder, graph))
+            return true;
+    }
+    return false;
+}
+function isReachable(fromId, targetId, graph) {
+    const seen = new Set();
+    const stack = [fromId];
+    while (stack.length > 0) {
+        const id = stack.pop();
+        if (id === undefined || seen.has(id))
+            continue;
+        seen.add(id);
+        for (const f of graph.outgoing.get(id) ?? []) {
+            if (f.targetRef === targetId)
+                return true;
+            stack.push(f.targetRef);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=flow-graph.js.map

package/dist/layout/grid/grid-engine.d.ts

@@ -0,0 +1,4 @@
+import type { BpmnFlowElement, BpmnSequenceFlow } from "../../bpmn/bpmn-model.js";
+import type { LayoutResult } from "../types.js";
+export declare function gridLayoutFlowNodes(flowNodes: BpmnFlowElement[], sequenceFlows: BpmnSequenceFlow[]): LayoutResult;
+//# sourceMappingURL=grid-engine.d.ts.map