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

package/dist/modules/core/index.d.ts

@@ -0,0 +1,268 @@
+export type EngineId = 'flowable' | 'activiti'
+export type NodeType =
+  | 'startEvent' | 'messageStartEvent' | 'timerStartEvent' | 'conditionalStartEvent' | 'signalStartEvent' | 'errorStartEvent' | 'escalationStartEvent' | 'compensationStartEvent'
+  | 'intermediateCatchEvent' | 'messageIntermediateCatchEvent' | 'timerIntermediateCatchEvent' | 'conditionalIntermediateCatchEvent' | 'signalIntermediateCatchEvent' | 'linkIntermediateCatchEvent'
+  | 'intermediateThrowEvent' | 'messageIntermediateThrowEvent' | 'escalationIntermediateThrowEvent' | 'signalIntermediateThrowEvent' | 'linkIntermediateThrowEvent' | 'compensationIntermediateThrowEvent'
+  | 'timerBoundaryEvent' | 'messageBoundaryEvent' | 'errorBoundaryEvent' | 'escalationBoundaryEvent' | 'signalBoundaryEvent' | 'conditionalBoundaryEvent' | 'compensationBoundaryEvent'
+  | 'endEvent' | 'messageEndEvent' | 'errorEndEvent' | 'escalationEndEvent' | 'cancelEndEvent' | 'compensationEndEvent' | 'signalEndEvent' | 'terminateEndEvent'
+  | 'task' | 'userTask' | 'manualTask' | 'serviceTask' | 'scriptTask' | 'businessRuleTask' | 'sendTask' | 'receiveTask' | 'callActivity'
+  | 'subProcess' | 'eventSubProcess' | 'transaction' | 'adHocSubProcess'
+  | 'exclusiveGateway' | 'parallelGateway' | 'inclusiveGateway' | 'eventBasedGateway' | 'complexGateway'
+  | 'dataObjectReference' | 'dataStoreReference' | 'textAnnotation' | 'group' | 'participant' | 'lane'
+
+export type EdgeType = 'sequenceFlow' | 'messageFlow' | 'association'
+export type NodeKind = 'event' | 'boundary' | 'task' | 'container' | 'gateway' | 'data' | 'dataStore' | 'annotation' | 'group' | 'participant' | 'lane'
+export type SwimlaneLabelPlacement = 'side' | 'top'
+export interface Point { x: number; y: number }
+export interface SelectionRect { x: number; y: number; width: number; height: number }
+export interface ExtensionAttributeMap { [qualifiedName: string]: string }
+
+export interface BpmnNodeProperties extends Record<string, unknown> {
+  extensionAttributes?: ExtensionAttributeMap
+  swimlaneLabelPlacement?: SwimlaneLabelPlacement
+  flowNodeRefs?: string[]
+  processRef?: string
+  attachedToRef?: string
+  categoryValue?: string
+}
+
+export interface BpmnNode {
+  id: string
+  type: NodeType
+  bpmnType: string
+  name: string
+  x: number
+  y: number
+  width: number
+  height: number
+  scopeId?: string
+  containerId?: string
+  isExpanded?: boolean
+  properties: BpmnNodeProperties
+  unknownAttributes?: Array<{ name: string; value: string }>
+  extensionElements?: string[]
+}
+
+export interface BpmnEdge {
+  id: string
+  type?: EdgeType
+  source: string
+  target: string
+  scopeId?: string
+  name?: string
+  condition?: string
+  isDefault?: boolean
+  waypoints?: Point[] | null
+  routeStyle?: 'rounded' | 'smooth' | 'straight'
+  cornerRadius?: number
+  properties?: Record<string, unknown> & { extensionAttributes?: ExtensionAttributeMap }
+  unknownAttributes?: Array<{ name: string; value: string }>
+  extensionElements?: string[]
+}
+
+export type ElementSelection =
+  | { kind: 'process'; id: string }
+  | { kind: 'node' | 'edge'; id: string }
+  | { kind: 'multi'; items: Array<{ kind: 'node' | 'edge'; id: string }> }
+
+export interface ProcessResource { id: string; name?: string }
+export interface ProcessModel {
+  id: string
+  name: string
+  engine: EngineId
+  isExecutable: boolean
+  targetNamespace: string
+  namespaceDeclarations: Record<string, string>
+  properties: Record<string, unknown> & { extensionAttributes?: ExtensionAttributeMap }
+  resources: {
+    messages: ProcessResource[]
+    signals: ProcessResource[]
+    errors: Array<ProcessResource & { errorCode?: string }>
+    escalations: Array<ProcessResource & { escalationCode?: string }>
+  }
+  extensionElements?: string[]
+  nodes: BpmnNode[]
+  edges: BpmnEdge[]
+  settings?: {
+    direction?: 'horizontal' | 'vertical'
+    layoutDensity?: 'compact' | 'balanced' | 'spacious'
+    edgeStyle?: 'rounded' | 'smooth' | 'straight'
+    cornerRadius?: number
+    showGrid?: boolean
+    gridSize?: number
+    snapToGrid?: boolean
+    alignmentGuides?: boolean
+    alignmentThreshold?: number
+    mergeGatewayConnections?: boolean
+  }
+}
+
+export interface NodeDefinition {
+  bpmnType: string
+  localName: string
+  label: string
+  icon: string
+  kind: NodeKind
+  width: number
+  height: number
+  palette?: string
+  eventStage?: 'start' | 'intermediate' | 'boundary' | 'end'
+  eventRole?: 'catch' | 'throw'
+  eventDefinition?: string | null
+  activityKind?: string
+}
+
+export const NODE_DEFINITIONS: Record<NodeType | 'generic', NodeDefinition>
+export const PALETTE_GROUPS: Array<{ id: string; label: string; types: NodeType[] }>
+export const EDGE_DEFINITIONS: Record<EdgeType, { bpmnType: string; label: string }>
+export function uid(prefix?: string): string
+export function createNode(type: NodeType, x?: number, y?: number, overrides?: Partial<BpmnNode>): BpmnNode
+export function createEdge(source: string, target: string, overrides?: Partial<BpmnEdge>): BpmnEdge
+export function createEmptyProcess(engine?: EngineId): ProcessModel
+export function cloneModel<T extends ProcessModel>(model: T): T
+export function getNode(model: ProcessModel, id: string): BpmnNode | null
+export function getEdge(model: ProcessModel, id: string): BpmnEdge | null
+export function clearConnectedWaypoints(model: ProcessModel, nodeId: string): void
+export function createSampleProcess(engine?: EngineId): ProcessModel
+
+export class HistoryStack {
+  constructor(limit?: number)
+  readonly canUndo: boolean
+  readonly canRedo: boolean
+  capture(model: ProcessModel): void
+  undo(current: ProcessModel): ProcessModel | null
+  redo(current: ProcessModel): ProcessModel | null
+}
+
+export interface SnapNodePositionOptions {
+  threshold?: number
+  disabled?: boolean
+}
+export interface AlignmentGuide {
+  orientation: 'horizontal' | 'vertical'
+  position: number
+  kind: 'center' | 'edge'
+}
+export interface SnapNodePositionResult { x: number; y: number; guides: AlignmentGuide[] }
+export type NodeSide = 'top' | 'right' | 'bottom' | 'left'
+export function smartAnchors(source: BpmnNode, target: BpmnNode): { sourceSide: NodeSide; targetSide: NodeSide }
+export function snapNodePosition(model: ProcessModel, node: BpmnNode, x: number, y: number, options?: SnapNodePositionOptions): SnapNodePositionResult
+export function edgeWaypoints(model: ProcessModel, edge: BpmnEdge): Point[]
+export function roundedPath(points: Point[], radius?: number): string
+export function smoothPath(points: Point[], radius?: number): string
+export const LAYOUT_DENSITIES: Readonly<Record<'compact' | 'balanced' | 'spacious', Readonly<{ rankGap: number; nodeGap: number; label: string }>>>
+export interface LayoutOptions {
+  direction?: 'horizontal' | 'vertical'
+  density?: 'compact' | 'balanced' | 'spacious'
+  compact?: boolean
+  startX?: number
+  startY?: number
+  rankGap?: number
+  nodeGap?: number
+  edgeStyle?: 'rounded' | 'smooth' | 'straight'
+  cornerRadius?: number
+  gridSize?: number
+  snapToGrid?: boolean
+  alignmentThreshold?: number
+  mergeGatewayConnections?: boolean
+}
+export function autoLayout(model: ProcessModel, options?: LayoutOptions): ProcessModel
+export function beautify(model: ProcessModel, options?: LayoutOptions): ProcessModel
+
+export const EMBEDDED_SUBPROCESS_TYPES: ReadonlySet<NodeType>
+export function isEmbeddedSubProcess(nodeOrType: BpmnNode | NodeType | null | undefined): boolean
+export function elementScopeId(model: ProcessModel, element?: BpmnNode | BpmnEdge | null): string
+export function scopeExists(model: ProcessModel, scopeId: string): boolean
+export type ScopeOwner = ProcessModel | BpmnNode
+export function getScopeOwner(model: ProcessModel, scopeId: string): ScopeOwner | null
+export function getParentScopeId(model: ProcessModel, scopeId: string): string | null
+export function getScopePath(model: ProcessModel, scopeId?: string): Array<{ id: string; name: string; kind: 'process' | 'subProcess' }>
+export function getScopeGraph(model: ProcessModel, scopeId?: string): ProcessModel
+export function getDescendantScopeIds(model: ProcessModel, ownerId: string): string[]
+export function hasScopeChildren(model: ProcessModel, ownerId: string): boolean
+export interface ScopeIntegrityIssue {
+  kind: 'node' | 'edge'
+  id: string
+  scopeId: string
+  reason: 'missing-scope' | 'cyclic-scope' | 'cross-scope'
+}
+export function getScopeIntegrityIssues(model: ProcessModel): ScopeIntegrityIssue[]
+
+export const CONTAINMENT_LIMITS: Readonly<{
+  groupMinWidth: 120; groupMinHeight: 80; groupPadding: 28
+  participantMinWidth: 320; participantMinHeight: 120
+  laneMinWidth: 240; laneMinHeight: 72; swimlaneTitleSize: 38
+  participantRailWidth: 38; participantContentPadding: 24
+}>
+export const SWIMLANE_LABEL_PLACEMENTS: Readonly<{ side: 'side'; top: 'top' }>
+export type ContainmentOperation =
+  | { type: 'reconcile'; inferOwners?: boolean; normalize?: boolean }
+  | { type: 'attach-lane'; laneId: string; participantId: string; index?: number }
+  | { type: 'detach-lane'; laneId: string; x?: number; y?: number; preservePosition?: boolean }
+  | { type: 'reorder-lane'; laneId: string; index: number }
+  | { type: 'assign-node'; nodeId: string }
+  | { type: 'assign-all' }
+  | { type: 'move-container'; nodeId: string; dx: number; dy: number }
+  | { type: 'resize-container'; nodeId: string; bounds: SelectionRect }
+  | { type: 'resize-divider'; laneId: string; delta: number }
+  | { type: 'update-label-placement'; nodeId: string; previousPlacement: SwimlaneLabelPlacement }
+  | { type: 'prepare-remove'; nodeId: string }
+export interface ContainmentResolution {
+  nodesById: Map<string, BpmnNode>
+  lanesByParticipant: Map<string, BpmnNode[]>
+  laneByNode: Map<string, BpmnNode>
+  getParticipantLanes(participantId: string): BpmnNode[]
+  getLaneForNode(nodeId: string): BpmnNode | null
+  getLaneAt(point: Point, excludedId?: string): BpmnNode | null
+  getParticipantAt(point: Point): BpmnNode | null
+}
+export function resolveSwimlaneLabelPlacement(model: ProcessModel, node: BpmnNode): SwimlaneLabelPlacement
+export function getSwimlaneContentInsets(model: ProcessModel, node: BpmnNode): { top: number; right: number; bottom: number; left: number }
+export function getSwimlaneContentBounds(model: ProcessModel, node: BpmnNode): SelectionRect
+export function resolveContainment(model: ProcessModel): ContainmentResolution
+export function applyContainmentOperation(model: ProcessModel, operation?: ContainmentOperation): { changed: boolean }
+
+export interface GatewayRoleResolution {
+  declared: 'Unspecified' | 'Diverging' | 'Converging' | 'Mixed'
+  inferred: 'Unspecified' | 'Diverging' | 'Converging' | 'Mixed'
+  effective: 'Unspecified' | 'Diverging' | 'Converging' | 'Mixed'
+  incoming: BpmnEdge[]
+  outgoing: BpmnEdge[]
+  topologyComplete: boolean
+  status: 'valid' | 'incomplete' | 'conflict' | 'ambiguous'
+  issues: string[]
+}
+export const PARALLEL_GATEWAY_PRESETS: Readonly<Record<'diverging' | 'converging', Readonly<{ id: string; label: string; iconId: string; nodeType: 'parallelGateway'; preset: Partial<BpmnNode> }>>>
+export function resolveGatewayRole(model: ProcessModel, node: BpmnNode): GatewayRoleResolution
+export function validateParallelGateway(model: ProcessModel, node: BpmnNode): string[]
+
+export interface RuntimeTransitionRouteOptions {
+  occupiedRoutes?: Array<Point[] | { points: Point[] }>
+  obstacles?: SelectionRect[]
+  labelSize?: { width: number; height: number }
+  nodeClearance?: number
+  laneGap?: number
+  laneSpacing?: number
+  nearParallelDistance?: number
+  anchorOverlapTolerance?: number
+  maxLanesPerSide?: number
+}
+export interface RuntimeTransitionRoute {
+  points: Point[]
+  labelPoint: Point
+  direction: 'horizontal' | 'vertical'
+  laneSide: 'top' | 'bottom' | 'left' | 'right'
+  laneIndex: number
+  sourceSide: 'top' | 'right' | 'bottom' | 'left'
+  targetSide: 'top' | 'right' | 'bottom' | 'left'
+  anchorStrategy: 'outer-same-side' | 'flow-axis-fallback'
+  portConflicts: number
+  nodeHits: number
+  overlapLength: number
+  nearParallelLength: number
+  crossings: number
+  bends: number
+  length: number
+  labelConflicts: number
+}
+export function routeRuntimeTransition(model: ProcessModel, transition: { sourceElementId: string; targetElementId?: string; [key: string]: unknown }, options?: RuntimeTransitionRouteOptions): RuntimeTransitionRoute | null

package/dist/modules/core/index.js

@@ -0,0 +1,7 @@
+export * from './model.js';
+export * from './history.js';
+export * from './layout.js';
+export * from './scope.js';
+export * from './containment.js';
+export * from './gateway.js';
+export * from './runtime-transition-route.js';