@bpmn-ld/bpmn-ld 0.0.0-stage → 0.2.0

package/dist/layout/collaboration.js

@@ -0,0 +1,152 @@
+import { arrangeLanes, bandsBottom, buildLaneLayout, extendLastBand, laneBoxes, laneBoxesFromNodes, LANE_HEADER } from "./lanes.js";
+import { allFlows, allNodes } from "./model.js";
+import { measure, ORIGIN, placeScope } from "./placement.js";
+export const POOL_HEADER = LANE_HEADER;
+const POOL_MARGIN = 20;
+const POOL_GAP = 50;
+const EMPTY_POOL_HEIGHT = 60;
+const MESSAGE_CLEARANCE = 15;
+const MESSAGE_PITCH = 8;
+const pointsOf = (routes) => [...routes.values()].flat();
+const clamp = (value, low, high) => Math.min(high, Math.max(low, value));
+const centerX = (box) => box.x + box.width / 2;
+export const layoutCollaboration = (participants, messageFlows, existing) => {
+    const { fixed, obstacles, missingFlows } = existing;
+    const known = participants.map((participant) => fixed.get(participant.id)).filter((box) => box !== undefined);
+    const poolX = known.length > 0 ? Math.min(...known.map((box) => box.x)) : ORIGIN.x;
+    let cursor = Math.max(ORIGIN.y, ...known.map((box) => box.y + box.height + POOL_GAP));
+    const pooled = [];
+    const routes = new Map();
+    for (const participant of participants) {
+        const { model } = participant;
+        const fixedBox = fixed.get(participant.id);
+        const hasContent = model !== undefined && (model.nodes.length > 0 || participant.lanes !== undefined);
+        if (!hasContent) {
+            const pool = fixedBox ?? { x: poolX, y: cursor, width: 0, height: EMPTY_POOL_HEIGHT };
+            if (!fixedBox)
+                cursor += pool.height + POOL_GAP;
+            pooled.push({ participant, pool, fixedPool: fixedBox !== undefined, anchored: false, required: pool.width });
+            continue;
+        }
+        const anchored = allNodes(model).some((node) => fixed.has(node.id));
+        const left = fixedBox?.x ?? poolX;
+        const top = fixedBox?.y ?? cursor;
+        const laneLayout = participant.lanes ? buildLaneLayout(participant.lanes, model) : undefined;
+        const indent = POOL_HEADER * ((participant.unframed ? 0 : 1) + (laneLayout ? 1 + laneLayout.depth : 0)) + POOL_MARGIN;
+        const context = {
+            fixed,
+            obstacles,
+            missingFlows,
+            boxes: new Map(),
+            routes: new Map(),
+            lanes: new Map(),
+            arrange: laneLayout ? (scope, layering, layered, origin) => (scope === model ? arrangeLanes(laneLayout, scope, layering, layered, origin) : undefined) : undefined,
+        };
+        measure(model);
+        placeScope(model, { x: left + indent, y: laneLayout ? top : top + POOL_MARGIN }, context);
+        for (const [id, route] of context.routes)
+            routes.set(id, route);
+        const boxes = [...context.boxes.values()];
+        const points = pointsOf(context.routes);
+        const right = Math.max(...boxes.map((box) => box.x + box.width), ...points.map((p) => p.x), left + indent);
+        const lowest = Math.max(...boxes.map((box) => box.y + box.height), ...points.map((p) => p.y));
+        let pool;
+        if (fixedBox)
+            pool = fixedBox;
+        else {
+            const x = anchored ? Math.min(poolX, Math.min(...boxes.map((box) => box.x)) - indent) : poolX;
+            let y = top;
+            let bottom;
+            if (laneLayout && !anchored) {
+                extendLastBand(laneLayout, Math.max(...points.map((p) => p.y), ...boxes.map((box) => box.y + box.height), 0) + POOL_MARGIN / 2);
+                bottom = bandsBottom(laneLayout);
+            }
+            else {
+                if (anchored)
+                    y = Math.min(...boxes.map((box) => box.y)) - POOL_MARGIN;
+                bottom = lowest + POOL_MARGIN;
+            }
+            pool = { x, y, width: right + POOL_MARGIN - x, height: Math.max(bottom - y, EMPTY_POOL_HEIGHT) };
+            cursor = Math.max(cursor, pool.y + pool.height + POOL_GAP);
+        }
+        pooled.push({ participant, pool, fixedPool: fixedBox !== undefined, anchored, required: pool.width, context, laneLayout });
+    }
+    const width = Math.max(0, ...pooled.filter((item) => !item.participant.unframed).map((item) => item.required));
+    for (const item of pooled)
+        if (!item.fixedPool && !item.participant.unframed)
+            item.pool.width = width;
+    const shapes = [];
+    const boxes = new Map();
+    const poolOf = new Map();
+    for (const item of pooled) {
+        const { participant, pool } = item;
+        if (!participant.unframed) {
+            shapes.push({ element: participant.id, kind: "pool", box: pool });
+            boxes.set(participant.id, pool);
+            poolOf.set(participant.id, pool);
+        }
+        if (item.laneLayout) {
+            const inset = participant.unframed ? 0 : POOL_HEADER;
+            const computed = item.anchored || item.fixedPool ? laneBoxesFromNodes(item.laneLayout, pool, item.context.boxes, inset) : laneBoxes(item.laneLayout, pool, inset);
+            for (const lane of item.laneLayout.lanes) {
+                const box = fixed.get(lane.id) ?? computed.get(lane.id);
+                shapes.push({ element: lane.id, kind: "lane", box });
+                boxes.set(lane.id, box);
+            }
+        }
+        for (const [id, box] of item.context?.lanes ?? []) {
+            const placed = fixed.get(id) ?? box;
+            shapes.push({ element: id, kind: "lane", box: placed });
+            boxes.set(id, placed);
+        }
+        if (participant.model)
+            for (const node of allNodes(participant.model)) {
+                const box = item.context?.boxes.get(node.id);
+                if (!box)
+                    continue;
+                shapes.push({ element: node.id, kind: "node", box, node });
+                boxes.set(node.id, box);
+                poolOf.set(node.id, pool);
+            }
+    }
+    const edges = [];
+    for (const item of pooled)
+        if (item.participant.model)
+            for (const flow of allFlows(item.participant.model)) {
+                const route = routes.get(flow.id);
+                if (route)
+                    edges.push({ element: flow.id, source: flow.source, target: flow.target, route });
+            }
+    const poolIds = new Set(participants.filter((participant) => !participant.unframed).map((participant) => participant.id));
+    const used = new Map();
+    for (const flow of messageFlows) {
+        const source = boxes.get(flow.source);
+        const target = boxes.get(flow.target);
+        if (!source || !target)
+            continue;
+        const sourcePool = poolOf.get(flow.source);
+        const targetPool = poolOf.get(flow.target);
+        const down = sourcePool === targetPool ? centerY(source) <= centerY(target) : sourcePool.y < targetPool.y;
+        const upper = down ? sourcePool : targetPool;
+        const index = used.get(upper) ?? 0;
+        used.set(upper, index + 1);
+        const within = (box, x) => clamp(x, box.x + POOL_HEADER, box.x + box.width);
+        const sourceIsPool = poolIds.has(flow.source);
+        const targetIsPool = poolIds.has(flow.target);
+        const preferred = !sourceIsPool ? centerX(source) : !targetIsPool ? centerX(target) : centerX(source);
+        const sx = sourceIsPool ? within(source, preferred) : centerX(source);
+        const tx = targetIsPool ? within(target, sx) : centerX(target);
+        const sy = down ? source.y + source.height : source.y;
+        const ty = down ? target.y : target.y + target.height;
+        let route;
+        if (sx === tx)
+            route = [{ x: sx, y: sy }, { x: tx, y: ty }];
+        else {
+            const middle = sourcePool === targetPool ? Math.round((sy + ty) / 2) : upper.y + upper.height + MESSAGE_CLEARANCE + index * MESSAGE_PITCH;
+            route = [{ x: sx, y: sy }, { x: sx, y: middle }, { x: tx, y: middle }, { x: tx, y: ty }];
+        }
+        edges.push({ element: flow.id, source: flow.source, target: flow.target, route });
+    }
+    return { shapes, edges };
+};
+const centerY = (box) => box.y + box.height / 2;

package/dist/layout/di.d.ts

@@ -0,0 +1,15 @@
+import type { Box, Json, Placement, Point, ProcessModel, FlowNode } from "./model.ts";
+export interface PreviousIds {
+    diagram?: string;
+    plane?: string;
+    name?: unknown;
+    resolution?: unknown;
+    messageVisibleKinds: Map<string, unknown>;
+    shapes: Map<string, string>;
+    edges: Map<string, string>;
+}
+export declare const diagramProperties: (previous?: PreviousIds) => Json;
+export declare const shapeElement: (id: string, node: FlowNode, box: Box) => Json;
+export declare const containerElement: (id: string, element: string, box: Box) => Json;
+export declare const edgeElement: (id: string, element: string, source: string | undefined, target: string | undefined, route: Point[], messageVisibleKind?: unknown) => Json;
+export declare const buildDiagram: (model: ProcessModel, placement: Placement, ids: (preferred: string) => string, previous?: PreviousIds) => Json;

package/dist/layout/di.js

@@ -0,0 +1,52 @@
+import { allFlows, allNodes } from "./model.js";
+export const diagramProperties = (previous) => ({
+    ...(previous?.name === undefined ? {} : { name: previous.name }),
+    ...(previous?.resolution === undefined ? {} : { resolution: previous.resolution }),
+});
+export const shapeElement = (id, node, box) => ({
+    id,
+    type: "BPMNShape",
+    bpmnElement: node.id,
+    ...(node.collapsed === undefined ? {} : { isExpanded: !node.collapsed }),
+    bounds: { type: "Bounds", x: box.x, y: box.y, width: box.width, height: box.height },
+});
+export const containerElement = (id, element, box) => ({
+    id,
+    type: "BPMNShape",
+    bpmnElement: element,
+    isHorizontal: true,
+    bounds: { type: "Bounds", x: box.x, y: box.y, width: box.width, height: box.height },
+});
+export const edgeElement = (id, element, source, target, route, messageVisibleKind) => ({
+    id,
+    type: "BPMNEdge",
+    bpmnElement: element,
+    ...(messageVisibleKind === undefined ? {} : { messageVisibleKind }),
+    ...(source === undefined ? {} : { sourceElement: source }),
+    ...(target === undefined ? {} : { targetElement: target }),
+    waypoints: route.map((point) => ({ type: "Point", x: point.x, y: point.y })),
+});
+export const buildDiagram = (model, placement, ids, previous) => {
+    const shapeIds = new Map();
+    const planeElements = [];
+    for (const [lane, box] of placement.lanes ?? [])
+        planeElements.push(containerElement(ids(previous?.shapes.get(lane) ?? `Shape_${lane}`), lane, box));
+    for (const node of allNodes(model)) {
+        const id = ids(previous?.shapes.get(node.id) ?? `Shape_${node.id}`);
+        shapeIds.set(node.id, id);
+        planeElements.push(shapeElement(id, node, placement.boxes.get(node.id)));
+    }
+    for (const flow of allFlows(model)) {
+        const route = placement.routes.get(flow.id);
+        if (!route)
+            continue;
+        const id = ids(previous?.edges.get(flow.id) ?? `Edge_${flow.id}`);
+        planeElements.push(edgeElement(id, flow.id, flow.source && shapeIds.get(flow.source), flow.target && shapeIds.get(flow.target), route, previous?.messageVisibleKinds.get(flow.id)));
+    }
+    return {
+        id: ids(previous?.diagram ?? `Diagram_${model.id}`),
+        type: "BPMNDiagram",
+        ...diagramProperties(previous),
+        plane: { id: ids(previous?.plane ?? `Plane_${model.id}`), type: "BPMNPlane", bpmnElement: model.id, planeElements },
+    };
+};

package/dist/layout/extract.d.ts

@@ -0,0 +1,2 @@
+import type { Json, ProcessModel } from "./model.ts";
+export declare const extractProcess: (container: Json, collapsed?: ReadonlySet<string>) => ProcessModel;

package/dist/layout/extract.js

@@ -0,0 +1,99 @@
+import { extractLanes, laneHooks } from "./lanes.js";
+const EVENT_SIZE = { width: 36, height: 36 };
+const GATEWAY_SIZE = { width: 50, height: 50 };
+const ACTIVITY_SIZE = { width: 100, height: 80 };
+const DATA_OBJECT_SIZE = { width: 36, height: 50 };
+const DATA_STORE_SIZE = { width: 50, height: 50 };
+const isSubProcess = (type) => type.endsWith("SubProcess") || type === "Transaction";
+const sizeOf = (type) => {
+    if (type.endsWith("Event"))
+        return EVENT_SIZE;
+    if (type.endsWith("Gateway"))
+        return GATEWAY_SIZE;
+    if (type.endsWith("Task") || isSubProcess(type) || type === "CallActivity")
+        return ACTIVITY_SIZE;
+    return undefined;
+};
+const dataSizeOf = (type) => type === "DataObjectReference" ? DATA_OBJECT_SIZE : type === "DataStoreReference" ? DATA_STORE_SIZE : undefined;
+const idsOf = (value) => [value].flat().filter((item) => typeof item === "string");
+export const extractProcess = (container, collapsed = new Set()) => {
+    const nodes = [];
+    const flows = [];
+    const data = [];
+    const sequenceFlows = [];
+    const elements = [];
+    for (const element of container.flowElements ?? []) {
+        if (element.type === "SequenceFlow") {
+            sequenceFlows.push(element);
+            continue;
+        }
+        elements.push(element);
+        const dataSize = dataSizeOf(element.type);
+        if (dataSize) {
+            data.push({ id: element.id, type: element.type, size: { ...dataSize } });
+            continue;
+        }
+        const size = sizeOf(element.type);
+        if (!size)
+            continue;
+        const node = { id: element.id, type: element.type, size: { ...size } };
+        if (isSubProcess(element.type)) {
+            const content = extractProcess(element, collapsed);
+            node.collapsed = collapsed.has(element.id) || content.nodes.length === 0;
+            if (!node.collapsed) {
+                node.content = content;
+                const lanes = extractLanes(element);
+                if (lanes)
+                    content.lanes = laneHooks(lanes, content);
+            }
+        }
+        if (element.type === "BoundaryEvent" && typeof element.attachedToRef === "string")
+            node.attachedTo = element.attachedToRef;
+        nodes.push(node);
+    }
+    const known = new Set(nodes.map((node) => node.id));
+    for (const node of nodes)
+        if (node.attachedTo && (!known.has(node.attachedTo) || node.attachedTo === node.id))
+            delete node.attachedTo;
+    for (const node of nodes)
+        if (node.attachedTo && nodes.find((host) => host.id === node.attachedTo).attachedTo)
+            delete node.attachedTo;
+    const stubs = [];
+    for (const flow of sequenceFlows) {
+        const source = typeof flow.sourceRef === "string" && known.has(flow.sourceRef) ? flow.sourceRef : undefined;
+        const target = typeof flow.targetRef === "string" && known.has(flow.targetRef) ? flow.targetRef : undefined;
+        if (source && target)
+            flows.push({ id: flow.id, source, target });
+        else if (source || target)
+            stubs.push({ id: flow.id, source, target });
+    }
+    const dataIds = new Set(data.map((item) => item.id));
+    const associations = [];
+    for (const element of elements) {
+        if (!known.has(element.id))
+            continue;
+        for (const association of [element.dataInputAssociations ?? []].flat()) {
+            if (typeof association?.id !== "string")
+                continue;
+            const source = idsOf(association.sourceRef).find((id) => dataIds.has(id));
+            if (source)
+                associations.push({ id: association.id, source, target: element.id });
+        }
+        for (const association of [element.dataOutputAssociations ?? []].flat()) {
+            if (typeof association?.id !== "string")
+                continue;
+            const target = idsOf(association.targetRef).find((id) => dataIds.has(id));
+            if (target)
+                associations.push({ id: association.id, source: element.id, target });
+        }
+    }
+    for (const artifact of [container.artifacts ?? []].flat()) {
+        if (artifact?.type !== "Association" || typeof artifact.id !== "string")
+            continue;
+        const source = idsOf(artifact.sourceRef).find((id) => known.has(id));
+        const target = idsOf(artifact.targetRef).find((id) => known.has(id));
+        if (source && target)
+            associations.push({ id: artifact.id, source, target });
+    }
+    return { id: container.id, nodes, flows, data, stubs, associations };
+};

package/dist/layout/lanes.d.ts

@@ -0,0 +1,30 @@
+import type { Layering } from "./layering.ts";
+import type { Box, Json, LaneHooks, Point, ProcessModel } from "./model.ts";
+export declare const LANE_HEADER = 30;
+export interface LaneNode {
+    id: string;
+    refs: string[];
+    children: LaneNode[];
+    depth: number;
+    first: number;
+    last: number;
+}
+export interface Band {
+    nodes: string[];
+    top: number;
+    height: number;
+}
+export interface LaneLayout {
+    lanes: LaneNode[];
+    bands: Band[];
+    depth: number;
+}
+export declare const extractLanes: (process: Json) => LaneNode[] | undefined;
+export declare const flattenLanes: (lanes: LaneNode[]) => LaneNode[];
+export declare const buildLaneLayout: (roots: LaneNode[], model: ProcessModel) => LaneLayout;
+export declare const arrangeLanes: (layout: LaneLayout, model: ProcessModel, layering: Layering, layered: Map<string, Box>, origin: Point) => void;
+export declare const extendLastBand: (layout: LaneLayout, bottom: number) => void;
+export declare const bandsBottom: (layout: LaneLayout) => number;
+export declare const laneBoxes: (layout: LaneLayout, pool: Box, inset?: number) => Map<string, Box>;
+export declare const laneBoxesFromNodes: (layout: LaneLayout, pool: Box, boxes: Map<string, Box>, inset?: number) => Map<string, Box>;
+export declare const laneHooks: (roots: LaneNode[], model: ProcessModel) => LaneHooks;

package/dist/layout/lanes.js

@@ -0,0 +1,112 @@
+import { boundaryBox, reserveBelow, ROW_GAP } from "./placement.js";
+export const LANE_HEADER = 30;
+const LANE_PAD = 20;
+const MIN_BAND = 80;
+const list = (value) => (Array.isArray(value) ? value : value && typeof value === "object" ? [value] : []).filter((item) => item && typeof item === "object");
+const refsOf = (lane) => [lane.flowNodeRef].flat().filter((ref) => typeof ref === "string");
+const parseLanes = (laneSet, depth) => list(laneSet.lanes)
+    .filter((lane) => typeof lane.id === "string")
+    .map((lane) => ({
+    id: lane.id,
+    refs: refsOf(lane),
+    children: list(lane.childLaneSet).flatMap((child) => parseLanes(child, depth + 1)),
+    depth,
+    first: 0,
+    last: 0,
+}));
+export const extractLanes = (process) => {
+    for (const laneSet of list(process.laneSets)) {
+        const lanes = parseLanes(laneSet, 0);
+        if (lanes.length > 0)
+            return lanes;
+    }
+    return undefined;
+};
+const descendantRefs = (lane) => new Set(lane.children.flatMap((child) => [...child.refs, ...descendantRefs(child)]));
+export const flattenLanes = (lanes) => lanes.flatMap((lane) => [lane, ...flattenLanes(lane.children)]);
+export const buildLaneLayout = (roots, model) => {
+    const known = new Set(model.nodes.filter((node) => !node.attachedTo).map((node) => node.id));
+    const claimed = new Set();
+    const bands = [];
+    const claim = (refs) => {
+        const mine = refs.filter((ref) => known.has(ref) && !claimed.has(ref));
+        mine.forEach((ref) => claimed.add(ref));
+        return mine;
+    };
+    const visit = (lane) => {
+        lane.first = bands.length;
+        if (lane.children.length === 0)
+            bands.push({ nodes: claim(lane.refs), top: 0, height: 0 });
+        else {
+            const below = descendantRefs(lane);
+            const own = claim(lane.refs.filter((ref) => !below.has(ref)));
+            if (own.length > 0)
+                bands.push({ nodes: own, top: 0, height: 0 });
+            lane.children.forEach(visit);
+        }
+        lane.last = Math.max(lane.first, bands.length - 1);
+    };
+    roots.forEach(visit);
+    const rest = model.nodes.filter((node) => !node.attachedTo && !claimed.has(node.id)).map((node) => node.id);
+    if (rest.length > 0)
+        bands.push({ nodes: rest, top: 0, height: 0 });
+    const all = flattenLanes(roots);
+    return { lanes: all, bands, depth: Math.max(0, ...all.map((lane) => lane.depth)) };
+};
+export const arrangeLanes = (layout, model, layering, layered, origin) => {
+    const sizes = new Map(model.nodes.map((node) => [node.id, node.size]));
+    const slot = (id) => sizes.get(id).height + reserveBelow(model, id);
+    const stacks = (band) => layering.layers.map((layer) => {
+        const inBand = layer.filter((id) => band.nodes.includes(id));
+        return { ids: inBand, height: inBand.reduce((sum, id) => sum + slot(id), 0) + ROW_GAP * Math.max(0, inBand.length - 1) };
+    });
+    let top = origin.y;
+    for (const band of layout.bands) {
+        const columns = stacks(band);
+        band.top = top;
+        band.height = Math.max(MIN_BAND, Math.max(0, ...columns.map((column) => column.height)) + 2 * LANE_PAD);
+        for (const column of columns) {
+            let y = top + (band.height - column.height) / 2;
+            for (const id of column.ids) {
+                layered.set(id, { ...layered.get(id), y });
+                y += slot(id) + ROW_GAP;
+            }
+        }
+        top += band.height;
+    }
+    for (const node of model.nodes)
+        if (node.attachedTo)
+            layered.set(node.id, boundaryBox(model, node, layered.get(node.attachedTo)));
+};
+export const extendLastBand = (layout, bottom) => {
+    const last = layout.bands.at(-1);
+    if (last && last.top + last.height < bottom)
+        last.height = bottom - last.top;
+};
+export const bandsBottom = (layout) => {
+    const last = layout.bands.at(-1);
+    return last ? last.top + last.height : 0;
+};
+export const laneBoxes = (layout, pool, inset = LANE_HEADER) => new Map(layout.lanes.map((lane) => {
+    const top = layout.bands[lane.first].top;
+    const last = layout.bands[lane.last];
+    return [
+        lane.id,
+        { x: pool.x + inset + LANE_HEADER * lane.depth, y: top, width: pool.width - inset - LANE_HEADER * lane.depth, height: last.top + last.height - top },
+    ];
+}));
+export const laneBoxesFromNodes = (layout, pool, boxes, inset = LANE_HEADER) => new Map(layout.lanes.map((lane) => {
+    const nodes = [lane, ...flattenLanes(lane.children)].flatMap((item) => item.refs).map((ref) => boxes.get(ref)).filter((box) => box !== undefined);
+    const top = nodes.length > 0 ? Math.max(pool.y, Math.min(...nodes.map((box) => box.y)) - LANE_PAD) : pool.y;
+    const bottom = nodes.length > 0 ? Math.min(pool.y + pool.height, Math.max(...nodes.map((box) => box.y + box.height)) + LANE_PAD) : pool.y + Math.min(MIN_BAND, pool.height);
+    return [lane.id, { x: pool.x + inset + LANE_HEADER * lane.depth, y: top, width: pool.width - inset - LANE_HEADER * lane.depth, height: bottom - top }];
+}));
+export const laneHooks = (roots, model) => {
+    const layout = buildLaneLayout(roots, model);
+    return {
+        ids: layout.lanes.map((lane) => lane.id),
+        indent: LANE_HEADER * (layout.depth + 1) + LANE_PAD,
+        arrange: (layering, layered, origin) => arrangeLanes(layout, model, layering, layered, origin),
+        boxes: (frame, boxes, anchored) => (anchored ? laneBoxesFromNodes(layout, frame, boxes, 0) : laneBoxes(layout, frame, 0)),
+    };
+};

package/dist/layout/layering.d.ts

@@ -0,0 +1,7 @@
+import type { ProcessModel } from "./model.ts";
+export interface Layering {
+    layers: string[][];
+    layerOf: Map<string, number>;
+    backFlows: Set<string>;
+}
+export declare const assignLayers: (model: ProcessModel) => Layering;

package/dist/layout/layering.js

@@ -0,0 +1,53 @@
+const findBackFlows = (nodes, flows) => {
+    const outgoing = new Map();
+    for (const node of nodes)
+        outgoing.set(node.id, []);
+    for (const flow of flows)
+        outgoing.get(flow.source).push({ id: flow.id, target: flow.target });
+    const state = new Map();
+    const back = new Set();
+    const visit = (id) => {
+        state.set(id, "open");
+        for (const edge of outgoing.get(id)) {
+            const seen = state.get(edge.target);
+            if (seen === "open")
+                back.add(edge.id);
+            else if (seen === undefined)
+                visit(edge.target);
+        }
+        state.set(id, "done");
+    };
+    const incoming = new Set(flows.map((flow) => flow.target));
+    const starts = nodes.filter((node) => !incoming.has(node.id));
+    for (const node of [...starts, ...nodes])
+        if (!state.has(node.id))
+            visit(node.id);
+    return back;
+};
+export const assignLayers = (model) => {
+    const hostOf = new Map(model.nodes.map((node) => [node.id, node.attachedTo ?? node.id]));
+    const nodes = model.nodes.filter((node) => !node.attachedTo);
+    const flows = model.flows.map((flow) => ({ id: flow.id, source: hostOf.get(flow.source), target: hostOf.get(flow.target) }));
+    const backFlows = findBackFlows(nodes, flows);
+    const forward = flows.filter((flow) => !backFlows.has(flow.id));
+    const layerOf = new Map(nodes.map((node) => [node.id, 0]));
+    for (let pass = 0; pass < nodes.length; pass++) {
+        let changed = false;
+        for (const flow of forward) {
+            const wanted = layerOf.get(flow.source) + 1;
+            if (layerOf.get(flow.target) < wanted) {
+                layerOf.set(flow.target, wanted);
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    const layers = [];
+    for (const node of nodes)
+        (layers[layerOf.get(node.id)] ??= []).push(node.id);
+    for (const node of model.nodes)
+        if (node.attachedTo)
+            layerOf.set(node.id, layerOf.get(node.attachedTo));
+    return { layers: layers.map((layer) => layer ?? []), layerOf, backFlows };
+};

package/dist/layout/layout.d.ts

@@ -0,0 +1,12 @@
+import { type Json } from "./model.ts";
+export interface LayoutResult {
+    document: Json;
+}
+export interface LayoutOptions {
+    force?: boolean;
+}
+export declare class LayoutInputError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+export declare const layoutDocument: (document: unknown, options?: LayoutOptions) => LayoutResult;