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

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;

package/dist/layout/layout.js

@@ -0,0 +1,299 @@
+import { compileSchema, validateWithSchema } from "../schema-validate.js";
+import { layoutCollaboration } from "./collaboration.js";
+import { buildDiagram, containerElement, diagramProperties, edgeElement, shapeElement } from "./di.js";
+import { extractProcess } from "./extract.js";
+import { extractLanes, flattenLanes } from "./lanes.js";
+import { allFlows, allNodes } from "./model.js";
+import { placeStandalone } from "./standalone.js";
+export class LayoutInputError extends Error {
+    errors;
+    constructor(errors) {
+        super(`invalid BPMN-LD document: ${errors[0]}`);
+        this.name = "LayoutInputError";
+        this.errors = errors;
+    }
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+let compiled;
+const schema = () => (compiled ??= compileSchema());
+const collectIds = (value, found) => {
+    if (Array.isArray(value))
+        value.forEach((item) => collectIds(item, found));
+    else if (isObject(value)) {
+        if (typeof value.id === "string")
+            found.add(value.id);
+        Object.values(value).forEach((item) => collectIds(item, found));
+    }
+    return found;
+};
+const diagramsOf = (graph, processId) => graph.filter((node) => node.type === "BPMNDiagram" && isObject(node.plane) && node.plane.bpmnElement === processId);
+const isBox = (bounds) => isObject(bounds) && ["x", "y", "width", "height"].every((key) => Number.isFinite(bounds[key]));
+const elementsOf = (diagrams) => diagrams.flatMap((diagram) => (Array.isArray(diagram.plane.planeElements) ? diagram.plane.planeElements.filter(isObject) : []));
+const previousIds = (diagrams) => {
+    const previous = {
+        diagram: diagrams[0].id,
+        plane: diagrams[0].plane.id,
+        name: diagrams[0].name,
+        resolution: diagrams[0].resolution,
+        messageVisibleKinds: new Map(),
+        shapes: new Map(),
+        edges: new Map(),
+    };
+    for (const element of elementsOf(diagrams)) {
+        if (typeof element.id !== "string" || typeof element.bpmnElement !== "string")
+            continue;
+        const table = element.type === "BPMNShape" ? previous.shapes : element.type === "BPMNEdge" ? previous.edges : undefined;
+        if (table && !table.has(element.bpmnElement)) {
+            table.set(element.bpmnElement, element.id);
+            if (element.type === "BPMNEdge" && element.messageVisibleKind !== undefined)
+                previous.messageVisibleKinds.set(element.bpmnElement, element.messageVisibleKind);
+        }
+    }
+    return previous;
+};
+const collapsedShapes = (diagrams) => new Set(elementsOf(diagrams)
+    .filter((element) => element.type === "BPMNShape" && element.isExpanded === false && typeof element.bpmnElement === "string")
+    .map((element) => element.bpmnElement));
+const nestedLaneIds = (model) => model.nodes.flatMap((node) => (node.content ? [...(node.content.lanes?.ids ?? []), ...nestedLaneIds(node.content)] : []));
+const ownersOf = (model, owners = new Map()) => {
+    for (const item of model.data)
+        owners.set(item.id, model.id);
+    for (const node of model.nodes) {
+        owners.set(node.id, model.id);
+        if (node.content)
+            ownersOf(node.content, owners);
+    }
+    return owners;
+};
+export const layoutDocument = (document, options = {}) => {
+    if (!isObject(document))
+        throw new LayoutInputError(["document must be a JSON object"]);
+    const errors = [...new Set(validateWithSchema(document, schema()))];
+    if (errors.length > 0)
+        throw new LayoutInputError(errors);
+    const output = structuredClone(document);
+    const graph = Array.isArray(output["@graph"]) ? output["@graph"] : [];
+    if (!Array.isArray(output["@graph"])) {
+        const { "@context": context, ...root } = output;
+        output["@graph"] = graph;
+        for (const key of Object.keys(root))
+            delete output[key];
+        graph.push(root);
+        output["@context"] = context;
+    }
+    const used = collectIds(graph, new Set());
+    const unique = (preferred) => {
+        let id = preferred;
+        for (let n = 2; used.has(id); n++)
+            id = `${preferred}_${n}`;
+        used.add(id);
+        return id;
+    };
+    const processes = new Map();
+    for (const node of graph)
+        if (node.type === "Process" && typeof node.id === "string")
+            processes.set(node.id, node);
+    const claimed = new Set();
+    const participantsOf = (collaboration) => (Array.isArray(collaboration.participants) ? collaboration.participants : []).filter((item) => isObject(item) && typeof item.id === "string");
+    for (const root of graph)
+        if (root.type === "Collaboration")
+            for (const participant of participantsOf(root))
+                if (typeof participant.processRef === "string" && processes.has(participant.processRef))
+                    claimed.add(participant.processRef);
+    const tied = new Map();
+    for (const root of graph) {
+        if (root.type !== "Collaboration" || participantsOf(root).length === 0)
+            continue;
+        const endpoints = new Set();
+        for (const flow of Array.isArray(root.messageFlows) ? root.messageFlows : [])
+            if (isObject(flow))
+                for (const key of ["sourceRef", "targetRef"])
+                    if (typeof flow[key] === "string")
+                        endpoints.add(flow[key]);
+        const drawn = new Set(elementsOf(diagramsOf(graph, root.id)).map((element) => element.bpmnElement));
+        const related = [];
+        for (const [id, process] of processes) {
+            if (claimed.has(id))
+                continue;
+            const model = extractProcess(process);
+            const elements = [...allNodes(model), ...allFlows(model)];
+            if (!elements.some((element) => endpoints.has(element.id) || drawn.has(element.id)) || model.nodes.length === 0)
+                continue;
+            claimed.add(id);
+            related.push(process);
+        }
+        tied.set(root.id, related);
+    }
+    const layoutCollaborationRoot = (root) => {
+        const participantInputs = participantsOf(root);
+        if (participantInputs.length === 0)
+            return;
+        const diagrams = diagramsOf(graph, root.id);
+        const collapsed = collapsedShapes(diagrams);
+        const seen = new Set();
+        const participants = participantInputs.map((participant) => {
+            const process = typeof participant.processRef === "string" && !seen.has(participant.processRef) ? processes.get(participant.processRef) : undefined;
+            if (!process)
+                return { id: participant.id };
+            seen.add(process.id);
+            return { id: participant.id, model: extractProcess(process, collapsed), lanes: extractLanes(process) };
+        });
+        for (const process of tied.get(root.id) ?? [])
+            participants.push({ id: process.id, model: extractProcess(process, collapsed), lanes: extractLanes(process), unframed: true });
+        const messageFlows = (Array.isArray(root.messageFlows) ? root.messageFlows : [])
+            .filter((flow) => isObject(flow) && typeof flow.id === "string" && typeof flow.sourceRef === "string" && typeof flow.targetRef === "string")
+            .map((flow) => ({ id: flow.id, source: flow.sourceRef, target: flow.targetRef }));
+        const build = (layout, shapeIds, shapeId, edgeId, skipShape, skipEdge) => {
+            const added = [];
+            for (const shape of layout.shapes) {
+                if (skipShape(shape.element))
+                    continue;
+                const id = shapeId(shape.element);
+                shapeIds.set(shape.element, id);
+                added.push(shape.kind === "node" ? shapeElement(id, shape.node, shape.box) : containerElement(id, shape.element, shape.box));
+            }
+            for (const edge of layout.edges)
+                if (!skipEdge(edge.element))
+                    added.push(edgeElement(edgeId(edge.element), edge.element, edge.source && shapeIds.get(edge.source), edge.target && shapeIds.get(edge.target), edge.route));
+            return added;
+        };
+        if (diagrams.length === 0 || options.force) {
+            const previous = diagrams.length > 0 ? previousIds(diagrams) : undefined;
+            if (previous)
+                collectIds(diagrams, new Set()).forEach((id) => used.delete(id));
+            const layout = layoutCollaboration(participants, messageFlows, { fixed: new Map(), obstacles: new Map() });
+            const shapeIds = new Map();
+            const planeElements = build(layout, shapeIds, (element) => unique(previous?.shapes.get(element) ?? `Shape_${element}`), (element) => unique(previous?.edges.get(element) ?? `Edge_${element}`), () => false, () => false);
+            for (const element of planeElements) {
+                const kind = element.type === "BPMNEdge" ? previous?.messageVisibleKinds.get(element.bpmnElement) : undefined;
+                if (kind !== undefined)
+                    element.messageVisibleKind = kind;
+            }
+            const replacement = {
+                id: unique(previous?.diagram ?? `Diagram_${root.id}`),
+                type: "BPMNDiagram",
+                ...diagramProperties(previous),
+                plane: { id: unique(previous?.plane ?? `Plane_${root.id}`), type: "BPMNPlane", bpmnElement: root.id, planeElements },
+            };
+            if (diagrams.length === 0)
+                graph.push(replacement);
+            else {
+                const position = graph.indexOf(diagrams[0]);
+                for (const diagram of diagrams.slice(1))
+                    graph.splice(graph.indexOf(diagram), 1);
+                graph.splice(position, 1, replacement);
+            }
+            return;
+        }
+        const elements = elementsOf(diagrams);
+        const shapeIds = new Map();
+        const fixed = new Map();
+        const drawnEdges = new Set();
+        for (const element of elements) {
+            if (typeof element.bpmnElement !== "string")
+                continue;
+            if (element.type === "BPMNShape" && isBox(element.bounds) && !shapeIds.has(element.bpmnElement)) {
+                shapeIds.set(element.bpmnElement, element.id);
+                fixed.set(element.bpmnElement, element.bounds);
+            }
+            else if (element.type === "BPMNEdge")
+                drawnEdges.add(element.bpmnElement);
+        }
+        const models = participants.flatMap((participant) => (participant.model ? [participant.model] : []));
+        const missingFlows = new Set(models.flatMap((model) => allFlows(model)).filter((flow) => !drawnEdges.has(flow.id)).map((flow) => flow.id));
+        const owners = new Map();
+        for (const model of models)
+            ownersOf(model, owners);
+        const obstacles = new Map();
+        for (const element of elements) {
+            if (element.type !== "BPMNShape" || !isBox(element.bounds) || !owners.has(element.bpmnElement))
+                continue;
+            const owner = owners.get(element.bpmnElement);
+            obstacles.set(owner, [...(obstacles.get(owner) ?? []), element.bounds]);
+        }
+        const layout = layoutCollaboration(participants, messageFlows, { fixed, obstacles, missingFlows });
+        const skipShape = (element) => fixed.has(element);
+        const skipEdge = (element) => drawnEdges.has(element);
+        if (layout.shapes.every((shape) => skipShape(shape.element)) && layout.edges.every((edge) => skipEdge(edge.element)))
+            return;
+        const added = build(layout, shapeIds, (element) => unique(`Shape_${element}`), (element) => unique(`Edge_${element}`), skipShape, skipEdge);
+        const plane = diagrams[0].plane;
+        plane.planeElements = [...(Array.isArray(plane.planeElements) ? plane.planeElements : []), ...added];
+    };
+    for (const root of [...graph]) {
+        if (root.type === "Collaboration" && typeof root.id === "string") {
+            layoutCollaborationRoot(root);
+            continue;
+        }
+        if (root.type !== "Process" || claimed.has(root.id) || typeof root.id !== "string")
+            continue;
+        const diagrams = diagramsOf(graph, root.id);
+        const model = extractProcess(root, collapsedShapes(diagrams));
+        if (model.nodes.length === 0)
+            continue;
+        const laneNodes = extractLanes(root);
+        if (diagrams.length === 0) {
+            graph.push(buildDiagram(model, placeStandalone(model, laneNodes), unique));
+            continue;
+        }
+        if (options.force) {
+            const previous = previousIds(diagrams);
+            collectIds(diagrams, new Set()).forEach((id) => used.delete(id));
+            const position = graph.indexOf(diagrams[0]);
+            const replacement = buildDiagram(model, placeStandalone(model, laneNodes), unique, previous);
+            for (const diagram of diagrams.slice(1))
+                graph.splice(graph.indexOf(diagram), 1);
+            graph.splice(position, 1, replacement);
+            continue;
+        }
+        const elements = elementsOf(diagrams);
+        const shapeIds = new Map();
+        const fixed = new Map();
+        const drawnFlows = new Set();
+        for (const element of elements) {
+            if (typeof element.bpmnElement !== "string")
+                continue;
+            if (element.type === "BPMNShape" && isBox(element.bounds) && !shapeIds.has(element.bpmnElement)) {
+                shapeIds.set(element.bpmnElement, element.id);
+                fixed.set(element.bpmnElement, element.bounds);
+            }
+            else if (element.type === "BPMNEdge")
+                drawnFlows.add(element.bpmnElement);
+        }
+        const nodes = allNodes(model);
+        const missingNodes = nodes.filter((node) => !fixed.has(node.id));
+        const missingFlows = allFlows(model).filter((flow) => !drawnFlows.has(flow.id));
+        const laneIds = new Set([...flattenLanes(laneNodes ?? []).map((lane) => lane.id), ...nestedLaneIds(model)]);
+        const missingLanes = [...laneIds].filter((id) => !fixed.has(id));
+        if (missingNodes.length === 0 && missingFlows.length === 0 && missingLanes.length === 0)
+            continue;
+        const owners = ownersOf(model);
+        const obstacles = new Map();
+        for (const element of elements) {
+            if (element.type !== "BPMNShape" || !isBox(element.bounds) || laneIds.has(element.bpmnElement))
+                continue;
+            const owner = owners.get(element.bpmnElement) ?? model.id;
+            obstacles.set(owner, [...(obstacles.get(owner) ?? []), element.bounds]);
+        }
+        const placed = placeStandalone(model, laneNodes, { fixed, obstacles, missingFlows: new Set(missingFlows.map((flow) => flow.id)) });
+        const added = [];
+        for (const lane of missingLanes) {
+            const id = unique(`Shape_${lane}`);
+            shapeIds.set(lane, id);
+            added.push(containerElement(id, lane, placed.lanes.get(lane)));
+        }
+        for (const node of missingNodes) {
+            const id = unique(`Shape_${node.id}`);
+            shapeIds.set(node.id, id);
+            added.push(shapeElement(id, node, placed.boxes.get(node.id)));
+        }
+        for (const flow of missingFlows) {
+            const route = placed.routes.get(flow.id);
+            if (route)
+                added.push(edgeElement(unique(`Edge_${flow.id}`), flow.id, flow.source && shapeIds.get(flow.source), flow.target && shapeIds.get(flow.target), route));
+        }
+        const plane = diagrams[0].plane;
+        plane.planeElements = [...(Array.isArray(plane.planeElements) ? plane.planeElements : []), ...added];
+    }
+    return { document: output };
+};

package/dist/layout/model.d.ts

@@ -0,0 +1,52 @@
+import type { Layering } from "./layering.ts";
+export type Json = Record<string, any>;
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Box extends Point, Size {
+}
+export interface LaneHooks {
+    ids: string[];
+    indent: number;
+    arrange: (layering: Layering, layered: Map<string, Box>, origin: Point) => void;
+    boxes: (frame: Box, boxes: Map<string, Box>, anchored: boolean) => Map<string, Box>;
+}
+export interface FlowNode {
+    id: string;
+    type: string;
+    size: Size;
+    attachedTo?: string;
+    collapsed?: boolean;
+    content?: ProcessModel;
+}
+export interface Flow {
+    id: string;
+    source: string;
+    target: string;
+}
+export interface Edge {
+    id: string;
+    source?: string;
+    target?: string;
+}
+export interface ProcessModel {
+    id: string;
+    nodes: FlowNode[];
+    flows: Flow[];
+    data: FlowNode[];
+    stubs: Edge[];
+    associations: Flow[];
+    lanes?: LaneHooks;
+}
+export interface Placement {
+    boxes: Map<string, Box>;
+    routes: Map<string, Point[]>;
+    lanes?: Map<string, Box>;
+}
+export declare const allNodes: (model: ProcessModel) => FlowNode[];
+export declare const allFlows: (model: ProcessModel) => Edge[];

package/dist/layout/model.js

@@ -0,0 +1,10 @@
+export const allNodes = (model) => [
+    ...model.nodes.flatMap((node) => [node, ...(node.content ? allNodes(node.content) : [])]),
+    ...model.data,
+];
+export const allFlows = (model) => [
+    ...model.flows,
+    ...model.stubs,
+    ...model.associations,
+    ...model.nodes.flatMap((node) => (node.content ? allFlows(node.content) : [])),
+];

package/dist/layout/placement.d.ts

@@ -0,0 +1,25 @@
+import { type Layering } from "./layering.ts";
+import type { Box, Flow, FlowNode, Point, ProcessModel } from "./model.ts";
+export declare const ORIGIN: Point;
+export declare const ROW_GAP = 40;
+export declare const reserveBelow: (model: ProcessModel, hostId: string) => number;
+export declare const boundaryBox: (model: ProcessModel, node: FlowNode, host: Box) => Box;
+export declare const placeNodes: (model: ProcessModel, layering: Layering, origin?: Point) => Map<string, Box>;
+export declare const routeFlows: (model: ProcessModel, flows: Flow[], layering: Layering, boxes: Map<string, Box>) => Map<string, Point[]>;
+export declare const placeData: (model: ProcessModel, boxes: Map<string, Box>, routes: Map<string, Point[]>, fixed?: Map<string, Box>) => Map<string, Box>;
+export declare const routeExtras: (model: ProcessModel, boxes: Map<string, Box>, only?: Set<string>) => Map<string, Point[]>;
+export declare const measure: (model: ProcessModel) => void;
+export interface ScopeContext {
+    fixed: Map<string, Box>;
+    obstacles: Map<string, Box[]>;
+    missingFlows?: Set<string>;
+    boxes: Map<string, Box>;
+    routes: Map<string, Point[]>;
+    arrange?: (model: ProcessModel, layering: Layering, layered: Map<string, Box>, origin: Point) => void;
+    lanes?: Map<string, Box>;
+}
+export declare const placeScope: (model: ProcessModel, origin: Point, context: ScopeContext) => void;
+export declare const place: (model: ProcessModel) => {
+    boxes: Map<string, Box>;
+    routes: Map<string, Point[]>;
+};