@bpmnkit/core 1.14.0 → 1.16.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/AGENTS.md +5 -4
- package/agent-cards/bpmn.md +86 -80
- package/builder-reference.md +27 -8
- package/dist/bpmn/auto-layout.js +235 -42
- package/dist/bpmn/bpmn-builder.d.ts +171 -17
- package/dist/bpmn/bpmn-builder.js +792 -135
- package/dist/bpmn/bpmn-model.d.ts +15 -0
- package/dist/bpmn/bpmn-parser.js +32 -6
- package/dist/bpmn/bpmn-serializer.js +9 -2
- package/dist/bpmn/compact-stream.d.ts +7 -0
- package/dist/bpmn/compact-stream.js +7 -0
- package/dist/bpmn/compact.d.ts +126 -9
- package/dist/bpmn/compact.js +305 -30
- package/dist/bpmn/full-operations.d.ts +19 -0
- package/dist/bpmn/full-operations.js +191 -7
- package/dist/bpmn/make-room.d.ts +26 -0
- package/dist/bpmn/make-room.js +151 -0
- package/dist/bpmn/optimize/flow.js +8 -0
- package/dist/bpmn/place-new-shapes.d.ts +6 -1
- package/dist/bpmn/place-new-shapes.js +53 -2
- package/dist/bpmn/preserving-writer.d.ts +1 -1
- package/dist/bpmn/preserving-writer.js +1 -1
- package/dist/bpmn/process-delta.d.ts +32 -1
- package/dist/bpmn/process-delta.js +62 -1
- package/dist/bpmn/process-text-writer.d.ts +18 -7
- package/dist/bpmn/process-text-writer.js +105 -22
- package/dist/bpmn/process-text.d.ts +34 -2
- package/dist/bpmn/process-text.js +410 -7
- package/dist/bpmn/swimlanes.d.ts +178 -0
- package/dist/bpmn/swimlanes.js +774 -0
- package/dist/form/user-task-forms.d.ts +45 -0
- package/dist/form/user-task-forms.js +129 -0
- package/dist/index.d.ts +9 -4
- package/dist/index.js +5 -2
- package/dist/layout/collaboration/message-labels.d.ts +25 -0
- package/dist/layout/collaboration/message-labels.js +108 -0
- package/dist/layout/collaboration/ordering.d.ts +5 -1
- package/dist/layout/collaboration/ordering.js +24 -9
- package/dist/layout/semantic/graph.js +3 -0
- package/dist/layout/semantic/place.d.ts +2 -0
- package/dist/layout/semantic/place.js +77 -9
- package/dist/xml/xml-patch.d.ts +1 -1
- package/llms.txt +1 -1
- package/package.json +2 -2
package/dist/bpmn/compact.js
CHANGED
|
@@ -1,11 +1,12 @@
|
|
|
1
1
|
import { packAnnotations } from "../layout/annotations.js";
|
|
2
2
|
import { layoutProcess } from "../layout/index.js";
|
|
3
3
|
import { assertBpmnDefinitions, assertCompactDiagram } from "./argument-guards.js";
|
|
4
|
-
import { addAnnotationShapes } from "./auto-layout.js";
|
|
4
|
+
import { addAnnotationShapes, applyAutoLayout } from "./auto-layout.js";
|
|
5
5
|
import { normalizeCamundaVersion } from "./camunda-compat.js";
|
|
6
6
|
import { toFeelCondition } from "./feel-condition.js";
|
|
7
7
|
import { restConnectorTaskType } from "./rest-connector.js";
|
|
8
8
|
import { assignEventDefinitionIds, rootDefinitionId } from "./stable-ids.js";
|
|
9
|
+
import { assignLane, buildLaneSet, collaborationProblems, laneForNewNode, laneOf, poolLanedProcesses, primaryProcess, revisitMessage, } from "./swimlanes.js";
|
|
9
10
|
import { makeConditionalDefinition, zeebeExtensionsToXmlElements } from "./zeebe-extensions.js";
|
|
10
11
|
import { assertDeployable } from "./zeebe-validate/gate.js";
|
|
11
12
|
// ── Default flows ────────────────────────────────────────────────────────────
|
|
@@ -302,17 +303,83 @@ function compactifyFlows(elements, sequenceFlows) {
|
|
|
302
303
|
*/
|
|
303
304
|
export function compactify(defs) {
|
|
304
305
|
assertBpmnDefinitions(defs, "compactify");
|
|
306
|
+
const pooled = defs.collaborations.length > 0 || defs.processes.some((p) => p.laneSet);
|
|
307
|
+
const primary = primaryProcess(defs);
|
|
308
|
+
const collaboration = defs.collaborations[0];
|
|
309
|
+
const participants = (collaboration?.participants ?? []).map(compactifyParticipant);
|
|
310
|
+
const messageFlows = (collaboration?.messageFlows ?? []).map(compactifyMessageFlow);
|
|
305
311
|
return {
|
|
306
312
|
id: defs.id,
|
|
307
|
-
processes: defs.processes.map((process) =>
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
313
|
+
processes: defs.processes.map((process) => {
|
|
314
|
+
const lanes = compactifyLanes(process);
|
|
315
|
+
// Flowable reads an absent isExecutable as true. Every non-primary pool says
|
|
316
|
+
// what it is, because expand gives only the first keyless pool the default.
|
|
317
|
+
const executable = process.isExecutable !== false;
|
|
318
|
+
const written = !executable || (pooled && process !== primary);
|
|
319
|
+
return {
|
|
320
|
+
id: process.id,
|
|
321
|
+
name: process.name,
|
|
322
|
+
documentation: process.documentation,
|
|
323
|
+
...(written ? { executable } : {}),
|
|
324
|
+
...(lanes.length > 0 ? { lanes } : {}),
|
|
325
|
+
elements: process.flowElements.map((el) => compactifyElement(el, defs)),
|
|
326
|
+
flows: compactifyFlows(process.flowElements, process.sequenceFlows),
|
|
327
|
+
};
|
|
328
|
+
}),
|
|
329
|
+
...(participants.length > 0 ? { participants } : {}),
|
|
330
|
+
...(messageFlows.length > 0 ? { messageFlows } : {}),
|
|
314
331
|
};
|
|
315
332
|
}
|
|
333
|
+
/** Element types that are not flow nodes: they sit in no lane. */
|
|
334
|
+
export const DATA_ELEMENT_TYPES = new Set([
|
|
335
|
+
"dataObject",
|
|
336
|
+
"dataObjectReference",
|
|
337
|
+
"dataStoreReference",
|
|
338
|
+
]);
|
|
339
|
+
/**
|
|
340
|
+
* The lane tree of `process`, members on leaves only. A member is kept only
|
|
341
|
+
* when it is a top-level flow node, so what `expand` would refuse (a dangling
|
|
342
|
+
* ref, a data reference, a sub-process child) is not passed on; a parent's own
|
|
343
|
+
* refs, which repeat its children's under the union convention, are dropped.
|
|
344
|
+
*/
|
|
345
|
+
export function compactifyLanes(process) {
|
|
346
|
+
const nodeIds = new Set(process.flowElements.filter((e) => !DATA_ELEMENT_TYPES.has(e.type)).map((e) => e.id));
|
|
347
|
+
const seen = new Set();
|
|
348
|
+
const toCompact = (lane) => {
|
|
349
|
+
if (seen.has(lane))
|
|
350
|
+
throw new Error(`Lane "${lane.id}" appears twice in one lane tree`);
|
|
351
|
+
seen.add(lane);
|
|
352
|
+
const result = { id: lane.id };
|
|
353
|
+
if (lane.name)
|
|
354
|
+
result.name = lane.name;
|
|
355
|
+
const children = lane.childLaneSet?.lanes ?? [];
|
|
356
|
+
if (children.length > 0) {
|
|
357
|
+
result.lanes = children.map(toCompact);
|
|
358
|
+
return result;
|
|
359
|
+
}
|
|
360
|
+
const members = [...new Set(lane.flowNodeRefs)].filter((ref) => nodeIds.has(ref));
|
|
361
|
+
if (members.length > 0)
|
|
362
|
+
result.members = members;
|
|
363
|
+
return result;
|
|
364
|
+
};
|
|
365
|
+
return (process.laneSet?.lanes ?? []).map(toCompact);
|
|
366
|
+
}
|
|
367
|
+
/** A pool as compact writes it; a black box has no `processId`. */
|
|
368
|
+
export function compactifyParticipant(participant) {
|
|
369
|
+
const result = { id: participant.id };
|
|
370
|
+
if (participant.name)
|
|
371
|
+
result.name = participant.name;
|
|
372
|
+
if (participant.processRef !== undefined)
|
|
373
|
+
result.processId = participant.processRef;
|
|
374
|
+
return result;
|
|
375
|
+
}
|
|
376
|
+
/** A message flow as compact writes it, with `source`/`target` so streams never read it as a sequence flow. */
|
|
377
|
+
export function compactifyMessageFlow(flow) {
|
|
378
|
+
const result = { id: flow.id, source: flow.sourceRef, target: flow.targetRef };
|
|
379
|
+
if (flow.name)
|
|
380
|
+
result.name = flow.name;
|
|
381
|
+
return result;
|
|
382
|
+
}
|
|
316
383
|
// ── Expand ───────────────────────────────────────────────────────────────────
|
|
317
384
|
const EVENT_TYPES = new Set([
|
|
318
385
|
"timer",
|
|
@@ -391,9 +458,63 @@ function compactProblems(compact) {
|
|
|
391
458
|
problems.push(`a note is on "${note.elementId}", which is not an element in the diagram`);
|
|
392
459
|
}
|
|
393
460
|
}
|
|
461
|
+
problems.push(...compactLaneProblems(process, claim));
|
|
394
462
|
}
|
|
463
|
+
for (const participant of compact.participants ?? [])
|
|
464
|
+
claim(participant.id, "participant");
|
|
465
|
+
for (const flow of compact.messageFlows ?? [])
|
|
466
|
+
claim(flow.id, "message flow");
|
|
467
|
+
return { problems, ids: seen };
|
|
468
|
+
}
|
|
469
|
+
/**
|
|
470
|
+
* What is wrong with the lanes of `process`: a lane tree that loops, members on
|
|
471
|
+
* a lane with child lanes, a member that is not a top-level flow node of this
|
|
472
|
+
* process, and a node listed in two lanes. Lane ids are claimed through `claim`.
|
|
473
|
+
* A node in no lane is not a problem; `expand` places it.
|
|
474
|
+
*/
|
|
475
|
+
function compactLaneProblems(process, claim) {
|
|
476
|
+
const problems = [];
|
|
477
|
+
const nodes = new Map(process.elements.map((element) => [element.id, element]));
|
|
478
|
+
const laneOfMember = new Map();
|
|
479
|
+
const seen = new Set();
|
|
480
|
+
const visit = (lanes) => {
|
|
481
|
+
for (const lane of lanes) {
|
|
482
|
+
if (seen.has(lane)) {
|
|
483
|
+
problems.push(`lane "${lane.id}" appears twice in the lane tree of "${process.id}"`);
|
|
484
|
+
continue;
|
|
485
|
+
}
|
|
486
|
+
seen.add(lane);
|
|
487
|
+
claim(lane.id, "lane");
|
|
488
|
+
const children = lane.lanes ?? [];
|
|
489
|
+
if (children.length > 0 && (lane.members?.length ?? 0) > 0) {
|
|
490
|
+
problems.push(`lane "${lane.id}" has child lanes and members; members go on its leaf lanes`);
|
|
491
|
+
}
|
|
492
|
+
for (const member of lane.members ?? []) {
|
|
493
|
+
const problem = memberProblem(process, lane.id, member, nodes.get(member), laneOfMember);
|
|
494
|
+
if (problem !== undefined)
|
|
495
|
+
problems.push(problem);
|
|
496
|
+
}
|
|
497
|
+
visit(children);
|
|
498
|
+
}
|
|
499
|
+
};
|
|
500
|
+
visit(process.lanes ?? []);
|
|
395
501
|
return problems;
|
|
396
502
|
}
|
|
503
|
+
/** Why `member` cannot sit in lane `laneId`, or `undefined`; records the lane of a valid member. */
|
|
504
|
+
function memberProblem(process, laneId, member, element, laneOfMember) {
|
|
505
|
+
if (element === undefined) {
|
|
506
|
+
return `lane "${laneId}" lists "${member}", which is not a top-level flow node of process "${process.id}"`;
|
|
507
|
+
}
|
|
508
|
+
if (DATA_ELEMENT_TYPES.has(element.type)) {
|
|
509
|
+
return `lane "${laneId}" lists "${member}", a ${element.type}; lanes hold flow nodes only`;
|
|
510
|
+
}
|
|
511
|
+
const other = laneOfMember.get(member);
|
|
512
|
+
if (other !== undefined && other !== laneId) {
|
|
513
|
+
return `"${member}" is in lanes "${other}" and "${laneId}"; a node belongs to one lane`;
|
|
514
|
+
}
|
|
515
|
+
laneOfMember.set(member, laneId);
|
|
516
|
+
return undefined;
|
|
517
|
+
}
|
|
397
518
|
export function makeEventDef(eventType) {
|
|
398
519
|
switch (eventType) {
|
|
399
520
|
case "timer":
|
|
@@ -471,7 +592,11 @@ export function makeExtensions(el) {
|
|
|
471
592
|
const ext = [];
|
|
472
593
|
const { inputs, headers } = zeebeConfig(el);
|
|
473
594
|
if (el.jobType) {
|
|
474
|
-
ext.push({
|
|
595
|
+
ext.push({
|
|
596
|
+
name: "zeebe:taskDefinition",
|
|
597
|
+
attributes: { type: el.jobType, ...(el.retries ? { retries: el.retries } : {}) },
|
|
598
|
+
children: [],
|
|
599
|
+
});
|
|
475
600
|
}
|
|
476
601
|
if (Object.keys(headers).length > 0) {
|
|
477
602
|
ext.push({
|
|
@@ -597,7 +722,10 @@ function buildSubContent(children, roots) {
|
|
|
597
722
|
sourceRef: f.from,
|
|
598
723
|
targetRef: f.to,
|
|
599
724
|
conditionExpression: f.condition
|
|
600
|
-
? {
|
|
725
|
+
? {
|
|
726
|
+
text: toFeelCondition(f.condition),
|
|
727
|
+
attributes: { "xsi:type": "bpmn:tFormalExpression" },
|
|
728
|
+
}
|
|
601
729
|
: undefined,
|
|
602
730
|
extensionElements: [],
|
|
603
731
|
unknownAttributes: {},
|
|
@@ -901,7 +1029,7 @@ function buildDiagram(processId, process) {
|
|
|
901
1029
|
},
|
|
902
1030
|
};
|
|
903
1031
|
}
|
|
904
|
-
function expandProcess(compact, roots) {
|
|
1032
|
+
function expandProcess(compact, isExecutable, roots) {
|
|
905
1033
|
const incoming = new Map();
|
|
906
1034
|
const outgoing = new Map();
|
|
907
1035
|
for (const f of compact.flows) {
|
|
@@ -920,7 +1048,7 @@ function expandProcess(compact, roots) {
|
|
|
920
1048
|
sourceRef: f.from,
|
|
921
1049
|
targetRef: f.to,
|
|
922
1050
|
conditionExpression: f.condition
|
|
923
|
-
? { text: toFeelCondition(f.condition), attributes: {} }
|
|
1051
|
+
? { text: toFeelCondition(f.condition), attributes: { "xsi:type": "bpmn:tFormalExpression" } }
|
|
924
1052
|
: undefined,
|
|
925
1053
|
extensionElements: [],
|
|
926
1054
|
unknownAttributes: {},
|
|
@@ -946,7 +1074,7 @@ function expandProcess(compact, roots) {
|
|
|
946
1074
|
id: compact.id,
|
|
947
1075
|
name: compact.name,
|
|
948
1076
|
documentation: compact.documentation,
|
|
949
|
-
isExecutable
|
|
1077
|
+
isExecutable,
|
|
950
1078
|
extensionElements: [],
|
|
951
1079
|
flowElements,
|
|
952
1080
|
sequenceFlows,
|
|
@@ -955,7 +1083,125 @@ function expandProcess(compact, roots) {
|
|
|
955
1083
|
groups: [],
|
|
956
1084
|
unknownAttributes: {},
|
|
957
1085
|
};
|
|
958
|
-
return
|
|
1086
|
+
return process;
|
|
1087
|
+
}
|
|
1088
|
+
/**
|
|
1089
|
+
* True when the compact describes pools or lanes, which switches `expand` to
|
|
1090
|
+
* the collaboration path: pools, lanes, and a layout of the whole diagram.
|
|
1091
|
+
*/
|
|
1092
|
+
export function isPooled(compact) {
|
|
1093
|
+
return ((compact.participants?.length ?? 0) > 0 ||
|
|
1094
|
+
(compact.messageFlows?.length ?? 0) > 0 ||
|
|
1095
|
+
compact.processes.some((process) => (process.lanes?.length ?? 0) > 0));
|
|
1096
|
+
}
|
|
1097
|
+
/**
|
|
1098
|
+
* `isExecutable` per process of `compact`, in order, by the rule documented on
|
|
1099
|
+
* {@link CompactProcess.executable}. `pooled` is {@link isPooled} of `compact`.
|
|
1100
|
+
*/
|
|
1101
|
+
export function executability(compact, pooled) {
|
|
1102
|
+
let defaultTaken = false;
|
|
1103
|
+
return compact.processes.map((process) => {
|
|
1104
|
+
if (process.executable !== undefined)
|
|
1105
|
+
return process.executable;
|
|
1106
|
+
if (!pooled)
|
|
1107
|
+
return true;
|
|
1108
|
+
const executable = !defaultTaken;
|
|
1109
|
+
defaultTaken = true;
|
|
1110
|
+
return executable;
|
|
1111
|
+
});
|
|
1112
|
+
}
|
|
1113
|
+
/**
|
|
1114
|
+
* `process` with the lane set `lanes` describes, replacing any it had. Members
|
|
1115
|
+
* are taken from leaf lanes only and written verbatim; a node no lane lists goes
|
|
1116
|
+
* in the lane {@link laneForNewNode} picks for it. `lanes` must not loop back
|
|
1117
|
+
* on itself. Returns `process` unchanged when `lanes` is absent or empty.
|
|
1118
|
+
*
|
|
1119
|
+
* @throws Error when `lanes` loops back on itself, or as {@link buildLaneSet} does.
|
|
1120
|
+
*/
|
|
1121
|
+
export function withLanes(process, lanes) {
|
|
1122
|
+
if (lanes === undefined || lanes.length === 0)
|
|
1123
|
+
return process;
|
|
1124
|
+
const leafOf = new Map();
|
|
1125
|
+
// Callers validate first, but this one is exported: a looping tree must fail
|
|
1126
|
+
// as one rather than overflow the stack.
|
|
1127
|
+
const seen = new Set();
|
|
1128
|
+
const collect = (children) => {
|
|
1129
|
+
for (const lane of children) {
|
|
1130
|
+
if (seen.has(lane))
|
|
1131
|
+
throw new Error(revisitMessage(lane.id));
|
|
1132
|
+
seen.add(lane);
|
|
1133
|
+
if ((lane.lanes?.length ?? 0) > 0)
|
|
1134
|
+
collect(lane.lanes ?? []);
|
|
1135
|
+
else
|
|
1136
|
+
for (const member of lane.members ?? [])
|
|
1137
|
+
leafOf.set(member, lane.id);
|
|
1138
|
+
}
|
|
1139
|
+
};
|
|
1140
|
+
collect(lanes);
|
|
1141
|
+
const laned = { ...process, laneSet: buildLaneSet(process, lanes, leafOf) };
|
|
1142
|
+
return fillLanes(laned, process.flowElements.map((element) => element.id));
|
|
1143
|
+
}
|
|
1144
|
+
/**
|
|
1145
|
+
* Puts each of `nodeIds` that is a top-level flow node of laned `process` and in
|
|
1146
|
+
* no lane yet into the lane {@link laneForNewNode} picks, in the order given.
|
|
1147
|
+
* Other ids are skipped. Returns `process` itself when it has no lanes.
|
|
1148
|
+
*/
|
|
1149
|
+
export function fillLanes(process, nodeIds) {
|
|
1150
|
+
if (process.laneSet === undefined)
|
|
1151
|
+
return process;
|
|
1152
|
+
const types = new Map(process.flowElements.map((element) => [element.id, element.type]));
|
|
1153
|
+
let laned = process;
|
|
1154
|
+
// One pass in the order given: an unlisted node whose only neighbours are
|
|
1155
|
+
// later unlisted nodes lands in the first leaf. Models leave single nodes
|
|
1156
|
+
// unlisted, not whole chains; a chain would need passes until nothing moves.
|
|
1157
|
+
for (const id of nodeIds) {
|
|
1158
|
+
const type = types.get(id);
|
|
1159
|
+
if (type === undefined || DATA_ELEMENT_TYPES.has(type) || laneOf(laned, id) !== undefined) {
|
|
1160
|
+
continue;
|
|
1161
|
+
}
|
|
1162
|
+
const lane = laneForNewNode(laned, id);
|
|
1163
|
+
if (lane !== undefined)
|
|
1164
|
+
laned = assignLane(laned, id, lane.id);
|
|
1165
|
+
}
|
|
1166
|
+
return laned;
|
|
1167
|
+
}
|
|
1168
|
+
/**
|
|
1169
|
+
* The first collaboration `compact` describes, under the first free
|
|
1170
|
+
* `Collaboration_<n>` id given the ids already taken. Empty without
|
|
1171
|
+
* participants or message flows.
|
|
1172
|
+
*/
|
|
1173
|
+
export function expandCollaborations(compact, ids) {
|
|
1174
|
+
const participants = compact.participants ?? [];
|
|
1175
|
+
const messageFlows = compact.messageFlows ?? [];
|
|
1176
|
+
if (participants.length === 0 && messageFlows.length === 0)
|
|
1177
|
+
return [];
|
|
1178
|
+
// Bounded: at most ids.size candidates can be taken.
|
|
1179
|
+
let n = 1;
|
|
1180
|
+
while (ids.has(`Collaboration_${n}`) && n <= ids.size)
|
|
1181
|
+
n++;
|
|
1182
|
+
return [
|
|
1183
|
+
{
|
|
1184
|
+
id: `Collaboration_${n}`,
|
|
1185
|
+
participants: participants.map((participant) => ({
|
|
1186
|
+
id: participant.id,
|
|
1187
|
+
name: participant.name,
|
|
1188
|
+
processRef: participant.processId,
|
|
1189
|
+
unknownAttributes: {},
|
|
1190
|
+
})),
|
|
1191
|
+
messageFlows: messageFlows.map((flow) => ({
|
|
1192
|
+
id: flow.id,
|
|
1193
|
+
name: flow.name,
|
|
1194
|
+
sourceRef: flow.source,
|
|
1195
|
+
targetRef: flow.target,
|
|
1196
|
+
unknownAttributes: {},
|
|
1197
|
+
})),
|
|
1198
|
+
textAnnotations: [],
|
|
1199
|
+
associations: [],
|
|
1200
|
+
groups: [],
|
|
1201
|
+
extensionElements: [],
|
|
1202
|
+
unknownAttributes: {},
|
|
1203
|
+
},
|
|
1204
|
+
];
|
|
959
1205
|
}
|
|
960
1206
|
/**
|
|
961
1207
|
* Restores a {@link CompactDiagram} (produced by {@link compactify} or an AI
|
|
@@ -967,9 +1213,19 @@ function expandProcess(compact, roots) {
|
|
|
967
1213
|
* Then `assertDeployable` refuses what Zeebe would reject, unless
|
|
968
1214
|
* `options.validate` is `false`.
|
|
969
1215
|
*
|
|
1216
|
+
* A diagram with lanes, participants or message flows becomes one collaboration:
|
|
1217
|
+
* every process with content gets a pool (a synthesized `Participant_<processId>`
|
|
1218
|
+
* when none names it), and the whole diagram is laid out on one plane bound to
|
|
1219
|
+
* the collaboration. Without them, each process is laid out on its own plane,
|
|
1220
|
+
* exactly as before lanes existed.
|
|
1221
|
+
*
|
|
970
1222
|
* @throws {Error} When the diagram cannot be valid BPMN — a flow or boundary
|
|
971
1223
|
* event naming an element that is not in its scope, a duplicate or missing id,
|
|
972
|
-
*
|
|
1224
|
+
* an unknown `eventType`, or a lane member that is not a top-level flow node of
|
|
1225
|
+
* its process, sits in two lanes or sits on a lane with child lanes. The message
|
|
1226
|
+
* lists every such problem at once. Pool problems (a participant naming a
|
|
1227
|
+
* missing process, a message-flow end in no pool, a message flow inside one
|
|
1228
|
+
* pool) are reported by a second check once those pass.
|
|
973
1229
|
* @throws {DeployabilityError} When the gate runs and Zeebe would reject the model.
|
|
974
1230
|
*
|
|
975
1231
|
* @example
|
|
@@ -982,19 +1238,43 @@ function expandProcess(compact, roots) {
|
|
|
982
1238
|
*/
|
|
983
1239
|
export function expand(compact, options = {}) {
|
|
984
1240
|
assertCompactDiagram(compact, "expand");
|
|
985
|
-
const problems = compactProblems(compact);
|
|
1241
|
+
const { problems, ids } = compactProblems(compact);
|
|
986
1242
|
if (problems.length > 0) {
|
|
987
1243
|
throw new Error(`expand: invalid CompactDiagram — ${problems.join("; ")}`);
|
|
988
1244
|
}
|
|
989
1245
|
const roots = new CompactRoots();
|
|
990
|
-
const
|
|
991
|
-
const
|
|
992
|
-
|
|
993
|
-
const { process, diagram } = expandProcess(cp, roots);
|
|
994
|
-
processes.push(process);
|
|
995
|
-
diagrams.push(diagram);
|
|
996
|
-
}
|
|
1246
|
+
const pooled = isPooled(compact);
|
|
1247
|
+
const executable = executability(compact, pooled);
|
|
1248
|
+
const processes = compact.processes.map((cp, index) => expandProcess(cp, executable[index] ?? true, roots));
|
|
997
1249
|
const gate = options.validate !== false;
|
|
1250
|
+
const defs = expandDefinitions(compact, processes, roots, gate);
|
|
1251
|
+
const definitions = pooled
|
|
1252
|
+
? expandPools(compact, defs, ids)
|
|
1253
|
+
: { ...defs, diagrams: processes.map((process) => buildDiagram(process.id, process)) };
|
|
1254
|
+
if (!gate)
|
|
1255
|
+
return definitions;
|
|
1256
|
+
return assertDeployable(definitions, {
|
|
1257
|
+
camundaVersion: normalizeCamundaVersion(options.camundaVersion ?? compact.executionPlatformVersion),
|
|
1258
|
+
placeholders: options.placeholders ?? false,
|
|
1259
|
+
}).definitions;
|
|
1260
|
+
}
|
|
1261
|
+
/** `defs` with the pools and lanes `compact` describes, laid out on one collaboration plane. */
|
|
1262
|
+
function expandPools(compact, defs, ids) {
|
|
1263
|
+
const withPools = poolLanedProcesses({
|
|
1264
|
+
...defs,
|
|
1265
|
+
collaborations: expandCollaborations(compact, ids),
|
|
1266
|
+
processes: defs.processes.map((process, index) => withLanes(process, compact.processes[index]?.lanes)),
|
|
1267
|
+
});
|
|
1268
|
+
// Checked on the built model: a message flow's ends and a pool's process
|
|
1269
|
+
// can only be judged once every pool, synthesized ones included, exists.
|
|
1270
|
+
const poolProblems = collaborationProblems(withPools);
|
|
1271
|
+
if (poolProblems.length > 0) {
|
|
1272
|
+
throw new Error(`expand: invalid CompactDiagram — ${poolProblems.join("; ")}`);
|
|
1273
|
+
}
|
|
1274
|
+
return applyAutoLayout(withPools);
|
|
1275
|
+
}
|
|
1276
|
+
/** The definitions around `processes`, with no collaborations and no diagram. */
|
|
1277
|
+
function expandDefinitions(compact, processes, roots, gate) {
|
|
998
1278
|
const platform = compact.executionPlatformVersion;
|
|
999
1279
|
// Gated output is Camunda 8 output: marking it so makes `Bpmn.export`'s "auto" check agree.
|
|
1000
1280
|
const camunda8 = gate || platform !== undefined;
|
|
@@ -1019,13 +1299,8 @@ export function expand(compact, options = {}) {
|
|
|
1019
1299
|
signals: roots.signals,
|
|
1020
1300
|
collaborations: [],
|
|
1021
1301
|
processes,
|
|
1022
|
-
diagrams,
|
|
1302
|
+
diagrams: [],
|
|
1023
1303
|
};
|
|
1024
|
-
|
|
1025
|
-
return definitions;
|
|
1026
|
-
return assertDeployable(definitions, {
|
|
1027
|
-
camundaVersion: normalizeCamundaVersion(options.camundaVersion ?? platform),
|
|
1028
|
-
placeholders: options.placeholders ?? false,
|
|
1029
|
-
}).definitions;
|
|
1304
|
+
return definitions;
|
|
1030
1305
|
}
|
|
1031
1306
|
//# sourceMappingURL=compact.js.map
|
|
@@ -80,10 +80,29 @@ export declare function applyBpmnOperations(definitions: BpmnDefinitions, operat
|
|
|
80
80
|
* a multi-process document means "this is how that process should look", not
|
|
81
81
|
* "delete the others".
|
|
82
82
|
*
|
|
83
|
+
* Lanes, pools and executability follow the same rule: a key the compact leaves
|
|
84
|
+
* out leaves that part of the model alone. A process's `lanes` rebuilds its
|
|
85
|
+
* membership (an empty list removes the lane set), keeping the attributes and
|
|
86
|
+
* extensions of every lane whose id survives; members that are not top-level
|
|
87
|
+
* flow nodes are dropped and unlisted nodes are placed as {@link expand} places
|
|
88
|
+
* them. `participants` and `messageFlows` replace those of the first
|
|
89
|
+
* collaboration, keeping what the compact form does not carry (`messageRef`,
|
|
90
|
+
* extensions, foreign attributes) on every id that survives. A lane, pool or
|
|
91
|
+
* message flow listed without a `name` has none, as {@link compactify} writes
|
|
92
|
+
* it, so a compact edit can remove a name. A laned process
|
|
93
|
+
* without a pool then gets one. A process the compact adds gets the
|
|
94
|
+
* `isExecutable` {@link expand} would give it, so a keyless partner pool is
|
|
95
|
+
* not executable. Without the keys, a deleted node still leaves
|
|
96
|
+
* its lanes and message flows, and an inserted one joins its predecessor's lane.
|
|
97
|
+
*
|
|
83
98
|
* @param definitions - The model to update. Never mutated.
|
|
84
99
|
* @param compact - The intended topology.
|
|
85
100
|
* @param options - `strict` (default `true`) throws instead of returning problems.
|
|
86
101
|
* @returns The updated model, plus what applied and what did not.
|
|
102
|
+
* @throws Error, in either mode, when the result would carry an id used twice
|
|
103
|
+
* or a collaboration problem (a dangling message end or process reference, a
|
|
104
|
+
* message inside one pool) that `definitions` did not already have: the
|
|
105
|
+
* input is invalid, as {@link expand} would find it.
|
|
87
106
|
*/
|
|
88
107
|
export declare function reconcileCompact(definitions: BpmnDefinitions, compact: CompactDiagram, options?: ApplyBpmnOperationsOptions): ApplyBpmnOperationsResult;
|
|
89
108
|
//# sourceMappingURL=full-operations.d.ts.map
|