@bpmnkit/core 0.0.8

package/dist/bpmn/bpmn-serializer.js

@@ -0,0 +1,515 @@
+import { serializeXml } from "../xml/xml-parser.js";
+// ---------------------------------------------------------------------------
+// Namespace prefix resolution
+// ---------------------------------------------------------------------------
+function nsPrefix(namespaces, uri) {
+    for (const [prefix, u] of Object.entries(namespaces)) {
+        if (u === uri)
+            return prefix;
+    }
+    return undefined;
+}
+function bpmnPrefix(ns) {
+    return nsPrefix(ns, "http://www.omg.org/spec/BPMN/20100524/MODEL") ?? "bpmn";
+}
+function bpmndiPrefix(ns) {
+    return nsPrefix(ns, "http://www.omg.org/spec/BPMN/20100524/DI") ?? "bpmndi";
+}
+function dcPrefix(ns) {
+    return nsPrefix(ns, "http://www.omg.org/spec/DD/20100524/DC") ?? "dc";
+}
+function diPrefix(ns) {
+    return nsPrefix(ns, "http://www.omg.org/spec/DD/20100524/DI") ?? "di";
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function el(name, attributes, children, text) {
+    return { name, attributes, children, text };
+}
+// ---------------------------------------------------------------------------
+// Event definitions
+// ---------------------------------------------------------------------------
+function serializeEventDefinitions(defs, bp) {
+    return defs.map((d) => {
+        switch (d.type) {
+            case "timer": {
+                const children = [];
+                if (d.timeDuration !== undefined) {
+                    children.push(el(`${bp}:timeDuration`, d.timeDurationAttributes ?? {}, [], d.timeDuration));
+                }
+                if (d.timeDate !== undefined) {
+                    children.push(el(`${bp}:timeDate`, d.timeDateAttributes ?? {}, [], d.timeDate));
+                }
+                if (d.timeCycle !== undefined) {
+                    children.push(el(`${bp}:timeCycle`, d.timeCycleAttributes ?? {}, [], d.timeCycle));
+                }
+                return el(`${bp}:timerEventDefinition`, d.id ? { id: d.id } : {}, children);
+            }
+            case "error": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                if (d.errorRef)
+                    attrs.errorRef = d.errorRef;
+                return el(`${bp}:errorEventDefinition`, attrs, []);
+            }
+            case "escalation": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                if (d.escalationRef)
+                    attrs.escalationRef = d.escalationRef;
+                return el(`${bp}:escalationEventDefinition`, attrs, []);
+            }
+            case "message": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                if (d.messageRef)
+                    attrs.messageRef = d.messageRef;
+                return el(`${bp}:messageEventDefinition`, attrs, []);
+            }
+            case "signal": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                if (d.signalRef)
+                    attrs.signalRef = d.signalRef;
+                return el(`${bp}:signalEventDefinition`, attrs, []);
+            }
+            case "conditional": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                const condChildren = [];
+                if (d.condition !== undefined) {
+                    condChildren.push(el(`${bp}:condition`, {}, [], d.condition));
+                }
+                return el(`${bp}:conditionalEventDefinition`, attrs, condChildren);
+            }
+            case "link": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                if (d.name)
+                    attrs.name = d.name;
+                return el(`${bp}:linkEventDefinition`, attrs, []);
+            }
+            case "cancel": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                return el(`${bp}:cancelEventDefinition`, attrs, []);
+            }
+            case "terminate": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                return el(`${bp}:terminateEventDefinition`, attrs, []);
+            }
+            case "compensate": {
+                const attrs = {};
+                if (d.id)
+                    attrs.id = d.id;
+                if (d.activityRef)
+                    attrs.activityRef = d.activityRef;
+                return el(`${bp}:compensateEventDefinition`, attrs, []);
+            }
+            default: {
+                const _exhaustive = d;
+                throw new Error(`Unknown event definition type: ${_exhaustive.type}`);
+            }
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Extension elements
+// ---------------------------------------------------------------------------
+function serializeExtensionElements(extensions, bp) {
+    if (extensions.length === 0)
+        return [];
+    return [el(`${bp}:extensionElements`, {}, extensions)];
+}
+// ---------------------------------------------------------------------------
+// Multi-instance loop
+// ---------------------------------------------------------------------------
+function serializeLoopCharacteristics(lc, bp) {
+    if (!lc)
+        return [];
+    return [
+        el(`${bp}:multiInstanceLoopCharacteristics`, {}, [
+            ...serializeExtensionElements(lc.extensionElements, bp),
+        ]),
+    ];
+}
+// ---------------------------------------------------------------------------
+// Flow elements
+// ---------------------------------------------------------------------------
+function flowRefs(refs, tag, bp) {
+    return refs.map((r) => el(`${bp}:${tag}`, {}, [], r));
+}
+function serializeFlowElement(fe, ns) {
+    const bp = bpmnPrefix(ns);
+    const attrs = { id: fe.id, ...fe.unknownAttributes };
+    if (fe.name !== undefined)
+        attrs.name = fe.name;
+    const children = [];
+    // Documentation
+    if (fe.documentation !== undefined) {
+        children.push(el(`${bp}:documentation`, {}, [], fe.documentation));
+    }
+    // Extension elements
+    children.push(...serializeExtensionElements(fe.extensionElements, bp));
+    // Incoming / outgoing
+    children.push(...flowRefs(fe.incoming, "incoming", bp));
+    children.push(...flowRefs(fe.outgoing, "outgoing", bp));
+    switch (fe.type) {
+        case "startEvent":
+        case "endEvent":
+        case "intermediateCatchEvent":
+        case "intermediateThrowEvent":
+            children.push(...serializeEventDefinitions(fe.eventDefinitions, bp));
+            break;
+        case "boundaryEvent":
+            attrs.attachedToRef = fe.attachedToRef;
+            if (fe.cancelActivity !== undefined)
+                attrs.cancelActivity = String(fe.cancelActivity);
+            children.push(...serializeEventDefinitions(fe.eventDefinitions, bp));
+            break;
+        case "task":
+        case "serviceTask":
+        case "scriptTask":
+        case "userTask":
+        case "sendTask":
+        case "receiveTask":
+        case "businessRuleTask":
+        case "manualTask":
+        case "callActivity":
+            children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
+            break;
+        case "adHocSubProcess":
+            children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
+            children.push(...serializeProcessContents(fe, ns));
+            break;
+        case "subProcess":
+            if (fe.triggeredByEvent !== undefined)
+                attrs.triggeredByEvent = String(fe.triggeredByEvent);
+            children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
+            children.push(...serializeProcessContents(fe, ns));
+            break;
+        case "eventSubProcess":
+            children.push(...serializeProcessContents(fe, ns));
+            break;
+        case "transaction":
+            children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
+            children.push(...serializeProcessContents(fe, ns));
+            break;
+        case "exclusiveGateway":
+            if (fe.default !== undefined)
+                attrs.default = fe.default;
+            break;
+        case "inclusiveGateway":
+            if (fe.default !== undefined)
+                attrs.default = fe.default;
+            break;
+        case "complexGateway":
+            if (fe.default !== undefined)
+                attrs.default = fe.default;
+            break;
+        case "parallelGateway":
+        case "eventBasedGateway":
+            break;
+    }
+    return el(`${bp}:${fe.type}`, attrs, children);
+}
+// ---------------------------------------------------------------------------
+// Sequence flows
+// ---------------------------------------------------------------------------
+function serializeSequenceFlow(sf, bp) {
+    const attrs = {
+        id: sf.id,
+        sourceRef: sf.sourceRef,
+        targetRef: sf.targetRef,
+        ...sf.unknownAttributes,
+    };
+    if (sf.name !== undefined)
+        attrs.name = sf.name;
+    const children = [];
+    children.push(...serializeExtensionElements(sf.extensionElements, bp));
+    if (sf.conditionExpression) {
+        children.push(el(`${bp}:conditionExpression`, sf.conditionExpression.attributes, [], sf.conditionExpression.text));
+    }
+    return el(`${bp}:sequenceFlow`, attrs, children);
+}
+// ---------------------------------------------------------------------------
+// Annotations
+// ---------------------------------------------------------------------------
+function serializeTextAnnotation(ta, bp) {
+    const children = [];
+    if (ta.text !== undefined) {
+        children.push(el(`${bp}:text`, {}, [], ta.text));
+    }
+    return el(`${bp}:textAnnotation`, { id: ta.id, ...ta.unknownAttributes }, children);
+}
+function serializeAssociation(a, bp) {
+    const attrs = {
+        id: a.id,
+        sourceRef: a.sourceRef,
+        targetRef: a.targetRef,
+        ...a.unknownAttributes,
+    };
+    if (a.associationDirection !== undefined)
+        attrs.associationDirection = a.associationDirection;
+    return el(`${bp}:association`, attrs, []);
+}
+// ---------------------------------------------------------------------------
+// Process contents
+// ---------------------------------------------------------------------------
+function serializeProcessContents(p, ns) {
+    const bp = bpmnPrefix(ns);
+    const children = [];
+    for (const fe of p.flowElements) {
+        children.push(serializeFlowElement(fe, ns));
+    }
+    for (const sf of p.sequenceFlows) {
+        children.push(serializeSequenceFlow(sf, bp));
+    }
+    for (const ta of p.textAnnotations) {
+        children.push(serializeTextAnnotation(ta, bp));
+    }
+    for (const a of p.associations) {
+        children.push(serializeAssociation(a, bp));
+    }
+    return children;
+}
+// ---------------------------------------------------------------------------
+// Lanes
+// ---------------------------------------------------------------------------
+function serializeLane(lane, bp) {
+    const attrs = { id: lane.id, ...lane.unknownAttributes };
+    if (lane.name !== undefined)
+        attrs.name = lane.name;
+    const children = lane.flowNodeRefs.map((ref) => el(`${bp}:flowNodeRef`, {}, [], ref));
+    if (lane.childLaneSet) {
+        children.push(serializeLaneSet(lane.childLaneSet, bp));
+    }
+    return el(`${bp}:lane`, attrs, children);
+}
+function serializeLaneSet(laneSet, bp) {
+    const attrs = {};
+    if (laneSet.id)
+        attrs.id = laneSet.id;
+    return el(`${bp}:laneSet`, attrs, laneSet.lanes.map((l) => serializeLane(l, bp)));
+}
+// ---------------------------------------------------------------------------
+// Process
+// ---------------------------------------------------------------------------
+function serializeProcess(process, ns) {
+    const bp = bpmnPrefix(ns);
+    const attrs = { id: process.id, ...process.unknownAttributes };
+    if (process.name !== undefined)
+        attrs.name = process.name;
+    if (process.isExecutable)
+        attrs.isExecutable = "true";
+    const children = [];
+    children.push(...serializeExtensionElements(process.extensionElements, bp));
+    if (process.laneSet) {
+        children.push(serializeLaneSet(process.laneSet, bp));
+    }
+    children.push(...serializeProcessContents(process, ns));
+    return el(`${bp}:process`, attrs, children);
+}
+// ---------------------------------------------------------------------------
+// Collaboration
+// ---------------------------------------------------------------------------
+function serializeParticipant(p, bp) {
+    const attrs = { id: p.id, ...p.unknownAttributes };
+    if (p.name !== undefined)
+        attrs.name = p.name;
+    if (p.processRef !== undefined)
+        attrs.processRef = p.processRef;
+    return el(`${bp}:participant`, attrs, []);
+}
+function serializeMessageFlow(mf, bp) {
+    const attrs = {
+        id: mf.id,
+        sourceRef: mf.sourceRef,
+        targetRef: mf.targetRef,
+        ...mf.unknownAttributes,
+    };
+    if (mf.name !== undefined)
+        attrs.name = mf.name;
+    return el(`${bp}:messageFlow`, attrs, []);
+}
+function serializeCollaboration(c, ns) {
+    const bp = bpmnPrefix(ns);
+    const children = [];
+    for (const p of c.participants) {
+        children.push(serializeParticipant(p, bp));
+    }
+    for (const mf of c.messageFlows) {
+        children.push(serializeMessageFlow(mf, bp));
+    }
+    for (const ta of c.textAnnotations) {
+        children.push(serializeTextAnnotation(ta, bp));
+    }
+    for (const a of c.associations) {
+        children.push(serializeAssociation(a, bp));
+    }
+    return el(`${bp}:collaboration`, { id: c.id, ...c.unknownAttributes }, children);
+}
+// ---------------------------------------------------------------------------
+// Root elements
+// ---------------------------------------------------------------------------
+function serializeError(e, bp) {
+    const attrs = { id: e.id };
+    if (e.name !== undefined)
+        attrs.name = e.name;
+    if (e.errorCode !== undefined)
+        attrs.errorCode = e.errorCode;
+    return el(`${bp}:error`, attrs, []);
+}
+function serializeEscalation(e, bp) {
+    const attrs = { id: e.id };
+    if (e.name !== undefined)
+        attrs.name = e.name;
+    if (e.escalationCode !== undefined)
+        attrs.escalationCode = e.escalationCode;
+    return el(`${bp}:escalation`, attrs, []);
+}
+function serializeMessage(m, bp) {
+    const attrs = { id: m.id, ...m.unknownAttributes };
+    if (m.name !== undefined)
+        attrs.name = m.name;
+    return el(`${bp}:message`, attrs, []);
+}
+// ---------------------------------------------------------------------------
+// Diagram interchange
+// ---------------------------------------------------------------------------
+function serializeDiShape(shape, bdi, dc) {
+    const attrs = {
+        id: shape.id,
+        bpmnElement: shape.bpmnElement,
+        ...shape.unknownAttributes,
+    };
+    if (shape.isMarkerVisible !== undefined)
+        attrs.isMarkerVisible = String(shape.isMarkerVisible);
+    if (shape.isExpanded !== undefined)
+        attrs.isExpanded = String(shape.isExpanded);
+    if (shape.isHorizontal !== undefined)
+        attrs.isHorizontal = String(shape.isHorizontal);
+    const children = [
+        el(`${dc}:Bounds`, {
+            x: String(shape.bounds.x),
+            y: String(shape.bounds.y),
+            width: String(shape.bounds.width),
+            height: String(shape.bounds.height),
+        }, []),
+    ];
+    if (shape.label) {
+        const labelChildren = [];
+        if (shape.label.bounds) {
+            labelChildren.push(el(`${dc}:Bounds`, {
+                x: String(shape.label.bounds.x),
+                y: String(shape.label.bounds.y),
+                width: String(shape.label.bounds.width),
+                height: String(shape.label.bounds.height),
+            }, []));
+        }
+        children.push(el(`${bdi}:BPMNLabel`, {}, labelChildren));
+    }
+    return el(`${bdi}:BPMNShape`, attrs, children);
+}
+function serializeDiEdge(edge, bdi, dc, dip) {
+    const attrs = {
+        id: edge.id,
+        bpmnElement: edge.bpmnElement,
+        ...edge.unknownAttributes,
+    };
+    const children = edge.waypoints.map((w) => el(`${dip}:waypoint`, { x: String(w.x), y: String(w.y) }, []));
+    if (edge.label) {
+        const labelChildren = [];
+        if (edge.label.bounds) {
+            labelChildren.push(el(`${dc}:Bounds`, {
+                x: String(edge.label.bounds.x),
+                y: String(edge.label.bounds.y),
+                width: String(edge.label.bounds.width),
+                height: String(edge.label.bounds.height),
+            }, []));
+        }
+        children.push(el(`${bdi}:BPMNLabel`, {}, labelChildren));
+    }
+    return el(`${bdi}:BPMNEdge`, attrs, children);
+}
+function serializeDiagram(diagram, ns) {
+    const bdi = bpmndiPrefix(ns);
+    const dc = dcPrefix(ns);
+    const dip = diPrefix(ns);
+    const planeChildren = [];
+    for (const s of diagram.plane.shapes) {
+        planeChildren.push(serializeDiShape(s, bdi, dc));
+    }
+    for (const e of diagram.plane.edges) {
+        planeChildren.push(serializeDiEdge(e, bdi, dc, dip));
+    }
+    const plane = el(`${bdi}:BPMNPlane`, {
+        id: diagram.plane.id,
+        bpmnElement: diagram.plane.bpmnElement,
+    }, planeChildren);
+    return el(`${bdi}:BPMNDiagram`, { id: diagram.id }, [plane]);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Serialize a BpmnDefinitions model to a BPMN XML string. */
+export function serializeBpmn(definitions) {
+    const ns = definitions.namespaces;
+    const bp = bpmnPrefix(ns);
+    const attrs = {};
+    // Namespace declarations
+    for (const [prefix, uri] of Object.entries(ns)) {
+        if (prefix === "") {
+            attrs.xmlns = uri;
+        }
+        else {
+            attrs[`xmlns:${prefix}`] = uri;
+        }
+    }
+    attrs.id = definitions.id;
+    attrs.targetNamespace = definitions.targetNamespace;
+    if (definitions.exporter !== undefined)
+        attrs.exporter = definitions.exporter;
+    if (definitions.exporterVersion !== undefined)
+        attrs.exporterVersion = definitions.exporterVersion;
+    // Unknown attributes (modeler:*, camunda:*, etc.)
+    for (const [key, value] of Object.entries(definitions.unknownAttributes)) {
+        attrs[key] = value;
+    }
+    const children = [];
+    // Root elements: errors, escalations, messages first
+    for (const e of definitions.escalations) {
+        children.push(serializeEscalation(e, bp));
+    }
+    for (const e of definitions.errors) {
+        children.push(serializeError(e, bp));
+    }
+    for (const m of definitions.messages) {
+        children.push(serializeMessage(m, bp));
+    }
+    // Collaborations
+    for (const c of definitions.collaborations) {
+        children.push(serializeCollaboration(c, ns));
+    }
+    // Processes
+    for (const p of definitions.processes) {
+        children.push(serializeProcess(p, ns));
+    }
+    // Diagrams
+    for (const d of definitions.diagrams) {
+        children.push(serializeDiagram(d, ns));
+    }
+    const root = el(`${bp}:definitions`, attrs, children);
+    return serializeXml(root);
+}
+//# sourceMappingURL=bpmn-serializer.js.map

package/dist/bpmn/compact.d.ts

@@ -0,0 +1,91 @@
+import type { BpmnDefinitions, BpmnElementType } from "./bpmn-model.js";
+/** A single BPMN flow node in compact form. */
+export interface CompactElement {
+    id: string;
+    type: BpmnElementType;
+    name?: string;
+    /** Zeebe job type (serviceTask: zeebe:taskDefinition.type) */
+    jobType?: string;
+    /**
+     * Zeebe task headers (key→value).
+     * For the Camunda HTTP connector use jobType "io.camunda:http-json:1" and set:
+     *   url, method, and optionally headers/body/connectionTimeoutInSeconds.
+     */
+    taskHeaders?: Record<string, string>;
+    /** Called process ID (callActivity: zeebe:calledElement.processId) */
+    calledProcess?: string;
+    /** Linked form ID (userTask: zeebe:formDefinition.formId) */
+    formId?: string;
+    /** Linked decision ID (businessRuleTask: zeebe:calledDecision.decisionId) */
+    decisionId?: string;
+    /**
+     * Primary output variable.
+     * - For businessRuleTask: stored in zeebe:calledDecision.resultVariable.
+     * - For serviceTask with jobType: stored as a zeebe:ioMapping output (source "= response").
+     */
+    resultVariable?: string;
+    /** Event definition type (timer, error, message, signal, …) */
+    eventType?: string;
+    /** Boundary event: host element ID */
+    attachedTo?: string;
+    /** Boundary event: false = non-interrupting */
+    interrupting?: boolean;
+}
+/** A sequence flow in compact form. */
+export interface CompactFlow {
+    id: string;
+    from: string;
+    to: string;
+    name?: string;
+    /** FEEL condition expression */
+    condition?: string;
+}
+/** A single process in compact form. */
+export interface CompactProcess {
+    id: string;
+    name?: string;
+    elements: CompactElement[];
+    flows: CompactFlow[];
+}
+/**
+ * Token-efficient representation of a {@link BpmnDefinitions} document.
+ * Produced by {@link compactify}; restored to full form by {@link expand}.
+ */
+export interface CompactDiagram {
+    id: string;
+    processes: CompactProcess[];
+}
+/**
+ * Converts a {@link BpmnDefinitions} model into a token-efficient
+ * {@link CompactDiagram} representation suitable for AI contexts (LLM prompts,
+ * MCP tool calls, etc.). The compact format is typically 5–15× smaller than
+ * raw BPMN XML.
+ *
+ * Use {@link expand} to restore a compact diagram back to a full model with
+ * auto-generated layout.
+ *
+ * @example
+ * ```typescript
+ * import { Bpmn, compactify, expand } from "@bpmnkit/core"
+ *
+ * const defs    = Bpmn.parse(xml)
+ * const compact = compactify(defs)   // send to AI
+ * const restored = expand(compact)   // get back BpmnDefinitions
+ * const xml2    = Bpmn.export(restored)
+ * ```
+ */
+export declare function compactify(defs: BpmnDefinitions): CompactDiagram;
+/**
+ * Restores a {@link CompactDiagram} (produced by {@link compactify} or an AI
+ * model) back to a full {@link BpmnDefinitions} with auto-generated layout.
+ *
+ * @example
+ * ```typescript
+ * const compact = await askAI(prompt)   // AI returns CompactDiagram JSON
+ * const defs    = expand(compact)
+ * const xml     = Bpmn.export(defs)
+ * editor.loadXml(xml)
+ * ```
+ */
+export declare function expand(compact: CompactDiagram): BpmnDefinitions;
+//# sourceMappingURL=compact.d.ts.map