@bpmnkit/core 0.0.8

package/dist/bpmn/bpmn-parser.js

@@ -0,0 +1,642 @@
+import { ParseError } from "../errors.js";
+import { parseXml } from "../xml/xml-parser.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function localName(name) {
+    const idx = name.indexOf(":");
+    return idx >= 0 ? name.slice(idx + 1) : name;
+}
+function findChildren(element, tagLocalName) {
+    return element.children.filter((c) => localName(c.name) === tagLocalName);
+}
+function findChild(element, tagLocalName) {
+    return element.children.find((c) => localName(c.name) === tagLocalName);
+}
+function attr(element, name) {
+    if (element.attributes[name] !== undefined)
+        return element.attributes[name];
+    for (const [key, value] of Object.entries(element.attributes)) {
+        if (localName(key) === name)
+            return value;
+    }
+    return undefined;
+}
+function requiredAttr(element, name) {
+    const value = attr(element, name);
+    if (value === undefined) {
+        throw new ParseError(`Missing required attribute "${name}" on <${element.name}>`);
+    }
+    return value;
+}
+/** Collect text from child <bpmn:incoming> / <bpmn:outgoing> elements. */
+function collectFlowRefs(element, tag) {
+    return findChildren(element, tag)
+        .map((c) => c.text?.trim())
+        .filter((t) => !!t);
+}
+/** Known attribute names on flow nodes — everything else goes to unknownAttributes. */
+const KNOWN_ATTRS = new Set([
+    "id",
+    "name",
+    "default",
+    "attachedToRef",
+    "cancelActivity",
+    "sourceRef",
+    "targetRef",
+    "associationDirection",
+    "isExecutable",
+    "isMarkerVisible",
+    "isExpanded",
+    "isHorizontal",
+    "bpmnElement",
+    "errorRef",
+    "escalationRef",
+    "errorCode",
+    "escalationCode",
+    "targetNamespace",
+    "exporter",
+    "exporterVersion",
+    "processRef",
+]);
+/** Extract unknown (namespace-qualified) attributes from an element. */
+function unknownAttrs(element) {
+    const result = {};
+    for (const [key, value] of Object.entries(element.attributes)) {
+        if (key.startsWith("xmlns:") || key === "xmlns")
+            continue;
+        if (KNOWN_ATTRS.has(key))
+            continue;
+        if (KNOWN_ATTRS.has(localName(key)))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/** Known child local names for flow nodes — anything else is an extension. */
+const KNOWN_FLOW_CHILDREN = new Set([
+    "incoming",
+    "outgoing",
+    "documentation",
+    "extensionElements",
+    "conditionExpression",
+    "timerEventDefinition",
+    "errorEventDefinition",
+    "escalationEventDefinition",
+    "messageEventDefinition",
+    "signalEventDefinition",
+    "conditionalEventDefinition",
+    "linkEventDefinition",
+    "cancelEventDefinition",
+    "terminateEventDefinition",
+    "compensateEventDefinition",
+    "multiInstanceLoopCharacteristics",
+    // Sub-process children are handled separately
+]);
+const KNOWN_PROCESS_CHILDREN = new Set([
+    "startEvent",
+    "endEvent",
+    "intermediateCatchEvent",
+    "intermediateThrowEvent",
+    "boundaryEvent",
+    "task",
+    "serviceTask",
+    "scriptTask",
+    "userTask",
+    "sendTask",
+    "receiveTask",
+    "businessRuleTask",
+    "manualTask",
+    "callActivity",
+    "subProcess",
+    "adHocSubProcess",
+    "eventSubProcess",
+    "transaction",
+    "exclusiveGateway",
+    "parallelGateway",
+    "inclusiveGateway",
+    "eventBasedGateway",
+    "complexGateway",
+    "sequenceFlow",
+    "textAnnotation",
+    "association",
+    "laneSet",
+    "extensionElements",
+]);
+// ---------------------------------------------------------------------------
+// Extension elements
+// ---------------------------------------------------------------------------
+function parseExtensionElements(element) {
+    const ext = findChild(element, "extensionElements");
+    return ext ? ext.children : [];
+}
+// ---------------------------------------------------------------------------
+// Event definitions
+// ---------------------------------------------------------------------------
+function parseEventDefinitions(element) {
+    const defs = [];
+    for (const child of element.children) {
+        const ln = localName(child.name);
+        if (ln === "timerEventDefinition") {
+            const durationEl = findChild(child, "timeDuration");
+            const dateEl = findChild(child, "timeDate");
+            const cycleEl = findChild(child, "timeCycle");
+            defs.push({
+                type: "timer",
+                id: attr(child, "id"),
+                timeDuration: durationEl?.text?.trim(),
+                timeDurationAttributes: durationEl
+                    ? Object.keys(durationEl.attributes).length > 0
+                        ? { ...durationEl.attributes }
+                        : undefined
+                    : undefined,
+                timeDate: dateEl?.text?.trim(),
+                timeDateAttributes: dateEl
+                    ? Object.keys(dateEl.attributes).length > 0
+                        ? { ...dateEl.attributes }
+                        : undefined
+                    : undefined,
+                timeCycle: cycleEl?.text?.trim(),
+                timeCycleAttributes: cycleEl
+                    ? Object.keys(cycleEl.attributes).length > 0
+                        ? { ...cycleEl.attributes }
+                        : undefined
+                    : undefined,
+            });
+        }
+        else if (ln === "errorEventDefinition") {
+            defs.push({
+                type: "error",
+                id: attr(child, "id"),
+                errorRef: attr(child, "errorRef"),
+            });
+        }
+        else if (ln === "escalationEventDefinition") {
+            defs.push({
+                type: "escalation",
+                id: attr(child, "id"),
+                escalationRef: attr(child, "escalationRef"),
+            });
+        }
+        else if (ln === "messageEventDefinition") {
+            defs.push({
+                type: "message",
+                id: attr(child, "id"),
+                messageRef: attr(child, "messageRef"),
+            });
+        }
+        else if (ln === "signalEventDefinition") {
+            defs.push({
+                type: "signal",
+                id: attr(child, "id"),
+                signalRef: attr(child, "signalRef"),
+            });
+        }
+        else if (ln === "conditionalEventDefinition") {
+            const condEl = findChild(child, "condition");
+            defs.push({
+                type: "conditional",
+                id: attr(child, "id"),
+                condition: condEl?.text?.trim(),
+            });
+        }
+        else if (ln === "linkEventDefinition") {
+            defs.push({
+                type: "link",
+                id: attr(child, "id"),
+                name: attr(child, "name"),
+            });
+        }
+        else if (ln === "cancelEventDefinition") {
+            defs.push({ type: "cancel", id: attr(child, "id") });
+        }
+        else if (ln === "terminateEventDefinition") {
+            defs.push({ type: "terminate", id: attr(child, "id") });
+        }
+        else if (ln === "compensateEventDefinition") {
+            defs.push({
+                type: "compensate",
+                id: attr(child, "id"),
+                activityRef: attr(child, "activityRef"),
+            });
+        }
+    }
+    return defs;
+}
+// ---------------------------------------------------------------------------
+// Multi-instance loop
+// ---------------------------------------------------------------------------
+function parseLoopCharacteristics(element) {
+    const loopEl = findChild(element, "multiInstanceLoopCharacteristics");
+    if (!loopEl)
+        return undefined;
+    return { extensionElements: parseExtensionElements(loopEl) };
+}
+// ---------------------------------------------------------------------------
+// Flow elements
+// ---------------------------------------------------------------------------
+const FLOW_ELEMENT_TYPES = new Set([
+    "startEvent",
+    "endEvent",
+    "intermediateCatchEvent",
+    "intermediateThrowEvent",
+    "boundaryEvent",
+    "task",
+    "serviceTask",
+    "scriptTask",
+    "userTask",
+    "sendTask",
+    "receiveTask",
+    "businessRuleTask",
+    "manualTask",
+    "callActivity",
+    "subProcess",
+    "adHocSubProcess",
+    "eventSubProcess",
+    "transaction",
+    "exclusiveGateway",
+    "parallelGateway",
+    "inclusiveGateway",
+    "eventBasedGateway",
+    "complexGateway",
+]);
+function parseFlowElement(element) {
+    const ln = localName(element.name);
+    if (!FLOW_ELEMENT_TYPES.has(ln))
+        return undefined;
+    const base = {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        incoming: collectFlowRefs(element, "incoming"),
+        outgoing: collectFlowRefs(element, "outgoing"),
+        documentation: findChild(element, "documentation")?.text,
+        extensionElements: parseExtensionElements(element),
+        unknownAttributes: unknownAttrs(element),
+    };
+    switch (ln) {
+        case "startEvent":
+        case "endEvent":
+        case "intermediateCatchEvent":
+        case "intermediateThrowEvent":
+            return { ...base, type: ln, eventDefinitions: parseEventDefinitions(element) };
+        case "boundaryEvent":
+            return {
+                ...base,
+                type: "boundaryEvent",
+                attachedToRef: requiredAttr(element, "attachedToRef"),
+                cancelActivity: attr(element, "cancelActivity") !== undefined
+                    ? attr(element, "cancelActivity") === "true"
+                    : undefined,
+                eventDefinitions: parseEventDefinitions(element),
+            };
+        case "task":
+        case "serviceTask":
+        case "scriptTask":
+        case "userTask":
+        case "sendTask":
+        case "receiveTask":
+        case "businessRuleTask":
+        case "manualTask":
+        case "callActivity":
+            return { ...base, type: ln, loopCharacteristics: parseLoopCharacteristics(element) };
+        case "adHocSubProcess":
+            return {
+                ...base,
+                type: "adHocSubProcess",
+                loopCharacteristics: parseLoopCharacteristics(element),
+                ...parseProcessContents(element),
+            };
+        case "subProcess":
+            return {
+                ...base,
+                type: "subProcess",
+                triggeredByEvent: attr(element, "triggeredByEvent") !== undefined
+                    ? attr(element, "triggeredByEvent") === "true"
+                    : undefined,
+                loopCharacteristics: parseLoopCharacteristics(element),
+                ...parseProcessContents(element),
+            };
+        case "eventSubProcess":
+            return {
+                ...base,
+                type: "eventSubProcess",
+                ...parseProcessContents(element),
+            };
+        case "transaction":
+            return {
+                ...base,
+                type: "transaction",
+                loopCharacteristics: parseLoopCharacteristics(element),
+                ...parseProcessContents(element),
+            };
+        case "exclusiveGateway":
+            return { ...base, type: "exclusiveGateway", default: attr(element, "default") };
+        case "parallelGateway":
+            return { ...base, type: "parallelGateway" };
+        case "inclusiveGateway":
+            return { ...base, type: "inclusiveGateway", default: attr(element, "default") };
+        case "eventBasedGateway":
+            return { ...base, type: "eventBasedGateway" };
+        case "complexGateway":
+            return { ...base, type: "complexGateway", default: attr(element, "default") };
+        default:
+            return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Sequence flows
+// ---------------------------------------------------------------------------
+function parseSequenceFlow(element) {
+    const condEl = findChild(element, "conditionExpression");
+    let conditionExpression;
+    if (condEl) {
+        conditionExpression = {
+            text: condEl.text ?? "",
+            attributes: { ...condEl.attributes },
+        };
+    }
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        sourceRef: requiredAttr(element, "sourceRef"),
+        targetRef: requiredAttr(element, "targetRef"),
+        conditionExpression,
+        extensionElements: parseExtensionElements(element),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+// ---------------------------------------------------------------------------
+// Annotations
+// ---------------------------------------------------------------------------
+function parseTextAnnotation(element) {
+    const textEl = findChild(element, "text");
+    return {
+        id: requiredAttr(element, "id"),
+        text: textEl?.text,
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+function parseAssociation(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        sourceRef: requiredAttr(element, "sourceRef"),
+        targetRef: requiredAttr(element, "targetRef"),
+        associationDirection: attr(element, "associationDirection"),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+// ---------------------------------------------------------------------------
+// Process contents (shared between process and adHocSubProcess)
+// ---------------------------------------------------------------------------
+function parseProcessContents(element) {
+    const flowElements = [];
+    const sequenceFlows = [];
+    const textAnnotations = [];
+    const associations = [];
+    for (const child of element.children) {
+        const ln = localName(child.name);
+        if (FLOW_ELEMENT_TYPES.has(ln)) {
+            const fe = parseFlowElement(child);
+            if (fe)
+                flowElements.push(fe);
+        }
+        else if (ln === "sequenceFlow") {
+            sequenceFlows.push(parseSequenceFlow(child));
+        }
+        else if (ln === "textAnnotation") {
+            textAnnotations.push(parseTextAnnotation(child));
+        }
+        else if (ln === "association") {
+            associations.push(parseAssociation(child));
+        }
+    }
+    return { flowElements, sequenceFlows, textAnnotations, associations };
+}
+// ---------------------------------------------------------------------------
+// Lanes
+// ---------------------------------------------------------------------------
+function parseLane(element) {
+    const flowNodeRefs = findChildren(element, "flowNodeRef")
+        .map((c) => c.text?.trim())
+        .filter((t) => !!t);
+    const childLaneSetEl = findChild(element, "childLaneSet");
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        flowNodeRefs,
+        childLaneSet: childLaneSetEl ? parseLaneSet(childLaneSetEl) : undefined,
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+function parseLaneSet(element) {
+    return {
+        id: attr(element, "id"),
+        lanes: findChildren(element, "lane").map(parseLane),
+    };
+}
+// ---------------------------------------------------------------------------
+// Process
+// ---------------------------------------------------------------------------
+function parseProcess(element) {
+    const laneSetEl = findChild(element, "laneSet");
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        isExecutable: attr(element, "isExecutable") === "true" ? true : undefined,
+        extensionElements: parseExtensionElements(element),
+        unknownAttributes: unknownAttrs(element),
+        laneSet: laneSetEl ? parseLaneSet(laneSetEl) : undefined,
+        ...parseProcessContents(element),
+    };
+}
+// ---------------------------------------------------------------------------
+// Collaboration
+// ---------------------------------------------------------------------------
+function parseParticipant(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        processRef: attr(element, "processRef"),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+function parseMessageFlow(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        sourceRef: requiredAttr(element, "sourceRef"),
+        targetRef: requiredAttr(element, "targetRef"),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+function parseCollaboration(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        participants: findChildren(element, "participant").map(parseParticipant),
+        messageFlows: findChildren(element, "messageFlow").map(parseMessageFlow),
+        textAnnotations: findChildren(element, "textAnnotation").map(parseTextAnnotation),
+        associations: findChildren(element, "association").map(parseAssociation),
+        extensionElements: parseExtensionElements(element),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+// ---------------------------------------------------------------------------
+// Root elements
+// ---------------------------------------------------------------------------
+function parseError(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        errorCode: attr(element, "errorCode"),
+    };
+}
+function parseEscalation(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        escalationCode: attr(element, "escalationCode"),
+    };
+}
+function parseMessage(element) {
+    return {
+        id: requiredAttr(element, "id"),
+        name: attr(element, "name"),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+// ---------------------------------------------------------------------------
+// Diagram interchange
+// ---------------------------------------------------------------------------
+function parseBounds(element) {
+    return {
+        x: Number(attr(element, "x") ?? "0"),
+        y: Number(attr(element, "y") ?? "0"),
+        width: Number(attr(element, "width") ?? "0"),
+        height: Number(attr(element, "height") ?? "0"),
+    };
+}
+function parseLabel(element) {
+    const labelEl = findChild(element, "BPMNLabel");
+    if (!labelEl)
+        return undefined;
+    const boundsEl = findChild(labelEl, "Bounds");
+    return { bounds: boundsEl ? parseBounds(boundsEl) : undefined };
+}
+function parseDiShape(element) {
+    const boundsEl = findChild(element, "Bounds");
+    if (!boundsEl)
+        throw new Error(`Missing <dc:Bounds> in shape "${attr(element, "id")}"`);
+    return {
+        id: requiredAttr(element, "id"),
+        bpmnElement: requiredAttr(element, "bpmnElement"),
+        isMarkerVisible: attr(element, "isMarkerVisible") !== undefined
+            ? attr(element, "isMarkerVisible") === "true"
+            : undefined,
+        isExpanded: attr(element, "isExpanded") !== undefined
+            ? attr(element, "isExpanded") === "true"
+            : undefined,
+        isHorizontal: attr(element, "isHorizontal") !== undefined
+            ? attr(element, "isHorizontal") === "true"
+            : undefined,
+        bounds: parseBounds(boundsEl),
+        label: parseLabel(element),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+function parseDiEdge(element) {
+    const waypoints = findChildren(element, "waypoint").map((w) => ({
+        x: Number(attr(w, "x") ?? "0"),
+        y: Number(attr(w, "y") ?? "0"),
+    }));
+    return {
+        id: requiredAttr(element, "id"),
+        bpmnElement: requiredAttr(element, "bpmnElement"),
+        waypoints,
+        label: parseLabel(element),
+        unknownAttributes: unknownAttrs(element),
+    };
+}
+function parseDiagram(element) {
+    const planeEl = findChild(element, "BPMNPlane");
+    if (!planeEl)
+        throw new Error("Missing <bpmndi:BPMNPlane> in diagram");
+    const shapes = [];
+    const edges = [];
+    for (const child of planeEl.children) {
+        const ln = localName(child.name);
+        if (ln === "BPMNShape")
+            shapes.push(parseDiShape(child));
+        else if (ln === "BPMNEdge")
+            edges.push(parseDiEdge(child));
+    }
+    return {
+        id: requiredAttr(element, "id"),
+        plane: {
+            id: requiredAttr(planeEl, "id"),
+            bpmnElement: requiredAttr(planeEl, "bpmnElement"),
+            shapes,
+            edges,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Parse a BPMN XML string into a typed BpmnDefinitions model. */
+export function parseBpmn(xml) {
+    const root = parseXml(xml);
+    if (localName(root.name) !== "definitions") {
+        throw new Error(`Expected <definitions> root element, got <${root.name}>`);
+    }
+    const namespaces = {};
+    const unknownAttributes = {};
+    for (const [key, value] of Object.entries(root.attributes)) {
+        if (key.startsWith("xmlns:")) {
+            namespaces[key.slice(6)] = value;
+        }
+        else if (key === "xmlns") {
+            namespaces[""] = value;
+        }
+        else if (KNOWN_ATTRS.has(key)) {
+        }
+        else {
+            unknownAttributes[key] = value;
+        }
+    }
+    const errors = [];
+    const escalations = [];
+    const messages = [];
+    const collaborations = [];
+    const processes = [];
+    const diagrams = [];
+    for (const child of root.children) {
+        const ln = localName(child.name);
+        if (ln === "error")
+            errors.push(parseError(child));
+        else if (ln === "escalation")
+            escalations.push(parseEscalation(child));
+        else if (ln === "message")
+            messages.push(parseMessage(child));
+        else if (ln === "collaboration")
+            collaborations.push(parseCollaboration(child));
+        else if (ln === "process")
+            processes.push(parseProcess(child));
+        else if (ln === "BPMNDiagram")
+            diagrams.push(parseDiagram(child));
+    }
+    return {
+        id: requiredAttr(root, "id"),
+        targetNamespace: requiredAttr(root, "targetNamespace"),
+        exporter: attr(root, "exporter"),
+        exporterVersion: attr(root, "exporterVersion"),
+        namespaces,
+        unknownAttributes,
+        errors,
+        escalations,
+        messages,
+        collaborations,
+        processes,
+        diagrams,
+    };
+}
+//# sourceMappingURL=bpmn-parser.js.map

package/dist/bpmn/bpmn-serializer.d.ts

@@ -0,0 +1,4 @@
+import type { BpmnDefinitions } from "./bpmn-model.js";
+/** Serialize a BpmnDefinitions model to a BPMN XML string. */
+export declare function serializeBpmn(definitions: BpmnDefinitions): string;
+//# sourceMappingURL=bpmn-serializer.d.ts.map