@bpmnkit/core 0.1.1 → 0.2.0

package/dist/bpmn/bpmn-serializer.js

@@ -131,6 +131,42 @@ function serializeExtensionElements(extensions, bp) {
         return [];
     return [el(`${bp}:extensionElements`, {}, extensions)];
 }
+/**
+ * The `documentation` and `extensionElements` children shared by every BPMN
+ * base element, in the order the schema declares them.
+ */
+function serializeBaseChildren(owner, bp) {
+    const children = [];
+    if (owner.documentation !== undefined) {
+        children.push(el(`${bp}:documentation`, {}, [], owner.documentation));
+    }
+    children.push(...serializeExtensionElements(owner.extensionElements ?? [], bp));
+    return children;
+}
+// ---------------------------------------------------------------------------
+// Data associations
+// ---------------------------------------------------------------------------
+function serializeProperty(property, bp) {
+    const attrs = { ...property.unknownAttributes };
+    if (property.id !== undefined)
+        attrs.id = property.id;
+    if (property.name !== undefined)
+        attrs.name = property.name;
+    if (property.itemSubjectRef !== undefined)
+        attrs.itemSubjectRef = property.itemSubjectRef;
+    return el(`${bp}:property`, attrs, []);
+}
+function serializeDataAssociation(association, tag, bp) {
+    const attrs = { ...association.unknownAttributes };
+    if (association.id !== undefined)
+        attrs.id = association.id;
+    const children = association.sourceRefs.map((ref) => el(`${bp}:sourceRef`, {}, [], ref));
+    if (association.targetRef !== undefined) {
+        children.push(el(`${bp}:targetRef`, {}, [], association.targetRef));
+    }
+    children.push(...(association.unknownChildren ?? []));
+    return el(`${bp}:${tag}`, attrs, children);
+}
 // ---------------------------------------------------------------------------
 // Multi-instance loop
 // ---------------------------------------------------------------------------
@@ -140,11 +176,15 @@ function serializeLoopCharacteristics(lc, bp) {
     const attrs = {};
     if (lc.isSequential)
         attrs.isSequential = "true";
-    return [
-        el(`${bp}:multiInstanceLoopCharacteristics`, attrs, [
-            ...serializeExtensionElements(lc.extensionElements, bp),
-        ]),
-    ];
+    const children = [...serializeExtensionElements(lc.extensionElements, bp)];
+    if (lc.loopCardinality) {
+        children.push(el(`${bp}:loopCardinality`, lc.loopCardinality.attributes, [], lc.loopCardinality.text));
+    }
+    if (lc.completionCondition) {
+        children.push(el(`${bp}:completionCondition`, lc.completionCondition.attributes, [], lc.completionCondition.text));
+    }
+    children.push(...(lc.unknownChildren ?? []));
+    return [el(`${bp}:multiInstanceLoopCharacteristics`, attrs, children)];
 }
 // ---------------------------------------------------------------------------
 // Flow elements
@@ -169,6 +209,17 @@ function serializeFlowElement(fe, ns) {
     // Incoming / outgoing
     children.push(...flowRefs(fe.incoming, "incoming", bp));
     children.push(...flowRefs(fe.outgoing, "outgoing", bp));
+    // Data wiring
+    for (const property of fe.properties ?? []) {
+        children.push(serializeProperty(property, bp));
+    }
+    for (const association of fe.dataInputAssociations ?? []) {
+        children.push(serializeDataAssociation(association, "dataInputAssociation", bp));
+    }
+    for (const association of fe.dataOutputAssociations ?? []) {
+        children.push(serializeDataAssociation(association, "dataOutputAssociation", bp));
+    }
+    children.push(...(fe.unknownChildren ?? []));
     switch (fe.type) {
         case "startEvent":
             if (fe.isInterrupting === false)
@@ -202,8 +253,14 @@ function serializeFlowElement(fe, ns) {
             children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
             break;
         case "adHocSubProcess":
+            if (fe.cancelRemainingInstances !== undefined) {
+                attrs.cancelRemainingInstances = String(fe.cancelRemainingInstances);
+            }
             children.push(...serializeLoopCharacteristics(fe.loopCharacteristics, bp));
             children.push(...serializeProcessContents(fe, ns));
+            if (fe.completionCondition) {
+                children.push(el(`${bp}:completionCondition`, fe.completionCondition.attributes, [], fe.completionCondition.text));
+            }
             break;
         case "subProcess":
             if (fe.triggeredByEvent !== undefined)
@@ -272,8 +329,22 @@ function serializeSequenceFlow(sf, bp) {
 // ---------------------------------------------------------------------------
 // Annotations
 // ---------------------------------------------------------------------------
+function serializeCategory(category, bp) {
+    const attrs = { ...category.unknownAttributes };
+    if (category.id !== undefined)
+        attrs.id = category.id;
+    if (category.name !== undefined)
+        attrs.name = category.name;
+    const children = category.categoryValues.map((value) => {
+        const valueAttrs = { id: value.id, ...value.unknownAttributes };
+        if (value.value !== undefined)
+            valueAttrs.value = value.value;
+        return el(`${bp}:categoryValue`, valueAttrs, []);
+    });
+    return el(`${bp}:category`, attrs, children);
+}
 function serializeTextAnnotation(ta, bp) {
-    const children = [];
+    const children = serializeBaseChildren(ta, bp);
     if (ta.text !== undefined) {
         children.push(el(`${bp}:text`, {}, [], ta.text));
     }
@@ -288,13 +359,13 @@ function serializeAssociation(a, bp) {
     };
     if (a.associationDirection !== undefined)
         attrs.associationDirection = a.associationDirection;
-    return el(`${bp}:association`, attrs, []);
+    return el(`${bp}:association`, attrs, serializeBaseChildren(a, bp));
 }
 function serializeGroup(g, bp) {
     const attrs = { id: g.id, ...g.unknownAttributes };
     if (g.categoryValueRef !== undefined)
         attrs.categoryValueRef = g.categoryValueRef;
-    return el(`${bp}:group`, attrs, []);
+    return el(`${bp}:group`, attrs, serializeBaseChildren(g, bp));
 }
 // ---------------------------------------------------------------------------
 // Process contents
@@ -327,16 +398,19 @@ 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));
+    const children = serializeBaseChildren(lane, bp);
+    children.push(...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 = {};
+    const attrs = { ...laneSet.unknownAttributes };
     if (laneSet.id)
         attrs.id = laneSet.id;
+    if (laneSet.name !== undefined)
+        attrs.name = laneSet.name;
     return el(`${bp}:laneSet`, attrs, laneSet.lanes.map((l) => serializeLane(l, bp)));
 }
 // ---------------------------------------------------------------------------
@@ -349,12 +423,12 @@ function serializeProcess(process, ns) {
         attrs.name = process.name;
     if (process.isExecutable)
         attrs.isExecutable = "true";
-    const children = [];
-    children.push(...serializeExtensionElements(process.extensionElements, bp));
+    const children = serializeBaseChildren({ documentation: process.documentation, extensionElements: process.extensionElements }, bp);
     if (process.laneSet) {
         children.push(serializeLaneSet(process.laneSet, bp));
     }
     children.push(...serializeProcessContents(process, ns));
+    children.push(...(process.unknownChildren ?? []));
     return el(`${bp}:process`, attrs, children);
 }
 // ---------------------------------------------------------------------------
@@ -366,7 +440,7 @@ function serializeParticipant(p, bp) {
         attrs.name = p.name;
     if (p.processRef !== undefined)
         attrs.processRef = p.processRef;
-    return el(`${bp}:participant`, attrs, []);
+    return el(`${bp}:participant`, attrs, serializeBaseChildren(p, bp));
 }
 function serializeMessageFlow(mf, bp) {
     const attrs = {
@@ -377,11 +451,13 @@ function serializeMessageFlow(mf, bp) {
     };
     if (mf.name !== undefined)
         attrs.name = mf.name;
-    return el(`${bp}:messageFlow`, attrs, []);
+    if (mf.messageRef !== undefined)
+        attrs.messageRef = mf.messageRef;
+    return el(`${bp}:messageFlow`, attrs, serializeBaseChildren(mf, bp));
 }
 function serializeCollaboration(c, ns) {
     const bp = bpmnPrefix(ns);
-    const children = [];
+    const children = serializeBaseChildren(c, bp);
     for (const p of c.participants) {
         children.push(serializeParticipant(p, bp));
     }
@@ -397,6 +473,7 @@ function serializeCollaboration(c, ns) {
     for (const g of c.groups ?? []) {
         children.push(serializeGroup(g, bp));
     }
+    children.push(...(c.unknownChildren ?? []));
     return el(`${bp}:collaboration`, { id: c.id, ...c.unknownAttributes }, children);
 }
 // ---------------------------------------------------------------------------
@@ -408,7 +485,7 @@ function serializeError(e, bp) {
         attrs.name = e.name;
     if (e.errorCode !== undefined)
         attrs.errorCode = e.errorCode;
-    return el(`${bp}:error`, attrs, []);
+    return el(`${bp}:error`, { ...e.unknownAttributes, ...attrs }, serializeBaseChildren(e, bp));
 }
 function serializeEscalation(e, bp) {
     const attrs = { id: e.id };
@@ -416,19 +493,19 @@ function serializeEscalation(e, bp) {
         attrs.name = e.name;
     if (e.escalationCode !== undefined)
         attrs.escalationCode = e.escalationCode;
-    return el(`${bp}:escalation`, attrs, []);
+    return el(`${bp}:escalation`, { ...e.unknownAttributes, ...attrs }, serializeBaseChildren(e, bp));
 }
 function serializeMessage(m, bp) {
     const attrs = { id: m.id, ...m.unknownAttributes };
     if (m.name !== undefined)
         attrs.name = m.name;
-    return el(`${bp}:message`, attrs, []);
+    return el(`${bp}:message`, attrs, serializeBaseChildren(m, bp));
 }
 function serializeSignal(s, bp) {
     const attrs = { id: s.id };
     if (s.name !== undefined)
         attrs.name = s.name;
-    return el(`${bp}:signal`, attrs, []);
+    return el(`${bp}:signal`, { ...s.unknownAttributes, ...attrs }, serializeBaseChildren(s, bp));
 }
 // ---------------------------------------------------------------------------
 // Diagram interchange
@@ -533,6 +610,17 @@ export function serializeBpmn(definitions) {
         attrs[key] = value;
     }
     const children = [];
+    if (definitions.documentation !== undefined) {
+        children.push(el(`${bp}:documentation`, {}, [], definitions.documentation));
+    }
+    // Categories supply the labels groups reference
+    for (const category of definitions.categories ?? []) {
+        children.push(serializeCategory(category, bp));
+    }
+    // Unmodelled children first: `import` and `extension` precede the root
+    // elements in the schema, and the rest are root elements themselves, so they
+    // sit legally alongside the modelled ones.
+    children.push(...(definitions.unknownChildren ?? []));
     // Root elements: errors, escalations, messages, signals first
     for (const e of definitions.escalations) {
         children.push(serializeEscalation(e, bp));

package/dist/bpmn/compact.d.ts

@@ -1,4 +1,5 @@
-import type { BpmnDefinitions, BpmnElementType } from "./bpmn-model.js";
+import type { XmlElement } from "../types/xml-element.js";
+import type { BpmnDefinitions, BpmnElementType, BpmnEventDefinition, BpmnFlowElement } from "./bpmn-model.js";
 /** A single BPMN flow node in compact form. */
 export interface CompactElement {
     id: string;
@@ -54,7 +55,18 @@ export interface CompactProcess {
 }
 /**
  * Token-efficient representation of a {@link BpmnDefinitions} document.
- * Produced by {@link compactify}; restored to full form by {@link expand}.
+ *
+ * **A read-only view, not a model.** It carries topology, names and the common
+ * Zeebe bindings and drops everything else — collaborations, participants,
+ * message flows, lanes, data stores, artifacts, root-level messages and errors,
+ * multi-instance loop characteristics, full `zeebe:ioMapping` entries and the
+ * diagram. Use it to show a model to a language model, and
+ * {@link expand} to build a *new* model from one.
+ *
+ * Do not use it as an edit path for a file you need to keep:
+ * `expand(compactify(defs))` is not `defs`. Edit the {@link BpmnDefinitions}
+ * instead — `applyBpmnOperations` applies the same operation vocabulary to the
+ * full model without going through this projection.
  */
 export interface CompactDiagram {
     id: string;
@@ -80,6 +92,9 @@ export interface CompactDiagram {
  * ```
  */
 export declare function compactify(defs: BpmnDefinitions): CompactDiagram;
+export declare function makeEventDef(eventType: string): BpmnEventDefinition | undefined;
+export declare function makeExtensions(el: CompactElement): XmlElement[];
+export declare function buildFlowElement(el: CompactElement, incoming: string[], outgoing: string[]): BpmnFlowElement;
 /**
  * Restores a {@link CompactDiagram} (produced by {@link compactify} or an AI
  * model) back to a full {@link BpmnDefinitions} with auto-generated layout.

package/dist/bpmn/compact.js

@@ -112,7 +112,7 @@ export function compactify(defs) {
     };
 }
 // ── Expand ───────────────────────────────────────────────────────────────────
-function makeEventDef(eventType) {
+export function makeEventDef(eventType) {
     switch (eventType) {
         case "timer":
             return { type: "timer" };
@@ -138,7 +138,7 @@ function makeEventDef(eventType) {
             return undefined;
     }
 }
-function makeExtensions(el) {
+export function makeExtensions(el) {
     const ext = [];
     if (el.jobType) {
         ext.push({ name: "zeebe:taskDefinition", attributes: { type: el.jobType }, children: [] });
@@ -226,7 +226,7 @@ function buildSubContent(children) {
         groups: [],
     };
 }
-function buildFlowElement(el, incoming, outgoing) {
+export function buildFlowElement(el, incoming, outgoing) {
     const base = {
         id: el.id,
         name: el.name,

package/dist/bpmn/full-operations.d.ts

@@ -0,0 +1,89 @@
+import type { BpmnDefinitions } from "./bpmn-model.js";
+import { type CompactDiagram } from "./compact.js";
+import type { BpmnOperation } from "./operations.js";
+/**
+ * Applies the {@link BpmnOperation} vocabulary directly to a
+ * {@link BpmnDefinitions}.
+ *
+ * The operations were originally applied to a `CompactDiagram`, which meant
+ * every edit round-tripped the model through a projection that models about
+ * fifteen properties — so editing a task's name silently discarded the
+ * document's pools, lanes, data associations and `zeebe:ioMapping` detail.
+ * Applying the same operations here touches only what an operation names and
+ * leaves the rest of the element untouched.
+ *
+ * Unresolved ids are reported rather than ignored. The original implementation
+ * skipped any operation whose target did not exist, so a patch with a
+ * misspelled id reported success and changed nothing.
+ */
+/** An operation that could not be applied, and why. */
+export interface OperationProblem {
+    /** Position in the operation list, so a caller can point at the offender. */
+    index: number;
+    /** The operation as given. */
+    operation: BpmnOperation;
+    /** What went wrong, in a form worth showing a user. */
+    reason: string;
+}
+export interface ApplyBpmnOperationsResult {
+    /** The edited model. The input is never mutated. */
+    definitions: BpmnDefinitions;
+    /** How many operations took effect. */
+    applied: number;
+    /** Operations that did not, each with a reason. */
+    problems: OperationProblem[];
+}
+export interface ApplyBpmnOperationsOptions {
+    /**
+     * Throw if any operation fails, leaving the model untouched. Default `true`
+     * — silence is what made the previous implementation dangerous.
+     */
+    strict?: boolean;
+}
+/** Thrown by {@link applyBpmnOperations} in strict mode. */
+export declare class OperationError extends Error {
+    readonly problems: OperationProblem[];
+    constructor(problems: OperationProblem[]);
+}
+/**
+ * Applies operations to a copy of the model.
+ *
+ * @param definitions - The model to edit. Never mutated.
+ * @param operations - Operations to apply, in order.
+ * @param options - `strict` (default `true`) throws instead of returning problems.
+ * @returns The edited model, how many operations landed, and what did not.
+ * @throws {OperationError} In strict mode, when any operation fails. Nothing is
+ *   applied — the caller's model and the returned one are both untouched.
+ *
+ * @example
+ * ```typescript
+ * import { applyBpmnOperations } from "@bpmnkit/core"
+ *
+ * const { definitions } = applyBpmnOperations(parsed, [
+ *   { op: "rename", id: "Task_1", name: "Approve invoice" },
+ * ])
+ * ```
+ */
+export declare function applyBpmnOperations(definitions: BpmnDefinitions, operations: readonly BpmnOperation[], options?: ApplyBpmnOperationsOptions): ApplyBpmnOperationsResult;
+/**
+ * Applies a {@link CompactDiagram} onto an existing model as a set of changes,
+ * rather than expanding it into a replacement.
+ *
+ * `expand(compact)` builds a whole new model from about fifteen properties per
+ * element, so using it to apply an edit destroys everything the compact form
+ * does not carry. This walks the same input as a description of the intended
+ * topology and turns it into {@link BpmnOperation}s: elements that already exist
+ * are patched in place and keep their extensions, new ones are inserted, and
+ * ones the input no longer mentions are removed.
+ *
+ * Processes are only ever added, never removed — a caller sending one process of
+ * a multi-process document means "this is how that process should look", not
+ * "delete the others".
+ *
+ * @param definitions - The model to update. Never mutated.
+ * @param compact - The intended topology.
+ * @param options - `strict` (default `true`) throws instead of returning problems.
+ * @returns The updated model, plus what applied and what did not.
+ */
+export declare function reconcileCompact(definitions: BpmnDefinitions, compact: CompactDiagram, options?: ApplyBpmnOperationsOptions): ApplyBpmnOperationsResult;
+//# sourceMappingURL=full-operations.d.ts.map