@bpmn-nova/studio 0.3.0-preview → 0.3.1-preview

package/dist/modules/properties-activiti/index.js

@@ -0,0 +1,97 @@
+import { propertyEntry, propertyGroup } from '../properties-core/index.js';
+
+const activityTypes = new Set(['task', 'userTask', 'manualTask', 'serviceTask', 'scriptTask', 'businessRuleTask', 'sendTask', 'receiveTask', 'callActivity', 'subProcess', 'eventSubProcess', 'transaction', 'adHocSubProcess']);
+const implementationTypes = [['class', 'Java Class'], ['delegateExpression', 'Delegate Expression'], ['expression', 'Expression']];
+const executionColumns = [
+  { key: 'event', label: 'Event', type: 'select', options: [['start', 'start'], ['end', 'end'], ['take', 'take']] },
+  { key: 'implementationType', label: '类型', type: 'select', options: implementationTypes },
+  { key: 'implementation', label: '实现' },
+];
+const taskListenerColumns = [
+  { key: 'event', label: 'Event', type: 'select', options: [['create', 'create'], ['assignment', 'assignment'], ['complete', 'complete'], ['delete', 'delete'], ['all', 'all']] },
+  { key: 'implementationType', label: '类型', type: 'select', options: implementationTypes },
+  { key: 'implementation', label: '实现' },
+];
+
+const processProvider = {
+  id: 'activiti-process', priority: 640, appliesTo: { kind: 'process', engine: 'activiti' },
+  getGroups() { return [propertyGroup({ id: 'activiti-process-execution', label: 'Activiti 执行监听器', collapsed: true, position: { after: 'global-resources' }, entries: [
+    propertyEntry({ id: 'process-listeners', type: 'table', label: 'Execution Listeners', path: 'properties.executionListeners', rowLabel: '监听器', defaultRow: () => ({ event: 'start', implementationType: 'class', implementation: '' }), columns: executionColumns }),
+  ] })]; },
+};
+
+const userTaskProvider = {
+  id: 'activiti-user-task', priority: 660, appliesTo: { kind: 'node', nodeType: 'userTask', engine: 'activiti' },
+  getGroups() { return [
+    propertyGroup({ id: 'assignment', label: '人员分配 · Activiti', position: { after: 'basic' }, entries: [
+      propertyEntry({ id: 'assignee', type: 'user-select', label: '负责人 Assignee', path: 'properties.assignee', dataProvider: 'identity', allowExpression: true, placeholder: '${manager}' }),
+      propertyEntry({ id: 'owner', type: 'user-select', label: 'Owner', path: 'properties.owner', dataProvider: 'identity', allowExpression: true }),
+      propertyEntry({ id: 'candidate-users', type: 'tags', label: '候选用户', path: 'properties.candidateUsers', dataProvider: 'identity' }),
+      propertyEntry({ id: 'candidate-groups', type: 'tags', label: '候选组', path: 'properties.candidateGroups', dataProvider: 'identity' }),
+    ] }),
+    propertyGroup({ id: 'task-config', label: '任务属性', position: { after: 'assignment' }, entries: [
+      propertyEntry({ id: 'form-key', type: 'form-select', label: 'Form Key', path: 'properties.formKey', dataProvider: 'forms', allowCustom: true }),
+      propertyEntry({ id: 'due-date', type: 'expression', label: 'Due Date', path: 'properties.dueDate' }),
+      propertyEntry({ id: 'priority', type: 'number', label: 'Priority', path: 'properties.priority', min: 0, max: 100 }),
+      propertyEntry({ id: 'category', label: 'Category', path: 'properties.category' }),
+      propertyEntry({ id: 'skip-expression', type: 'expression', label: 'Skip Expression', path: 'properties.skipExpression' }),
+    ] }),
+    propertyGroup({ id: 'task-listeners', label: 'Task Listeners', collapsed: true, position: { after: 'multi-instance' }, entries: [
+      propertyEntry({ id: 'task-listener-table', type: 'table', label: '任务监听器', path: 'properties.taskListeners', rowLabel: 'Task Listener', defaultRow: () => ({ event: 'create', implementationType: 'class', implementation: '' }), columns: taskListenerColumns }),
+    ] }),
+  ]; },
+};
+
+const implementationProvider = {
+  id: 'activiti-implementation', priority: 660,
+  appliesTo: (ctx) => ctx.kind === 'node' && ctx.model.engine === 'activiti' && ['serviceTask', 'sendTask', 'businessRuleTask'].includes(ctx.element.type),
+  getGroups() { return [
+    propertyGroup({ id: 'engine-implementation', label: '执行实现 · Activiti', position: { after: 'basic' }, entries: [
+      propertyEntry({ id: 'implementation-type', type: 'select', label: '实现方式', path: 'properties.implementationType', options: implementationTypes }),
+      propertyEntry({ id: 'implementation', type: 'expression', label: '实现值', path: 'properties.implementation', placeholder: 'com.example.MyDelegate / ${delegateBean}' }),
+      propertyEntry({ id: 'result-variable', label: 'Result Variable', path: 'properties.resultVariable' }),
+    ] }),
+    propertyGroup({ id: 'field-injection', label: 'Field Injection', collapsed: true, position: { after: 'engine-implementation' }, entries: [
+      propertyEntry({ id: 'fields', type: 'table', label: '字段注入', path: 'properties.fields', rowLabel: 'Field', defaultRow: () => ({ name: '', type: 'string', value: '' }), columns: [{ key: 'name', label: 'Name' }, { key: 'type', label: '类型', type: 'select', options: [['string', 'String'], ['expression', 'Expression']] }, { key: 'value', label: 'Value' }] }),
+    ] }),
+  ]; },
+};
+
+const activityProvider = {
+  id: 'activiti-activity-execution', priority: 610,
+  appliesTo: (ctx) => ctx.kind === 'node' && ctx.model.engine === 'activiti' && activityTypes.has(ctx.element.type),
+  getGroups() { return [
+    propertyGroup({ id: 'engine-execution', label: '执行配置 · Activiti', collapsed: true, position: { after: 'multi-instance' }, entries: [
+      propertyEntry({ id: 'async', type: 'switch', label: 'Async', path: 'properties.async' }),
+      propertyEntry({ id: 'exclusive', type: 'switch', label: 'Exclusive Job', path: 'properties.exclusive' }),
+      propertyEntry({ id: 'async-leave', type: 'switch', label: 'Async Leave', path: 'properties.asyncLeave' }),
+      propertyEntry({ id: 'failed-retry', type: 'expression', label: 'Failed Job Retry Cycle', path: 'properties.failedJobRetryTimeCycle', placeholder: 'R3/PT5M' }),
+    ] }),
+    propertyGroup({ id: 'execution-listeners', label: 'Execution Listeners', collapsed: true, position: { after: 'engine-execution' }, entries: [
+      propertyEntry({ id: 'execution-listener-table', type: 'table', label: '执行监听器', path: 'properties.executionListeners', rowLabel: 'Execution Listener', defaultRow: () => ({ event: 'start', implementationType: 'class', implementation: '' }), columns: executionColumns.map((column) => column.key === 'event' ? { ...column, options: [['start', 'start'], ['end', 'end']] } : column) }),
+    ] }),
+  ]; },
+};
+
+const callProvider = {
+  id: 'activiti-call-activity', priority: 650, appliesTo: { kind: 'node', nodeType: 'callActivity', engine: 'activiti' },
+  getGroups() { return [propertyGroup({ id: 'activiti-call', label: 'Activiti 调用选项', collapsed: true, position: { after: 'call-activity' }, entries: [
+    propertyEntry({ id: 'inherit-business-key', type: 'switch', label: 'Inherit Business Key', path: 'properties.inheritBusinessKey' }),
+    propertyEntry({ id: 'inherit-variables', type: 'switch', label: 'Inherit Variables', path: 'properties.inheritVariables' }),
+  ] })]; },
+};
+
+const edgeProvider = {
+  id: 'activiti-edge-listeners', priority: 620,
+  appliesTo: (ctx) => ctx.kind === 'edge' && ctx.model.engine === 'activiti' && (ctx.element.type || 'sequenceFlow') === 'sequenceFlow',
+  getGroups() { return [propertyGroup({ id: 'edge-listeners', label: 'Take Listener · Activiti', collapsed: true, position: { after: 'condition' }, entries: [
+    propertyEntry({ id: 'edge-execution-listeners', type: 'table', label: 'Execution Listeners', path: 'properties.executionListeners', rowLabel: 'Take Listener', defaultRow: () => ({ event: 'take', implementationType: 'class', implementation: '' }), columns: executionColumns.map((column) => column.key === 'event' ? { ...column, options: [['take', 'take']] } : column) }),
+  ] })]; },
+};
+
+export const activitiPropertiesProviders = [processProvider, userTaskProvider, implementationProvider, activityProvider, callProvider, edgeProvider];
+
+export function registerActivitiProperties(registry) {
+  const disposers = activitiPropertiesProviders.map((provider) => registry.registerProvider(provider.priority ?? 500, provider));
+  return () => disposers.forEach((dispose) => dispose());
+}

package/dist/modules/properties-bpmn/index.d.ts

@@ -0,0 +1,3 @@
+import type { PropertiesProvider, PropertiesRegistry } from '../properties-core/index.js'
+export const bpmnPropertiesProviders: PropertiesProvider[]
+export function registerBpmnProperties(registry: PropertiesRegistry): () => void

package/dist/modules/properties-bpmn/index.js

@@ -0,0 +1,516 @@
+import { NODE_DEFINITIONS, resolveGatewayRole, resolveSwimlaneLabelPlacement } from '../core/index.js';
+import { propertyEntry, propertyGroup } from '../properties-core/index.js';
+
+const activityKinds = new Set(['task', 'container']);
+const eventRefs = {
+  message: { resource: 'messages', label: '消息 Message' },
+  signal: { resource: 'signals', label: '信号 Signal' },
+  error: { resource: 'errors', label: '错误 Error' },
+  escalation: { resource: 'escalations', label: '升级 Escalation' },
+};
+
+function nodeTypeOptions(context) {
+  const currentKind = context.definition?.kind;
+  const compatible = currentKind === 'event' || currentKind === 'boundary'
+    ? ['event', 'boundary']
+    : currentKind === 'task' || currentKind === 'container'
+      ? ['task', 'container']
+      : [currentKind];
+  return Object.entries(NODE_DEFINITIONS)
+    .filter(([type, def]) => type !== 'generic' && compatible.includes(def.kind))
+    .map(([value, def]) => ({ value, label: def.label }));
+}
+
+function idValidator(value, context) {
+  if (!value) return 'ID 不能为空';
+  if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(value)) return 'ID 只能包含字母、数字、_、-、.，且不能以数字开头';
+  const model = context.model;
+  const processConflict = context.kind !== 'process' && model.id === value;
+  const nodeConflict = model.nodes.some((item) => item.id === value && !(context.kind === 'node' && item === context.element));
+  const edgeConflict = model.edges.some((item) => item.id === value && !(context.kind === 'edge' && item === context.element));
+  if (processConflict || nodeConflict || edgeConflict) return 'ID 已存在；BPMN Element ID 必须在 Definitions 内唯一';
+  return null;
+}
+
+const basicProvider = {
+  id: 'bpmn-basic',
+  priority: 1000,
+  getGroups(context) {
+    if (context.kind === 'process') {
+      return [propertyGroup({
+        id: 'basic', label: '基本信息', collapsible: false,
+        entries: [
+          propertyEntry({ id: 'process-name', label: '流程名称', path: 'name', required: true }),
+          propertyEntry({ id: 'process-id', label: 'Process ID', path: 'id', required: true, validate: idValidator, note: '部署到流程引擎时作为 processDefinitionKey。', level: 'developer' }),
+          propertyEntry({ id: 'namespace', label: 'Target Namespace', path: 'targetNamespace', placeholder: 'urn:company:workflow', level: 'developer' }),
+          propertyEntry({ id: 'executable', type: 'switch', label: '可执行流程', path: 'isExecutable' }),
+          propertyEntry({
+            id: 'engine', type: 'select', label: '流程引擎',
+            options: [{ value: 'flowable', label: 'Flowable' }, { value: 'activiti', label: 'Activiti' }],
+            getValue: (ctx) => ctx.model.engine,
+            setValue: (ctx, value) => ctx.studio.setEngine(value),
+          }),
+        ],
+      })];
+    }
+    if (context.kind === 'edge') {
+      return [propertyGroup({
+        id: 'basic', label: context.element.type === 'sequenceFlow' ? '分支定义' : '连线信息', collapsible: false,
+        entries: [
+          propertyEntry({ id: 'edge-name', label: '名称', path: 'name', placeholder: '例如：同意 / 驳回 / 金额 ≥ 5万' }),
+          propertyEntry({ id: 'edge-id', label: 'Flow ID', path: 'id', required: true, validate: idValidator }),
+          propertyEntry({ id: 'edge-type', type: 'readonly', label: 'BPMN Type', getValue: (ctx) => ctx.element.type === 'messageFlow' ? 'bpmn:MessageFlow' : ctx.element.type === 'association' ? 'bpmn:Association' : 'bpmn:SequenceFlow' }),
+        ],
+      })];
+    }
+    const def = context.definition;
+    return [propertyGroup({
+      id: 'basic', label: '基本信息', collapsible: false,
+      entries: [
+        propertyEntry({ id: 'name', label: '名称', path: 'name', required: true }),
+        propertyEntry({ id: 'id', label: 'Element ID', path: 'id', required: true, validate: idValidator, level: 'developer' }),
+        propertyEntry({
+          id: 'node-type', type: 'select', label: '节点类型', options: nodeTypeOptions,
+          getValue: (ctx) => ctx.element.type,
+          setValue: (ctx, value) => ctx.designer.changeNodeType(ctx.element.id, value),
+        }),
+        propertyEntry({ id: 'bpmn-type', type: 'readonly', label: 'BPMN Type', getValue: (ctx) => ctx.definition?.bpmnType || ctx.element.bpmnType, level: 'developer' }),
+      ],
+    })];
+  },
+};
+
+const documentationProvider = {
+  id: 'bpmn-documentation',
+  priority: 200,
+  getGroups(context) {
+    return [propertyGroup({
+      id: 'documentation', label: '文档说明', collapsed: true, position: { append: true },
+      entries: [propertyEntry({
+        id: 'documentation', type: 'textarea', label: 'Documentation', path: context.kind === 'process' ? 'properties.documentation' : 'properties.documentation',
+        placeholder: '节点说明、业务规则、实现备注或流程文档。', rows: 5,
+      })],
+    })];
+  },
+};
+
+const processProvider = {
+  id: 'bpmn-process',
+  priority: 800,
+  appliesTo: { kind: 'process' },
+  getGroups() {
+    return [
+      propertyGroup({
+        id: 'process-start-permissions', label: '启动权限', collapsed: true, position: { after: 'basic' },
+        entries: [
+          propertyEntry({ id: 'starter-users', type: 'tags', label: '候选启动用户', path: 'properties.candidateStarterUsers', placeholder: 'user1,user2' }),
+          propertyEntry({ id: 'starter-groups', type: 'tags', label: '候选启动组', path: 'properties.candidateStarterGroups', placeholder: 'manager,finance' }),
+        ],
+      }),
+      propertyGroup({
+        id: 'global-resources', label: '全局事件资源', collapsed: true, position: { after: 'process-start-permissions' },
+        description: '集中管理 Message / Signal / Error / Escalation，事件节点通过 ID 引用。',
+        entries: [
+          propertyEntry({ id: 'messages', type: 'table', label: 'Messages', path: 'resources.messages', rowLabel: '消息', defaultRow: () => ({ id: `Message_${Date.now().toString(36)}`, name: '新消息' }), columns: [{ key: 'id', label: 'ID' }, { key: 'name', label: '名称' }] }),
+          propertyEntry({ id: 'signals', type: 'table', label: 'Signals', path: 'resources.signals', rowLabel: '信号', defaultRow: () => ({ id: `Signal_${Date.now().toString(36)}`, name: '新信号' }), columns: [{ key: 'id', label: 'ID' }, { key: 'name', label: '名称' }] }),
+          propertyEntry({ id: 'errors', type: 'table', label: 'Errors', path: 'resources.errors', rowLabel: '错误', defaultRow: () => ({ id: `Error_${Date.now().toString(36)}`, name: '业务错误', errorCode: 'BUSINESS_ERROR' }), columns: [{ key: 'id', label: 'ID' }, { key: 'name', label: '名称' }, { key: 'errorCode', label: 'Error Code' }] }),
+          propertyEntry({ id: 'escalations', type: 'table', label: 'Escalations', path: 'resources.escalations', rowLabel: '升级', defaultRow: () => ({ id: `Escalation_${Date.now().toString(36)}`, name: '业务升级', escalationCode: 'ESCALATE' }), columns: [{ key: 'id', label: 'ID' }, { key: 'name', label: '名称' }, { key: 'escalationCode', label: 'Code' }] }),
+        ],
+      }),
+      propertyGroup({
+        id: 'namespaces', label: '命名空间', collapsed: true, position: { after: 'global-resources' },
+        description: '自定义属性 / Extension Element 使用的 XML Namespace。填写前缀时使用 xmlns:company 形式。',
+        entries: [propertyEntry({
+          id: 'namespace-table', type: 'table', label: 'Namespace Declarations',
+          getValue: (ctx) => Object.entries(ctx.model.namespaceDeclarations || {}).map(([name, uri]) => ({ name, uri })),
+          setValue: (ctx, rows) => ctx.designer.updateProcess({ namespaceDeclarations: Object.fromEntries((rows || []).filter((row) => row.name && row.uri).map((row) => [row.name.startsWith('xmlns:') ? row.name : `xmlns:${row.name}`, row.uri])) }),
+          rowLabel: '命名空间', defaultRow: () => ({ name: 'xmlns:company', uri: 'urn:company:bpmn-extension' }), columns: [{ key: 'name', label: 'Prefix' }, { key: 'uri', label: 'URI' }],
+        })],
+      }),
+      propertyGroup({
+        id: 'canvas-display', label: '画布显示', position: { after: 'basic' },
+        entries: [
+          propertyEntry({ id: 'show-grid', type: 'switch', label: '显示网格', path: 'settings.showGrid', defaultValue: true }),
+          propertyEntry({ id: 'grid-size', type: 'range', label: '网格尺寸', path: 'settings.gridSize', defaultValue: 16, min: 8, max: 40, step: 4, unit: 'px' }),
+          propertyEntry({ id: 'snap-to-grid', type: 'switch', label: '吸附到网格', path: 'settings.snapToGrid', defaultValue: false }),
+          propertyEntry({ id: 'alignment-guides', type: 'switch', label: '智能对齐辅助线', path: 'settings.alignmentGuides', defaultValue: true, note: '关闭后不再进行磁性对齐，也不显示拖动辅助线。' }),
+        ],
+      }),
+      propertyGroup({
+        id: 'nova-layout', label: '布局与连线', position: { after: 'canvas-display' },
+        entries: [
+          propertyEntry({ id: 'direction', type: 'select', label: '默认布局方向', path: 'settings.direction', options: [['horizontal', '横向 Left → Right'], ['vertical', '纵向 Top → Bottom']] }),
+          propertyEntry({ id: 'density', type: 'select', label: '布局紧凑度', path: 'settings.layoutDensity', options: [['compact', '紧凑'], ['balanced', '标准'], ['spacious', '舒展']], note: '影响快捷添加和一键美化的节点间距。' }),
+          propertyEntry({ id: 'edge-style', type: 'select', label: '默认连线风格', path: 'settings.edgeStyle', options: [['rounded', '圆角折线'], ['smooth', '柔和曲线'], ['straight', '直角折线']] }),
+          propertyEntry({ id: 'beautify', type: 'action', label: '一键整理全部节点与连线', actionLabel: '一键美化', iconId: 'ui.magic', action: (ctx) => ctx.designer.beautify({ direction: ctx.model.settings?.direction, density: ctx.model.settings?.layoutDensity, edgeStyle: ctx.model.settings?.edgeStyle }) }),
+        ],
+      }),
+    ];
+  },
+};
+
+const sequenceFlowProvider = {
+  id: 'bpmn-sequence-flow',
+  priority: 850,
+  appliesTo: (ctx) => ctx.kind === 'edge' && (ctx.element.type || 'sequenceFlow') === 'sequenceFlow',
+  getGroups(context) {
+    const source = context.model.nodes.find((node) => node.id === context.element.source);
+    const sourceDef = NODE_DEFINITIONS[source?.type] || {};
+    return [
+      propertyGroup({
+        id: 'condition', label: '条件与默认出口', position: { after: 'basic' },
+        entries: [
+          propertyEntry({ id: 'condition-expression', type: 'expression', label: '条件表达式', path: 'condition', placeholder: '${amount >= 50000}', note: source?.type === 'parallelGateway' ? '并行网关不会根据条件选择出口；仅供开发者清理历史数据。' : '导出为 bpmn:conditionExpression。', visible: (ctx) => source?.type === 'parallelGateway' ? ctx.profile === 'developer' : sourceDef.kind === 'gateway' || !!context.element.condition }),
+          propertyEntry({
+            id: 'default-flow', type: 'switch', label: '默认线路', getValue: (ctx) => !!ctx.element.isDefault,
+            setValue: (ctx, value) => {
+              const patches = [];
+              if (value) {
+                for (const edge of ctx.model.edges.filter((edge) => edge.source === ctx.element.source && edge.id !== ctx.element.id && edge.isDefault)) patches.push({ id: edge.id, patch: { isDefault: false } });
+              }
+              patches.push({ id: ctx.element.id, patch: { isDefault: !!value } });
+              ctx.designer.updateEdges(patches);
+            },
+            note: source?.type === 'parallelGateway' ? '并行网关不支持默认出口；仅供开发者清理历史数据。' : '',
+            visible: (ctx) => ['exclusiveGateway', 'inclusiveGateway', 'complexGateway'].includes(source?.type) || (source?.type === 'parallelGateway' && ctx.profile === 'developer'),
+          }),
+        ],
+      }),
+      propertyGroup({
+        id: 'nova-edge-style', label: '流程图显示', collapsed: true, position: { after: 'condition' },
+        entries: [
+          propertyEntry({ id: 'route-style', type: 'select', label: '线路样式', path: 'routeStyle', options: [['rounded', '圆角折线'], ['smooth', '柔和曲线'], ['straight', '直角折线']] }),
+          propertyEntry({ id: 'corner-radius', type: 'range', label: '圆角半径', path: 'cornerRadius', min: 0, max: 28, step: 1, unit: 'px' }),
+          propertyEntry({ id: 'reset-route', type: 'action', label: '重算最佳路径', actionLabel: '重算线路', iconId: 'ui.routeSmooth', action: (ctx) => ctx.designer.resetEdgeRoute(ctx.element.id) }),
+        ],
+      }),
+    ];
+  },
+};
+
+const activityProvider = {
+  id: 'bpmn-activity',
+  priority: 700,
+  appliesTo: (ctx) => ctx.kind === 'node' && activityKinds.has(ctx.definition?.kind),
+  getGroups() {
+    return [
+      propertyGroup({
+        id: 'multi-instance', label: '循环 / 多实例', collapsed: true, position: { after: 'basic' },
+        entries: [
+          propertyEntry({ id: 'loop-type', type: 'select', label: '循环类型', path: 'properties.loopType', options: [['none', '无'], ['standard', '标准循环'], ['parallel', '并行多实例'], ['sequential', '串行多实例']] }),
+          propertyEntry({ id: 'loop-condition', type: 'expression', label: 'Loop Condition', path: 'properties.loopCondition', placeholder: '${retry == true}', visible: (ctx) => ctx.get('properties.loopType') === 'standard' }),
+          propertyEntry({ id: 'loop-test-before', type: 'switch', label: 'Test Before', path: 'properties.testBefore', visible: (ctx) => ctx.get('properties.loopType') === 'standard' }),
+          propertyEntry({ id: 'loop-maximum', type: 'number', label: 'Loop Maximum', path: 'properties.loopMaximum', min: 0, visible: (ctx) => ctx.get('properties.loopType') === 'standard' }),
+          propertyEntry({ id: 'collection', label: 'Collection', path: 'properties.collection', placeholder: '${approvers}', visible: (ctx) => ['parallel', 'sequential'].includes(ctx.get('properties.loopType')) }),
+          propertyEntry({ id: 'element-variable', label: 'Element Variable', path: 'properties.elementVariable', placeholder: 'approver', visible: (ctx) => ['parallel', 'sequential'].includes(ctx.get('properties.loopType')) }),
+          propertyEntry({ id: 'element-index-variable', label: 'Element Index Variable', path: 'properties.elementIndexVariable', placeholder: 'index', visible: (ctx) => ['parallel', 'sequential'].includes(ctx.get('properties.loopType')) }),
+          propertyEntry({ id: 'loop-cardinality', type: 'expression', label: 'Loop Cardinality', path: 'properties.loopCardinality', placeholder: '${3}', visible: (ctx) => ['parallel', 'sequential'].includes(ctx.get('properties.loopType')) }),
+          propertyEntry({ id: 'completion-condition', type: 'expression', label: 'Completion Condition', path: 'properties.completionCondition', placeholder: '${nrOfCompletedInstances >= 2}', visible: (ctx) => ['parallel', 'sequential'].includes(ctx.get('properties.loopType')) }),
+          propertyEntry({ id: 'compensation', type: 'switch', label: '补偿活动', path: 'properties.isForCompensation' }),
+        ],
+      }),
+    ];
+  },
+};
+
+const scriptProvider = {
+  id: 'bpmn-script-task', priority: 720, appliesTo: { kind: 'node', nodeType: 'scriptTask' },
+  getGroups() { return [propertyGroup({ id: 'script', label: '脚本', position: { after: 'basic' }, entries: [
+    propertyEntry({ id: 'script-format', label: 'Script Format', path: 'properties.scriptFormat', placeholder: 'javascript / groovy' }),
+    propertyEntry({ id: 'script-body', type: 'code', label: 'Script', path: 'properties.script', rows: 9, placeholder: '// script body' }),
+    propertyEntry({ id: 'script-result', label: 'Result Variable', path: 'properties.resultVariable', placeholder: 'result' }),
+  ] })]; },
+};
+
+const callActivityProvider = {
+  id: 'bpmn-call-activity', priority: 720, appliesTo: { kind: 'node', nodeType: 'callActivity' },
+  getGroups() { return [propertyGroup({ id: 'call-activity', label: '调用流程', position: { after: 'basic' }, entries: [
+    propertyEntry({ id: 'called-element', type: 'process-select', label: 'Called Element', path: 'properties.calledElement', placeholder: 'Process_Sub_1', dataProvider: 'processes', allowCustom: true }),
+    propertyEntry({ id: 'called-business-key', type: 'expression', label: 'Business Key', path: 'properties.businessKey', placeholder: '${businessKey}' }),
+    propertyEntry({ id: 'inherit-business-key', type: 'switch', label: '继承 Business Key', path: 'properties.inheritBusinessKey' }),
+    propertyEntry({ id: 'inherit-variables', type: 'switch', label: '继承流程变量', path: 'properties.inheritVariables' }),
+    propertyEntry({ id: 'input-mapping', type: 'table', label: '输入参数 In', path: 'properties.inParameters', rowLabel: '输入映射', defaultRow: () => ({ source: '', sourceExpression: '', target: '' }), columns: [{ key: 'source', label: 'Source' }, { key: 'sourceExpression', label: 'Expression' }, { key: 'target', label: 'Target' }] }),
+    propertyEntry({ id: 'output-mapping', type: 'table', label: '输出参数 Out', path: 'properties.outParameters', rowLabel: '输出映射', defaultRow: () => ({ source: '', sourceExpression: '', target: '' }), columns: [{ key: 'source', label: 'Source' }, { key: 'sourceExpression', label: 'Expression' }, { key: 'target', label: 'Target' }] }),
+  ] })]; },
+};
+
+const messageTaskProvider = {
+  id: 'bpmn-message-task', priority: 725,
+  appliesTo: (ctx) => ctx.kind === 'node' && ['sendTask', 'receiveTask'].includes(ctx.element.type),
+  getGroups(context) {
+    const entries = [
+      propertyEntry({
+        id: 'message-ref', type: 'resource-select', label: 'Message Ref', path: 'properties.messageRef', resource: 'messages', allowCustom: true,
+        options: (ctx) => (ctx.model.resources?.messages || []).map((item) => ({ value: item.id, label: `${item.name || item.id} · ${item.id}` })),
+        placeholder: '选择或输入 Message ID',
+      }),
+      propertyEntry({ id: 'operation-ref', label: 'Operation Ref', path: 'properties.operationRef', placeholder: 'Operation_1' }),
+    ];
+    if (context.element.type === 'receiveTask') entries.push(propertyEntry({ id: 'instantiate-receive', type: 'switch', label: 'Instantiate', path: 'properties.instantiate' }));
+    return [propertyGroup({ id: 'message-task', label: context.element.type === 'sendTask' ? '消息发送' : '消息接收', position: { after: 'basic' }, entries })];
+  },
+};
+
+const subProcessProvider = {
+  id: 'bpmn-sub-process', priority: 710,
+  appliesTo: (ctx) => ctx.kind === 'node' && ctx.definition?.kind === 'container',
+  getGroups(context) {
+    const entries = [];
+    if (context.element.type === 'eventSubProcess') entries.push(propertyEntry({ id: 'triggered-by-event', type: 'readonly', label: 'Triggered By Event', value: 'true' }));
+    if (context.element.type === 'adHocSubProcess') entries.push(
+      propertyEntry({ id: 'adhoc-ordering', type: 'select', label: 'Ordering', path: 'properties.ordering', options: [['Parallel', 'Parallel'], ['Sequential', 'Sequential']] }),
+      propertyEntry({ id: 'adhoc-completion', type: 'expression', label: 'Completion Condition', path: 'properties.adHocCompletionCondition', placeholder: '${completed}' }),
+      propertyEntry({ id: 'adhoc-cancel', type: 'switch', label: 'Cancel Remaining Instances', path: 'properties.cancelRemainingInstances' }),
+    );
+    if (!entries.length) return [];
+    return [propertyGroup({ id: 'sub-process', label: '子流程行为', position: { after: 'basic' }, entries })];
+  },
+};
+
+const gatewayProvider = {
+  id: 'bpmn-gateway', priority: 760, appliesTo: { kind: 'node', elementKind: 'gateway' },
+  getGroups(context) {
+    const role = resolveGatewayRole(context.model, context.element);
+    const isParallel = context.element.type === 'parallelGateway';
+    const entries = [];
+    if (isParallel && context.profile === 'business') entries.push(propertyEntry({
+      id: 'parallel-role', type: 'select', label: '并行角色', path: 'properties.gatewayDirection',
+      options: (ctx) => [
+        ['Unspecified', '自动判断'], ['Diverging', '并行分支'], ['Converging', '并行汇聚'],
+        ...(ctx.element.properties?.gatewayDirection === 'Mixed' ? [['Mixed', '混合（开发者配置）']] : []),
+      ],
+      note: role.effective === 'Converging' ? '并行汇聚会等待所有入口到达后再继续。' : '',
+    }));
+    if (context.profile === 'developer' || !isParallel) entries.push(propertyEntry({ id: 'gateway-direction', type: 'select', label: 'Gateway Direction', path: 'properties.gatewayDirection', options: [['Unspecified', 'Unspecified'], ['Diverging', 'Diverging / 分支'], ['Converging', 'Converging / 汇聚'], ['Mixed', 'Mixed']] }));
+    if (context.element.type === 'eventBasedGateway') entries.push(
+      propertyEntry({ id: 'instantiate', type: 'switch', label: 'Instantiate', path: 'properties.instantiate' }),
+      propertyEntry({ id: 'event-gateway-type', type: 'select', label: 'Event Gateway Type', path: 'properties.eventGatewayType', options: [['Exclusive', 'Exclusive'], ['Parallel', 'Parallel']] }),
+    );
+    if (context.element.type === 'complexGateway') entries.push(propertyEntry({ id: 'activation-condition', type: 'expression', label: 'Activation Condition', path: 'properties.activationCondition' }));
+    const groups = [];
+    if (entries.length) groups.push(propertyGroup({ id: 'gateway', label: '网关配置', position: { after: 'basic' }, entries }));
+    if (!isParallel) {
+      groups.push(propertyGroup({
+        id: 'gateway-branches', label: `分支线路 · ${role.outgoing.length}`, collapsed: false, position: { after: 'gateway' },
+        description: '直接在网关面板维护出口名称、条件和默认线路；点击定位可选中对应 Sequence Flow。',
+        entries: [propertyEntry({
+          id: 'branches', type: 'branchList', label: '',
+          getValue: () => role.outgoing.map((edge) => ({ id: edge.id, name: edge.name || '', condition: edge.condition || '', isDefault: !!edge.isDefault, target: edge.target })),
+          setValue: (ctx, rows) => {
+            const patches = rows.map((row) => ({ id: row.id, patch: { name: row.name, condition: row.condition, isDefault: !!row.isDefault } }));
+            const defaultRow = rows.find((row) => row.isDefault);
+            if (defaultRow) {
+              for (const edge of role.outgoing) if (edge.id !== defaultRow.id && edge.isDefault) patches.push({ id: edge.id, patch: { isDefault: false } });
+            }
+            ctx.designer.updateEdges(patches);
+          },
+          selectRow: (ctx, row) => ctx.designer.select({ kind: 'edge', id: row.id }),
+        })],
+      }));
+      return groups;
+    }
+
+    let structureAfter = 'gateway';
+    if (role.effective === 'Diverging') {
+      groups.push(propertyGroup({
+        id: 'gateway-branches', label: `并行出口 · ${role.outgoing.length}`, collapsed: false, position: { after: 'gateway' },
+        description: '并行分支会同时激活所有出口；可维护线路名称或定位对应 Sequence Flow。',
+        entries: [
+          propertyEntry({
+            id: 'branches', type: 'branchList', label: '', fields: ['name'],
+            getValue: () => role.outgoing.map((edge) => ({ id: edge.id, name: edge.name || '', condition: edge.condition || '', isDefault: !!edge.isDefault, target: edge.target })),
+            setValue: (ctx, rows) => ctx.designer.updateEdges(rows.map((row) => ({ id: row.id, patch: { name: row.name } }))),
+            selectRow: (ctx, row) => ctx.designer.select({ kind: 'edge', id: row.id }),
+          }),
+          propertyEntry({ id: 'connect-parallel-branch', type: 'action', label: '连接已有节点', actionLabel: '连接并行分支', iconId: 'ui.connect', action: (ctx) => ctx.designer.startConnect(ctx.element.id) }),
+        ],
+      }));
+      structureAfter = 'gateway-branches';
+    } else {
+      const isJoin = role.effective === 'Converging';
+      groups.push(propertyGroup({
+        id: 'parallel-incoming', label: `${isJoin ? '汇聚入口' : '入口线路'} · ${role.incoming.length}`, collapsed: false, position: { after: 'gateway' },
+        description: isJoin ? '并行汇聚会等待所有入口到达后再继续。' : '当前角色尚未确定，仅展示已有入口线路。',
+        entries: [propertyEntry({ id: 'incoming-flows', type: 'flow-list', label: '', relation: 'source', emptyText: '当前并行网关没有入口线路', getValue: () => role.incoming })],
+      }));
+      groups.push(propertyGroup({
+        id: 'parallel-outgoing', label: `${isJoin ? '后续出口' : '出口线路'} · ${role.outgoing.length}`, collapsed: false, position: { after: 'parallel-incoming' },
+        description: isJoin ? '并行汇聚通常只连接一个后续节点。' : '当前角色尚未确定，仅展示已有出口线路。',
+        entries: [
+          propertyEntry({ id: 'outgoing-flows', type: 'flow-list', label: '', relation: 'target', emptyText: '当前并行网关没有出口线路', getValue: () => role.outgoing }),
+          ...(isJoin && role.outgoing.length === 0 ? [propertyEntry({ id: 'connect-parallel-next', type: 'action', label: '连接后续节点', actionLabel: '连接后续节点', iconId: 'ui.connect', action: (ctx) => ctx.designer.startConnect(ctx.element.id) })] : []),
+        ],
+      }));
+      structureAfter = 'parallel-outgoing';
+    }
+
+    const statusLabels = { valid: '结构正常', incomplete: '结构未完成', conflict: '结构冲突', ambiguous: '角色待判断' };
+    groups.push(propertyGroup({
+      id: 'parallel-structure', label: '结构校验', collapsed: false, position: { after: structureAfter },
+      entries: [
+        propertyEntry({ id: 'parallel-structure-summary', type: 'readonly', label: '线路结构', value: `${role.incoming.length} 入 · ${role.outgoing.length} 出` }),
+        propertyEntry({ id: 'parallel-structure-status', type: 'readonly', label: '状态', variant: role.status, value: statusLabels[role.status] }),
+        ...(role.issues.length ? [propertyEntry({ id: 'parallel-structure-issues', type: 'readonly', label: '提示', variant: role.status, value: role.issues.join('；') })] : []),
+      ],
+    }));
+    return groups;
+  },
+};
+
+const eventProvider = {
+  id: 'bpmn-events', priority: 750,
+  appliesTo: (ctx) => ctx.kind === 'node' && ['event', 'boundary'].includes(ctx.definition?.kind),
+  getGroups(context) {
+    const def = context.definition;
+    const entries = [];
+    if (def.eventDefinition === 'timer') entries.push(
+      propertyEntry({ id: 'timer-type', type: 'select', label: '定时类型', path: 'properties.timerType', options: [['duration', 'Duration'], ['date', 'Date'], ['cycle', 'Cycle']] }),
+      propertyEntry({ id: 'timer-value', type: 'expression', label: '时间表达式', path: 'properties.timerValue', placeholder: 'PT1H / 2026-08-26T09:00 / R3/PT10M' }),
+    );
+    if (def.eventDefinition === 'conditional') entries.push(propertyEntry({ id: 'event-condition', type: 'expression', label: '条件表达式', path: 'properties.condition', placeholder: '${approved == true}' }));
+    if (eventRefs[def.eventDefinition]) {
+      const meta = eventRefs[def.eventDefinition];
+      entries.push(propertyEntry({
+        id: 'event-ref', type: 'resource-select', label: meta.label, path: 'properties.eventRef', resource: meta.resource, allowCustom: true,
+        options: (ctx) => (ctx.model.resources?.[meta.resource] || []).map((item) => ({ value: item.id, label: `${item.name || item.id} · ${item.id}` })),
+        placeholder: '选择或输入资源 ID',
+      }));
+    }
+    if (def.eventDefinition === 'link') entries.push(propertyEntry({ id: 'link-name', label: 'Link Name', path: 'properties.eventRef', placeholder: 'Link_A' }));
+    if (def.eventDefinition === 'compensate') entries.push(
+      propertyEntry({ id: 'activity-ref', type: 'node-select', label: 'Activity Ref', path: 'properties.activityRef', nodeFilter: (node) => activityKinds.has(NODE_DEFINITIONS[node.type]?.kind) }),
+      propertyEntry({ id: 'wait-for-completion', type: 'switch', label: 'Wait For Completion', path: 'properties.waitForCompletion' }),
+    );
+    if ((def.eventStage === 'start' || (def.eventStage === 'intermediate' && def.eventRole === 'catch')) && ['message', 'signal'].includes(def.eventDefinition)) {
+      entries.push(propertyEntry({ id: 'parallel-multiple', type: 'switch', label: 'Parallel Multiple', path: 'properties.parallelMultiple' }));
+    }
+    if (!entries.length) entries.push(propertyEntry({ id: 'event-info', type: 'readonly', label: '事件定义', getValue: () => def.eventDefinition ? def.eventDefinition : 'None' }));
+    const groups = [propertyGroup({ id: 'event-definition', label: '事件定义', position: { after: 'basic' }, entries })];
+    if (def.kind === 'boundary') groups.push(propertyGroup({
+      id: 'boundary', label: '边界事件', position: { after: 'event-definition' }, entries: [
+        propertyEntry({ id: 'attached-to', type: 'node-select', label: '附着到活动', path: 'properties.attachedToRef', nodeFilter: (node) => activityKinds.has(NODE_DEFINITIONS[node.type]?.kind) }),
+        propertyEntry({ id: 'cancel-activity', type: 'switch', label: '中断主活动', path: 'properties.cancelActivity' }),
+      ],
+    }));
+    return groups;
+  },
+};
+
+const artifactProvider = {
+  id: 'bpmn-artifacts', priority: 730,
+  appliesTo: (ctx) => ctx.kind === 'node' && ['data', 'dataStore', 'annotation', 'group', 'participant', 'lane'].includes(ctx.definition?.kind),
+  getGroups(context) {
+    const type = context.element.type;
+    const entries = [];
+    if (type === 'textAnnotation') entries.push(propertyEntry({ id: 'annotation-text', type: 'textarea', label: '文本', path: 'properties.text', rows: 6 }), propertyEntry({ id: 'annotation-format', label: 'Text Format', path: 'properties.textFormat', placeholder: 'text/plain' }));
+    if (type === 'dataObjectReference') entries.push(propertyEntry({ id: 'data-object-ref', label: 'Data Object Ref', path: 'properties.dataObjectRef' }), propertyEntry({ id: 'data-state', label: 'Data State', path: 'properties.dataState' }));
+    if (type === 'dataStoreReference') entries.push(propertyEntry({ id: 'data-store-ref', label: 'Data Store Ref', path: 'properties.dataStoreRef' }), propertyEntry({ id: 'data-state', label: 'Data State', path: 'properties.dataState' }));
+    if (type === 'participant') entries.push(
+      propertyEntry({
+        id: 'swimlane-label-placement', type: 'select', label: '标题位置', path: 'properties.swimlaneLabelPlacement', defaultValue: 'side',
+        options: [['side', '左侧竖排'], ['top', '上方横排']],
+        note: '挂载到此 Pool 的 Lane 会继承该标题布局。',
+      }),
+      propertyEntry({ id: 'process-ref', label: 'Process Ref', path: 'properties.processRef' }),
+    );
+    if (type === 'lane') entries.push(
+      context.element.containerId
+        ? propertyEntry({
+            id: 'swimlane-label-placement-inherited', type: 'readonly', label: '标题位置',
+            getValue: (ctx) => resolveSwimlaneLabelPlacement(ctx.model, ctx.element) === 'top' ? '上方横排（跟随 Pool）' : '左侧竖排（跟随 Pool）',
+            note: '挂载 Lane 的标题布局由所属 Pool 统一控制。',
+          })
+        : propertyEntry({
+            id: 'swimlane-label-placement', type: 'select', label: '标题位置', path: 'properties.swimlaneLabelPlacement', defaultValue: 'side',
+            options: [['side', '左侧竖排'], ['top', '上方横排']],
+            note: '该设置仅影响编辑器展示，不写入标准 BPMN XML。',
+          }),
+      propertyEntry({ id: 'lane-members', type: 'node-list', label: '包含节点', getValue: (ctx) => ctx.element.properties?.flowNodeRefs || [], note: '节点拖入 Lane 后可由布局/containment 模块维护；此处用于检查当前引用。' }),
+    );
+    if (type === 'group') entries.push(propertyEntry({ id: 'category-value', label: 'Category Value', path: 'properties.categoryValue', placeholder: context.element.name }));
+    return entries.length ? [propertyGroup({ id: 'artifact', label: '元素配置', position: { after: 'basic' }, entries })] : [];
+  },
+};
+
+
+
+const nonSequenceEdgeProvider = {
+  id: 'bpmn-non-sequence-edge', priority: 845,
+  appliesTo: (ctx) => ctx.kind === 'edge' && ['messageFlow', 'association'].includes(ctx.element.type),
+  getGroups(context) {
+    const entries = context.element.type === 'messageFlow'
+      ? [propertyEntry({
+          id: 'message-flow-ref', type: 'resource-select', label: 'Message Ref', path: 'properties.messageRef', resource: 'messages', allowCustom: true,
+          options: (ctx) => (ctx.model.resources?.messages || []).map((item) => ({ value: item.id, label: `${item.name || item.id} · ${item.id}` })),
+        })]
+      : [propertyEntry({ id: 'association-direction', type: 'select', label: 'Association Direction', path: 'properties.associationDirection', options: [['None', 'None'], ['One', 'One'], ['Both', 'Both']] })];
+    return [propertyGroup({ id: 'edge-semantics', label: context.element.type === 'messageFlow' ? '消息流' : '关联', position: { after: 'basic' }, entries })];
+  },
+};
+
+const extensionElementsProvider = {
+  id: 'bpmn-extension-elements', priority: 110,
+  getGroups(context) {
+    return [propertyGroup({
+      id: 'extension-elements', label: 'Extension Elements', collapsed: true, position: { append: true },
+      description: '原始扩展 XML 会无损保留。推荐通过 Properties Provider + Engine/Extension serializer 管理结构化扩展；此处适合查看或维护少量未知扩展。',
+      entries: [propertyEntry({
+        id: 'raw-extension-elements', type: 'table', label: 'Raw XML',
+        getValue: (ctx) => (ctx.get('extensionElements', []) || []).map((xml) => ({ xml })),
+        setValue: (ctx, rows) => ctx.set('extensionElements', (rows || []).map((row) => row.xml).filter(Boolean)),
+        rowLabel: 'Extension Element', defaultRow: () => ({ xml: '<company:property value="" />' }), columns: [{ key: 'xml', label: 'XML' }],
+      })],
+    })];
+  },
+};
+
+const extensionAttributesProvider = {
+  id: 'bpmn-extension-attributes', priority: 120,
+  getGroups(context) {
+    const rootPath = 'properties.extensionAttributes';
+    return [propertyGroup({
+      id: 'extension-attributes', label: '扩展属性', collapsed: true, position: { append: true },
+      description: '用于企业自定义 namespace attribute。请同时在 Process 的 namespaceDeclarations 中注册对应 xmlns 前缀。未知 Extension Elements 在导入/导出时仍会保留。',
+      entries: [propertyEntry({
+        id: 'extension-attribute-table', type: 'table', label: 'Custom Attributes',
+        getValue: (ctx) => Object.entries(ctx.get(rootPath, {}) || {}).map(([name, value]) => ({ name, value })),
+        setValue: (ctx, rows) => ctx.set(rootPath, Object.fromEntries((rows || []).filter((row) => row.name).map((row) => [row.name, row.value || '']))),
+        rowLabel: '属性', defaultRow: () => ({ name: 'company:property', value: '' }), columns: [{ key: 'name', label: 'QName' }, { key: 'value', label: 'Value' }],
+      })],
+    })];
+  },
+};
+
+const destructiveActionsProvider = {
+  id: 'bpmn-actions', priority: 20,
+  appliesTo: (ctx) => ctx.kind === 'node' || ctx.kind === 'edge',
+  getGroups() {
+    return [propertyGroup({
+      id: 'element-actions', label: '元素操作', collapsed: true, position: { append: true },
+      entries: [propertyEntry({ id: 'delete-element', type: 'action', label: '删除当前元素', actionLabel: '删除元素', variant: 'danger', action: (ctx) => ctx.studio.commands.remove() })],
+    })];
+  },
+};
+export const bpmnPropertiesProviders = [
+  basicProvider,
+  processProvider,
+  sequenceFlowProvider,
+  gatewayProvider,
+  eventProvider,
+  scriptProvider,
+  callActivityProvider,
+  messageTaskProvider,
+  subProcessProvider,
+  artifactProvider,
+  activityProvider,
+  documentationProvider,
+  nonSequenceEdgeProvider,
+  extensionAttributesProvider,
+  extensionElementsProvider,
+  destructiveActionsProvider,
+];
+
+export function registerBpmnProperties(registry) {
+  const disposers = bpmnPropertiesProviders.map((provider) => registry.registerProvider(provider.priority ?? 500, provider));
+  return () => disposers.forEach((dispose) => dispose());
+}