@aranzatech/diagrams-bpmn 0.1.3 → 0.2.1

package/dist/modeling/index.cjs

@@ -0,0 +1,1241 @@
+'use strict';
+
+var diagramsCore = require('@aranzatech/diagrams-core');
+var serialization = require('@aranzatech/diagrams-core/serialization');
+
+// src/modeling/index.ts
+
+// src/elements/catalog.ts
+var BPMN_ELEMENT_CATALOG = {
+  // ─── Events ──────────────────────────────────────────────────────────────────
+  StartEvent: {
+    label: "Start Event",
+    icon: "Circle",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "source",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "start",
+    canBeStart: true,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 1
+  },
+  EndEvent: {
+    label: "End Event",
+    icon: "CircleDot",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "target",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "end",
+    canBeStart: false,
+    canBeEnd: true,
+    maxOutgoing: 0
+  },
+  IntermediateCatchEvent: {
+    label: "Intermediate Catch Event",
+    icon: "Clock3",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateCatch",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  IntermediateThrowEvent: {
+    label: "Intermediate Throw Event",
+    icon: "Send",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "intermediateThrow",
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BoundaryEvent: {
+    label: "Boundary Event",
+    icon: "AlarmClock",
+    category: "event",
+    defaultWidth: 36,
+    defaultHeight: 36,
+    handlePolicy: "source",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    eventSemantics: "boundary",
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  // ─── Tasks ───────────────────────────────────────────────────────────────────
+  Task: {
+    label: "Task",
+    icon: "CheckSquare",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  UserTask: {
+    label: "User Task",
+    icon: "UserRound",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ServiceTask: {
+    label: "Service Task",
+    icon: "Cog",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ScriptTask: {
+    label: "Script Task",
+    icon: "FileCode",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ManualTask: {
+    label: "Manual Task",
+    icon: "Hand",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  BusinessRuleTask: {
+    label: "Business Rule Task",
+    icon: "Table2",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ReceiveTask: {
+    label: "Receive Task",
+    icon: "Inbox",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SendTask: {
+    label: "Send Task",
+    icon: "Send",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallActivity: {
+    label: "Call Activity",
+    icon: "ExternalLink",
+    category: "task",
+    defaultWidth: 120,
+    defaultHeight: 60,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Gateways ────────────────────────────────────────────────────────────────
+  ExclusiveGateway: {
+    label: "Exclusive Gateway",
+    icon: "X",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  InclusiveGateway: {
+    label: "Inclusive Gateway",
+    icon: "Circle",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  ParallelGateway: {
+    label: "Parallel Gateway",
+    icon: "Plus",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventBasedGateway: {
+    label: "Event-Based Gateway",
+    icon: "Radio",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 1
+  },
+  ComplexGateway: {
+    label: "Complex Gateway",
+    icon: "Asterisk",
+    category: "gateway",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Containers ───────────────────────────────────────────────────────────────
+  SubProcess: {
+    label: "Sub-Process",
+    icon: "PlusSquare",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  Transaction: {
+    label: "Transaction",
+    icon: "Receipt",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  EventSubProcess: {
+    label: "Event Sub-Process",
+    icon: "CircleDotDashed",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  AdHocSubProcess: {
+    label: "Ad-Hoc Sub-Process",
+    icon: "Waves",
+    category: "container",
+    defaultWidth: 350,
+    defaultHeight: 200,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: true,
+    supportsCollapse: true,
+    supportsMarkers: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  Pool: {
+    label: "Pool",
+    icon: "Rows3",
+    category: "container",
+    defaultWidth: 600,
+    defaultHeight: 200,
+    handlePolicy: "none",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  Lane: {
+    label: "Lane",
+    icon: "PanelTop",
+    category: "container",
+    defaultWidth: 600,
+    defaultHeight: 120,
+    handlePolicy: "none",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Artifacts ────────────────────────────────────────────────────────────────
+  Annotation: {
+    label: "Text Annotation",
+    icon: "StickyNote",
+    category: "artifact",
+    defaultWidth: 100,
+    defaultHeight: 60,
+    handlePolicy: "none",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  Group: {
+    label: "Group",
+    icon: "Group",
+    category: "artifact",
+    defaultWidth: 300,
+    defaultHeight: 200,
+    handlePolicy: "none",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Data (BPMN 2.0 §10.3) ───────────────────────────────────────────────────
+  DataObject: {
+    label: "Data Object",
+    icon: "File",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataObjectReference: {
+    label: "Data Object Reference",
+    icon: "FileSymlink",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataInput: {
+    label: "Data Input",
+    icon: "FileInput",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0
+  },
+  DataOutput: {
+    label: "Data Output",
+    icon: "FileOutput",
+    category: "data",
+    defaultWidth: 36,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxOutgoing: 0
+  },
+  DataStore: {
+    label: "Data Store",
+    icon: "Database",
+    category: "data",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  DataStoreReference: {
+    label: "Data Store Reference",
+    icon: "DatabaseZap",
+    category: "data",
+    defaultWidth: 50,
+    defaultHeight: 50,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false,
+    maxIncoming: 0,
+    maxOutgoing: 0
+  },
+  // ─── Conversation (BPMN 2.0 §12) ─────────────────────────────────────────────
+  Conversation: {
+    label: "Conversation",
+    icon: "MessageCircle",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubConversation: {
+    label: "Sub-Conversation",
+    icon: "MessagesSquare",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallConversation: {
+    label: "Call Conversation",
+    icon: "PhoneCall",
+    category: "conversation",
+    defaultWidth: 60,
+    defaultHeight: 52,
+    handlePolicy: "all",
+    orientation: "free",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  // ─── Choreography (BPMN 2.0 §11) ─────────────────────────────────────────────
+  ChoreographyTask: {
+    label: "Choreography Task",
+    icon: "ArrowLeftRight",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  SubChoreography: {
+    label: "Sub-Choreography",
+    icon: "BoxSelect",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: true,
+    acceptsBoundaryEvents: false,
+    supportsCollapse: true,
+    canBeStart: false,
+    canBeEnd: false
+  },
+  CallChoreography: {
+    label: "Call Choreography",
+    icon: "Phone",
+    category: "choreography",
+    defaultWidth: 120,
+    defaultHeight: 80,
+    handlePolicy: "all",
+    orientation: "horizontal",
+    isContainer: false,
+    acceptsBoundaryEvents: false,
+    canBeStart: false,
+    canBeEnd: false
+  }
+};
+function getElementMeta(type) {
+  return BPMN_ELEMENT_CATALOG[type];
+}
+var BPMN_RESIZABLE_ELEMENT_TYPES = [
+  "Task",
+  "UserTask",
+  "ServiceTask",
+  "ScriptTask",
+  "ManualTask",
+  "BusinessRuleTask",
+  "ReceiveTask",
+  "SendTask",
+  "CallActivity",
+  "SubProcess",
+  "Transaction",
+  "EventSubProcess",
+  "AdHocSubProcess",
+  "Pool",
+  "Lane",
+  "Annotation",
+  "Group",
+  "SubConversation",
+  "ChoreographyTask",
+  "SubChoreography",
+  "CallChoreography"
+];
+var BPMN_MIN_SIZE_OVERRIDES = {
+  Task: { minWidth: 80, minHeight: 48 },
+  UserTask: { minWidth: 80, minHeight: 48 },
+  ServiceTask: { minWidth: 80, minHeight: 48 },
+  ScriptTask: { minWidth: 80, minHeight: 48 },
+  ManualTask: { minWidth: 80, minHeight: 48 },
+  BusinessRuleTask: { minWidth: 80, minHeight: 48 },
+  ReceiveTask: { minWidth: 80, minHeight: 48 },
+  SendTask: { minWidth: 80, minHeight: 48 },
+  CallActivity: { minWidth: 80, minHeight: 48 },
+  SubProcess: { minWidth: 160, minHeight: 100 },
+  Transaction: { minWidth: 160, minHeight: 100 },
+  EventSubProcess: { minWidth: 160, minHeight: 100 },
+  AdHocSubProcess: { minWidth: 160, minHeight: 100 },
+  Pool: { minWidth: 240, minHeight: 120 },
+  Lane: { minWidth: 240, minHeight: 80 },
+  Annotation: { minWidth: 80, minHeight: 40 },
+  Group: { minWidth: 120, minHeight: 80 },
+  SubConversation: { minWidth: 60, minHeight: 52 },
+  ChoreographyTask: { minWidth: 100, minHeight: 70 },
+  SubChoreography: { minWidth: 100, minHeight: 70 },
+  CallChoreography: { minWidth: 100, minHeight: 70 }
+};
+var resizableTypes = new Set(BPMN_RESIZABLE_ELEMENT_TYPES);
+function isBpmnElementResizable(type) {
+  return resizableTypes.has(type);
+}
+function getBpmnElementSize(type) {
+  const meta = getElementMeta(type);
+  const min = BPMN_MIN_SIZE_OVERRIDES[type];
+  return {
+    width: meta.defaultWidth,
+    height: meta.defaultHeight,
+    minWidth: meta.minWidth ?? min?.minWidth ?? meta.defaultWidth,
+    minHeight: meta.minHeight ?? min?.minHeight ?? meta.defaultHeight,
+    resizable: meta.resizable ?? isBpmnElementResizable(type)
+  };
+}
+
+// src/elements/guards.ts
+var GATEWAY_TYPES = /* @__PURE__ */ new Set([
+  "ExclusiveGateway",
+  "InclusiveGateway",
+  "ParallelGateway",
+  "EventBasedGateway",
+  "ComplexGateway"
+]);
+var EVENT_TYPES = /* @__PURE__ */ new Set([
+  "StartEvent",
+  "EndEvent",
+  "IntermediateCatchEvent",
+  "IntermediateThrowEvent",
+  "BoundaryEvent"
+]);
+var DATA_TYPES = /* @__PURE__ */ new Set([
+  "DataObject",
+  "DataObjectReference",
+  "DataInput",
+  "DataOutput",
+  "DataStore",
+  "DataStoreReference"
+]);
+function isGatewayType(type) {
+  return GATEWAY_TYPES.has(type);
+}
+function isEventType(type) {
+  return EVENT_TYPES.has(type);
+}
+function isDataType(type) {
+  return DATA_TYPES.has(type);
+}
+function acceptsBoundaryEvents(type) {
+  return BPMN_ELEMENT_CATALOG[type].acceptsBoundaryEvents;
+}
+function getHandlePolicy(type) {
+  return BPMN_ELEMENT_CATALOG[type].handlePolicy;
+}
+
+// src/modeling/index.ts
+function createBpmnNode(options) {
+  const size = getBpmnElementSize(options.elementType);
+  const meta = BPMN_ELEMENT_CATALOG[options.elementType];
+  const orientation = options.data?.orientation ?? meta.orientation;
+  const dragHandle = getBpmnDragHandleSelector(options.elementType);
+  return {
+    id: options.id,
+    type: options.elementType,
+    position: options.position,
+    data: {
+      elementType: options.elementType,
+      orientation,
+      ...options.label ? { label: options.label } : {},
+      ...options.data ?? {}
+    },
+    width: options.width ?? size.width,
+    height: options.height ?? size.height,
+    ...options.parentId ? { parentId: options.parentId } : {},
+    ...dragHandle ? { dragHandle } : {}
+  };
+}
+var BPMN_POOL_LANE_LAYOUT = {
+  poolHeaderSize: 30,
+  laneHeaderSize: 24,
+  laneGap: 0
+};
+function getBpmnDragHandleSelector(elementType) {
+  if (elementType === "Pool") return ".pool-drag-handle";
+  if (elementType === "Lane") return ".lane-drag-handle";
+  return void 0;
+}
+var BPMN_SELECTION_STYLE = {
+  nodeOutline: "#2563eb",
+  edgeStroke: "#2563eb",
+  handleFill: "#ffffff",
+  handleStroke: "#2563eb",
+  resizeHandleSize: 8,
+  routingPointRadius: 5
+};
+var BPMN_ROUTABLE_EDGE_TYPES = [
+  "sequenceFlow",
+  "messageFlow",
+  "association",
+  "dataAssociation",
+  "conversationLink"
+];
+var BPMN_EDGE_CONNECTION_RULES = {
+  sequenceFlow: {
+    edgeType: "sequenceFlow",
+    sourceCategories: ["flowNode"],
+    targetCategories: ["flowNode"],
+    allowSameParent: true,
+    allowDifferentParent: false
+  },
+  messageFlow: {
+    edgeType: "messageFlow",
+    sourceCategories: ["flowNode"],
+    targetCategories: ["flowNode"],
+    allowSameParent: false,
+    allowDifferentParent: true
+  },
+  association: {
+    edgeType: "association",
+    sourceCategories: ["flowNode", "artifact", "data"],
+    targetCategories: ["flowNode", "artifact", "data"],
+    allowSameParent: true,
+    allowDifferentParent: true
+  },
+  dataAssociation: {
+    edgeType: "dataAssociation",
+    sourceCategories: ["flowNode", "data"],
+    targetCategories: ["flowNode", "data"],
+    allowSameParent: true,
+    allowDifferentParent: true
+  },
+  conversationLink: {
+    edgeType: "conversationLink",
+    sourceCategories: ["conversation", "flowNode"],
+    targetCategories: ["conversation", "flowNode"],
+    allowSameParent: true,
+    allowDifferentParent: true
+  }
+};
+function inferBpmnEdgeType(state, sourceId, targetId) {
+  const source = diagramsCore.getNode(state, sourceId);
+  const target = diagramsCore.getNode(state, targetId);
+  if (!source || !target) return "sequenceFlow";
+  if (isDataType(source.data.elementType) || isDataType(target.data.elementType)) {
+    return "dataAssociation";
+  }
+  if (source.data.elementType === "Annotation" || target.data.elementType === "Annotation" || source.data.elementType === "Group" || target.data.elementType === "Group") {
+    return "association";
+  }
+  if (source.data.elementType === "Conversation" || source.data.elementType === "SubConversation" || source.data.elementType === "CallConversation" || target.data.elementType === "Conversation" || target.data.elementType === "SubConversation" || target.data.elementType === "CallConversation") {
+    return "conversationLink";
+  }
+  if (source.parentId && target.parentId && source.parentId !== target.parentId) {
+    return "messageFlow";
+  }
+  return "sequenceFlow";
+}
+function canUseSequenceFlow(type) {
+  const meta = BPMN_ELEMENT_CATALOG[type];
+  return meta.handlePolicy !== "none" && !isDataType(type) && type !== "Annotation" && type !== "Group" && meta.category !== "conversation";
+}
+function matchesConnectionCategory(type, categories) {
+  return categories.some((category) => {
+    if (category === type) return true;
+    if (category === "flowNode") return canUseSequenceFlow(type);
+    if (category === "data") return isDataType(type);
+    if (category === "artifact") return type === "Annotation" || type === "Group";
+    if (category === "conversation") return BPMN_ELEMENT_CATALOG[type].category === "conversation";
+    return false;
+  });
+}
+function isBpmnEdgeRoutingEditable(edgeType) {
+  return BPMN_ROUTABLE_EDGE_TYPES.includes(edgeType);
+}
+function isBpmnProcessNode(type) {
+  return isEventType(type) || isGatewayType(type) || type.includes("Task") || type === "CallActivity" || type === "SubProcess" || type === "Transaction" || type === "EventSubProcess" || type === "AdHocSubProcess";
+}
+function canContainBpmnElement(parentType, childType) {
+  if (!parentType) return true;
+  if (parentType === "Pool") {
+    return childType === "Lane" || isBpmnProcessNode(childType) ? true : "Pools can contain lanes or BPMN process nodes.";
+  }
+  if (parentType === "Lane") {
+    return isBpmnProcessNode(childType) ? true : "Lanes can only contain BPMN process nodes.";
+  }
+  if (parentType === "SubProcess" || parentType === "Transaction" || parentType === "EventSubProcess" || parentType === "AdHocSubProcess") {
+    return isBpmnProcessNode(childType) ? true : "Subprocesses can only contain BPMN process nodes.";
+  }
+  return `${parentType} cannot contain BPMN child elements.`;
+}
+function getDirectBpmnChildren(state, parentId) {
+  return state.nodes.filter((node) => node.parentId === parentId);
+}
+function getBpmnPoolLanes(state, poolId) {
+  return getDirectBpmnChildren(state, poolId).filter(
+    (node) => node.data.elementType === "Lane"
+  );
+}
+function getNodeDimension(node, axis) {
+  return node[axis] ?? node.measured?.[axis] ?? getBpmnElementSize(node.data.elementType)[axis];
+}
+function resolvePoolLaneDirection(pool) {
+  return pool.data.orientation === "vertical" ? "horizontal" : "vertical";
+}
+function getBpmnLaneIndexAtPosition(state, poolId, position) {
+  const pool = diagramsCore.getNode(state, poolId);
+  if (!pool) return 0;
+  const lanes = getBpmnPoolLanes(state, poolId);
+  const direction = resolvePoolLaneDirection(pool);
+  const axis = direction === "vertical" ? "y" : "x";
+  const sizeKey = direction === "vertical" ? "height" : "width";
+  for (let index = 0; index < lanes.length; index += 1) {
+    const lane = lanes[index];
+    const midpoint = lane.position[axis] + getNodeDimension(lane, sizeKey) / 2;
+    if (position[axis] < midpoint) return index;
+  }
+  return lanes.length;
+}
+function sortBpmnLanes(state, poolId, laneId, index) {
+  const lanes = getBpmnPoolLanes(state, poolId);
+  const currentIndex = lanes.findIndex((lane) => lane.id === laneId);
+  if (currentIndex < 0) return state;
+  const orderedIds = lanes.map((lane) => lane.id);
+  const [moved] = orderedIds.splice(currentIndex, 1);
+  orderedIds.splice(Math.max(0, Math.min(index, orderedIds.length)), 0, moved);
+  const order = new Map(orderedIds.map((id, laneIndex) => [id, laneIndex]));
+  return {
+    ...state,
+    nodes: [...state.nodes].sort((a, b) => {
+      const aOrder = order.get(a.id);
+      const bOrder = order.get(b.id);
+      if (aOrder === void 0 && bOrder === void 0) return 0;
+      if (aOrder === void 0) return -1;
+      if (bOrder === void 0) return 1;
+      return aOrder - bOrder;
+    })
+  };
+}
+function layoutBpmnPoolLanes(state, poolId) {
+  const pool = diagramsCore.getNode(state, poolId);
+  if (!pool) return state;
+  const poolSize = getBpmnElementSize("Pool");
+  const direction = resolvePoolLaneDirection(pool);
+  const lanes = getBpmnPoolLanes(state, poolId);
+  let cursor = direction === "vertical" ? BPMN_POOL_LANE_LAYOUT.poolHeaderSize : 0;
+  let next = state;
+  for (const lane of lanes) {
+    const laneSize = getBpmnElementSize("Lane");
+    const width = direction === "vertical" ? Math.max(poolSize.minWidth - BPMN_POOL_LANE_LAYOUT.poolHeaderSize, lane.width ?? laneSize.width) : lane.width ?? laneSize.width;
+    const height = direction === "vertical" ? lane.height ?? laneSize.height : Math.max(poolSize.minHeight - BPMN_POOL_LANE_LAYOUT.poolHeaderSize, lane.height ?? laneSize.height);
+    next = diagramsCore.patchNode(next, lane.id, {
+      position: direction === "vertical" ? { x: BPMN_POOL_LANE_LAYOUT.poolHeaderSize, y: cursor } : { x: cursor, y: BPMN_POOL_LANE_LAYOUT.poolHeaderSize },
+      width,
+      height,
+      data: { orientation: pool.data.orientation ?? "horizontal" }
+    });
+    cursor += (direction === "vertical" ? height : width) + BPMN_POOL_LANE_LAYOUT.laneGap;
+  }
+  const minWidth = direction === "vertical" ? poolSize.minWidth : Math.max(poolSize.minWidth, cursor);
+  const minHeight = direction === "vertical" ? Math.max(poolSize.minHeight, cursor) : poolSize.minHeight;
+  return diagramsCore.resizeNode(next, poolId, { width: minWidth, height: minHeight });
+}
+function reorderBpmnLane(state, options) {
+  return layoutBpmnPoolLanes(
+    sortBpmnLanes(state, options.poolId, options.laneId, options.index),
+    options.poolId
+  );
+}
+function validateBpmnConnectionForEdgeType(state, edgeType, source, target) {
+  const rule = BPMN_EDGE_CONNECTION_RULES[edgeType];
+  if (!matchesConnectionCategory(source.data.elementType, rule.sourceCategories)) {
+    return `${edgeType} cannot start from ${source.data.elementType}.`;
+  }
+  if (!matchesConnectionCategory(target.data.elementType, rule.targetCategories)) {
+    return `${edgeType} cannot target ${target.data.elementType}.`;
+  }
+  const sameParent = (source.parentId ?? null) === (target.parentId ?? null);
+  if (sameParent && rule.allowSameParent === false) {
+    return `${edgeType} must connect BPMN elements in different participants/scopes.`;
+  }
+  if (!sameParent && rule.allowDifferentParent === false) {
+    return `${edgeType} must stay inside the same BPMN participant/scope.`;
+  }
+  if (edgeType === "sequenceFlow") {
+    if (source.data.elementType === "EndEvent") return "End events cannot have outgoing sequence flows.";
+    if (target.data.elementType === "StartEvent") return "Start events cannot have incoming sequence flows.";
+    return validateEdgeCardinality(state, edgeType, source, target);
+  }
+  return true;
+}
+function validateEdgeCardinality(state, edgeType, source, target) {
+  if (edgeType !== "sequenceFlow") return true;
+  const sourceMax = BPMN_ELEMENT_CATALOG[source.data.elementType].maxOutgoing;
+  const targetMax = BPMN_ELEMENT_CATALOG[target.data.elementType].maxIncoming;
+  const outgoing = diagramsCore.getOutgoingEdges(state, source.id).filter(
+    (edge) => edge.data?.edgeType === "sequenceFlow"
+  );
+  const incoming = diagramsCore.getIncomingEdges(state, target.id).filter(
+    (edge) => edge.data?.edgeType === "sequenceFlow"
+  );
+  if (sourceMax !== void 0 && outgoing.length >= sourceMax) {
+    return `${source.data.elementType} cannot have more than ${sourceMax} outgoing sequence flow(s).`;
+  }
+  if (targetMax !== void 0 && incoming.length >= targetMax) {
+    return `${target.data.elementType} cannot have more than ${targetMax} incoming sequence flow(s).`;
+  }
+  return true;
+}
+var bpmnConnectionValidators = [
+  ({ state, source, target }) => {
+    if (source.id === target.id) return "BPMN self-connections are not allowed.";
+    const edgeType = inferBpmnEdgeType(state, source.id, target.id);
+    if (getHandlePolicy(source.data.elementType) === "none" || getHandlePolicy(target.data.elementType) === "none") {
+      return "Elements without BPMN connection handles cannot be directly connected.";
+    }
+    if (edgeType === "sequenceFlow") {
+      return validateBpmnConnectionForEdgeType(state, edgeType, source, target);
+    }
+    return validateBpmnConnectionForEdgeType(state, edgeType, source, target);
+  }
+];
+var BPMN_MODELING_RULES = diagramsCore.createModelingRules({
+  connect: [
+    ({ state, source, target }) => {
+      if (!source || !target) return false;
+      for (const validator of bpmnConnectionValidators) {
+        const result = validator({
+          state,
+          source,
+          target,
+          existingEdges: state.edges
+        });
+        if (result !== true) return result;
+      }
+      return true;
+    }
+  ],
+  drop: [
+    ({ node, parent }) => {
+      if (!node || !parent) return true;
+      if (node.data.elementType === "BoundaryEvent") {
+        return acceptsBoundaryEvents(parent.data.elementType) ? true : "Boundary events can only be attached to tasks or subprocesses.";
+      }
+      return canContainBpmnElement(parent.data.elementType, node.data.elementType);
+    }
+  ],
+  reparent: [
+    ({ node, parent }) => {
+      if (!node || !parent) return true;
+      if (node.data.elementType === "BoundaryEvent") {
+        return acceptsBoundaryEvents(parent.data.elementType) ? true : "Boundary events can only be reparented to tasks or subprocesses.";
+      }
+      return canContainBpmnElement(parent?.data.elementType, node.data.elementType);
+    }
+  ],
+  delete: [() => true],
+  resize: [
+    ({ node }) => !node || isBpmnElementResizable(node.data.elementType) ? true : `${node.data.elementType} is not resizable in BPMN.`
+  ]
+});
+function createBpmnNodeCommand(options) {
+  return {
+    id: `bpmn.createNode.${options.id}`,
+    label: `Create ${options.elementType}`,
+    execute: (state) => diagramsCore.addNode(state, createBpmnNode(options))
+  };
+}
+function connectBpmnCommand(options) {
+  return {
+    id: `bpmn.connect.${options.id ?? `${options.source}-${options.target}`}`,
+    label: "Connect BPMN elements",
+    execute: (state) => {
+      const edgeType = options.edgeType ?? inferBpmnEdgeType(state, options.source, options.target);
+      const source = diagramsCore.getNode(state, options.source);
+      const target = diagramsCore.getNode(state, options.target);
+      if (!source) throw new Error(`Source node "${options.source}" does not exist.`);
+      if (!target) throw new Error(`Target node "${options.target}" does not exist.`);
+      const validation = validateBpmnConnectionForEdgeType(state, edgeType, source, target);
+      if (validation !== true) throw new Error(validation);
+      return diagramsCore.connectNodes(
+        state,
+        {
+          source: options.source,
+          target: options.target,
+          type: edgeType,
+          ...options.sourceHandle !== void 0 ? { sourceHandle: options.sourceHandle } : {},
+          ...options.targetHandle !== void 0 ? { targetHandle: options.targetHandle } : {},
+          ...options.id ? { id: options.id } : {},
+          data: {
+            edgeType,
+            ...options.label ? { label: options.label } : {},
+            ...options.data ?? {}
+          }
+        },
+        []
+      );
+    }
+  };
+}
+function attachBoundaryEventCommand(boundaryId, hostId) {
+  return {
+    id: `bpmn.attachBoundary.${boundaryId}.${hostId}`,
+    label: "Attach boundary event",
+    execute: (state) => {
+      const host = diagramsCore.getNode(state, hostId);
+      if (!host || !acceptsBoundaryEvents(host.data.elementType)) {
+        throw new Error(`Element "${hostId}" cannot host boundary events.`);
+      }
+      const boundary = diagramsCore.getNode(state, boundaryId);
+      if (!boundary || boundary.data.elementType !== "BoundaryEvent") {
+        throw new Error(`Element "${boundaryId}" is not a boundary event.`);
+      }
+      const reparented = diagramsCore.reparentNode(state, boundaryId, { parentId: hostId });
+      return diagramsCore.patchNode(reparented, boundaryId, {
+        data: { attachedToRef: hostId }
+      });
+    }
+  };
+}
+function replaceBpmnNodeCommand(options) {
+  return {
+    id: `bpmn.replaceNode.${options.id}.${options.elementType}`,
+    label: `Replace with ${options.elementType}`,
+    execute: (state) => {
+      const current = diagramsCore.getNode(state, options.id);
+      if (!current) throw new Error(`Element "${options.id}" does not exist.`);
+      const meta = BPMN_ELEMENT_CATALOG[options.elementType];
+      return diagramsCore.replaceNode(state, options.id, {
+        ...current,
+        type: options.elementType,
+        width: options.width ?? current.width ?? meta.defaultWidth,
+        height: options.height ?? current.height ?? meta.defaultHeight,
+        data: {
+          ...current.data,
+          elementType: options.elementType,
+          ...options.label ? { label: options.label } : {},
+          ...options.data ?? {}
+        }
+      });
+    }
+  };
+}
+function reparentBpmnNodeCommand(options) {
+  return {
+    id: `bpmn.reparent.${options.id}.${options.parentId ?? "root"}`,
+    label: "Reparent BPMN element",
+    execute: (state) => {
+      const node = diagramsCore.getNode(state, options.id);
+      const parent = options.parentId ? diagramsCore.getNode(state, options.parentId) : void 0;
+      if (!node) throw new Error(`Element "${options.id}" does not exist.`);
+      if (parent && node.data.elementType === "BoundaryEvent" && !acceptsBoundaryEvents(parent.data.elementType)) {
+        throw new Error("Boundary events can only be reparented to tasks or subprocesses.");
+      }
+      const containment = canContainBpmnElement(parent?.data.elementType, node.data.elementType);
+      if (containment !== true) throw new Error(containment);
+      const reparented = diagramsCore.reparentNode(state, options.id, {
+        ...options.parentId !== void 0 ? { parentId: options.parentId } : {},
+        ...options.position ? { position: options.position } : {}
+      });
+      return parent?.data.elementType === "Pool" && node.data.elementType === "Lane" ? layoutBpmnPoolLanes(reparented, parent.id) : reparented;
+    }
+  };
+}
+function resizeBpmnNodeCommand(options) {
+  return {
+    id: `bpmn.resize.${options.id}`,
+    label: "Resize BPMN element",
+    execute: (state) => {
+      const node = diagramsCore.getNode(state, options.id);
+      if (!node) throw new Error(`Element "${options.id}" does not exist.`);
+      const size = getBpmnElementSize(node.data.elementType);
+      if (!size.resizable) {
+        throw new Error(`${node.data.elementType} is not resizable in BPMN.`);
+      }
+      return diagramsCore.resizeNode(state, options.id, {
+        width: options.width === void 0 ? void 0 : Math.max(size.minWidth, options.width),
+        height: options.height === void 0 ? void 0 : Math.max(size.minHeight, options.height)
+      });
+    }
+  };
+}
+function reorderBpmnLaneCommand(options) {
+  return {
+    id: `bpmn.reorderLane.${options.poolId}.${options.laneId}`,
+    label: "Reorder BPMN lane",
+    execute: (state) => {
+      const pool = diagramsCore.getNode(state, options.poolId);
+      const lane = diagramsCore.getNode(state, options.laneId);
+      if (!pool || pool.data.elementType !== "Pool") {
+        throw new Error(`Element "${options.poolId}" is not a pool.`);
+      }
+      if (!lane || lane.data.elementType !== "Lane" || lane.parentId !== options.poolId) {
+        throw new Error(`Element "${options.laneId}" is not a lane in pool "${options.poolId}".`);
+      }
+      return reorderBpmnLane(state, options);
+    }
+  };
+}
+function moveBpmnLaneCommand(options) {
+  return {
+    id: `bpmn.moveLane.${options.poolId}.${options.laneId}`,
+    label: "Move BPMN lane",
+    execute: (state) => reorderBpmnLane(state, {
+      poolId: options.poolId,
+      laneId: options.laneId,
+      index: getBpmnLaneIndexAtPosition(state, options.poolId, options.position)
+    })
+  };
+}
+function routeBpmnEdgeCommand(options) {
+  return {
+    id: `bpmn.routeEdge.${options.id}`,
+    label: "Route BPMN edge",
+    execute: (state) => {
+      const edge = state.edges.find((item) => item.id === options.id);
+      if (!edge) throw new Error(`Edge "${options.id}" does not exist.`);
+      const edgeType = edge.data?.edgeType;
+      if (!edgeType || !isBpmnEdgeRoutingEditable(edgeType)) {
+        throw new Error(`${edgeType ?? "edge"} routing points cannot be edited.`);
+      }
+      return diagramsCore.patchEdge(state, options.id, {
+        data: { routingPoints: options.routingPoints }
+      });
+    }
+  };
+}
+function deleteBpmnElementsCommand(ids) {
+  return {
+    id: `bpmn.delete.${ids.join(".")}`,
+    label: "Delete BPMN elements",
+    execute: (state) => diagramsCore.removeElements(state, ids)
+  };
+}
+function copyBpmnElements(state, selection) {
+  return diagramsCore.copyElements(state, selection);
+}
+function pasteBpmnElementsCommand(clipboard, options = {}) {
+  return {
+    id: "bpmn.paste",
+    label: "Paste BPMN elements",
+    execute: (state) => diagramsCore.pasteElements(state, clipboard, options)
+  };
+}
+function selectBpmnElementsCommand(selection) {
+  return {
+    id: "bpmn.select",
+    label: "Select BPMN elements",
+    execute: (state) => diagramsCore.setSelection(state, diagramsCore.createSelectionState(selection.nodeIds, selection.edgeIds))
+  };
+}
+function createBpmnDiagramDocument(state, options = {}) {
+  return serialization.createDiagramDocument(diagramsCore.normalizeDiagramState(state), {
+    ...options,
+    diagramType: "bpmn"
+  });
+}
+function serializeBpmnDiagram(state, options = {}) {
+  return serialization.serializeDiagram(diagramsCore.normalizeDiagramState(state), {
+    ...options,
+    diagramType: "bpmn"
+  });
+}
+function parseBpmnDiagramDocument(json) {
+  const document = serialization.parseDiagramDocument(json);
+  if (document.diagramType && document.diagramType !== "bpmn") {
+    throw new Error(`Expected a BPMN diagram document, received "${document.diagramType}".`);
+  }
+  return document;
+}
+function deserializeBpmnDiagram(json) {
+  const document = parseBpmnDiagramDocument(json);
+  return serialization.deserializeDiagram(JSON.stringify(document));
+}
+function runBpmnCommand(stack, command) {
+  return diagramsCore.executeCommand(stack, command);
+}
+function runBpmnCommands(stack, commands, options = {}) {
+  return diagramsCore.executeCommands(stack, commands, options);
+}
+
+exports.BPMN_EDGE_CONNECTION_RULES = BPMN_EDGE_CONNECTION_RULES;
+exports.BPMN_MODELING_RULES = BPMN_MODELING_RULES;
+exports.BPMN_POOL_LANE_LAYOUT = BPMN_POOL_LANE_LAYOUT;
+exports.BPMN_ROUTABLE_EDGE_TYPES = BPMN_ROUTABLE_EDGE_TYPES;
+exports.BPMN_SELECTION_STYLE = BPMN_SELECTION_STYLE;
+exports.attachBoundaryEventCommand = attachBoundaryEventCommand;
+exports.bpmnConnectionValidators = bpmnConnectionValidators;
+exports.canContainBpmnElement = canContainBpmnElement;
+exports.connectBpmnCommand = connectBpmnCommand;
+exports.copyBpmnElements = copyBpmnElements;
+exports.createBpmnDiagramDocument = createBpmnDiagramDocument;
+exports.createBpmnNode = createBpmnNode;
+exports.createBpmnNodeCommand = createBpmnNodeCommand;
+exports.deleteBpmnElementsCommand = deleteBpmnElementsCommand;
+exports.deserializeBpmnDiagram = deserializeBpmnDiagram;
+exports.getBpmnDragHandleSelector = getBpmnDragHandleSelector;
+exports.getBpmnElementSize = getBpmnElementSize;
+exports.getBpmnLaneIndexAtPosition = getBpmnLaneIndexAtPosition;
+exports.getBpmnPoolLanes = getBpmnPoolLanes;
+exports.inferBpmnEdgeType = inferBpmnEdgeType;
+exports.isBpmnEdgeRoutingEditable = isBpmnEdgeRoutingEditable;
+exports.isBpmnElementResizable = isBpmnElementResizable;
+exports.isBpmnProcessNode = isBpmnProcessNode;
+exports.layoutBpmnPoolLanes = layoutBpmnPoolLanes;
+exports.moveBpmnLaneCommand = moveBpmnLaneCommand;
+exports.parseBpmnDiagramDocument = parseBpmnDiagramDocument;
+exports.pasteBpmnElementsCommand = pasteBpmnElementsCommand;
+exports.reorderBpmnLane = reorderBpmnLane;
+exports.reorderBpmnLaneCommand = reorderBpmnLaneCommand;
+exports.reparentBpmnNodeCommand = reparentBpmnNodeCommand;
+exports.replaceBpmnNodeCommand = replaceBpmnNodeCommand;
+exports.resizeBpmnNodeCommand = resizeBpmnNodeCommand;
+exports.routeBpmnEdgeCommand = routeBpmnEdgeCommand;
+exports.runBpmnCommand = runBpmnCommand;
+exports.runBpmnCommands = runBpmnCommands;
+exports.selectBpmnElementsCommand = selectBpmnElementsCommand;
+exports.serializeBpmnDiagram = serializeBpmnDiagram;
+exports.validateBpmnConnectionForEdgeType = validateBpmnConnectionForEdgeType;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map