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

package/dist/modules/core/scope.js

@@ -0,0 +1,99 @@
+export const EMBEDDED_SUBPROCESS_TYPES = new Set(['subProcess', 'eventSubProcess', 'transaction', 'adHocSubProcess']);
+
+export function isEmbeddedSubProcess(nodeOrType) {
+  return EMBEDDED_SUBPROCESS_TYPES.has(typeof nodeOrType === 'string' ? nodeOrType : nodeOrType?.type);
+}
+
+export function elementScopeId(model, element) {
+  return element?.scopeId || model?.id || '';
+}
+
+export function scopeExists(model, scopeId) {
+  return scopeId === model?.id || model?.nodes?.some((node) => node.id === scopeId && isEmbeddedSubProcess(node));
+}
+
+export function getScopeOwner(model, scopeId) {
+  if (!model || scopeId === model.id) return model || null;
+  return model.nodes.find((node) => node.id === scopeId && isEmbeddedSubProcess(node)) || null;
+}
+
+export function getParentScopeId(model, scopeId) {
+  if (!model || scopeId === model.id) return null;
+  const owner = getScopeOwner(model, scopeId);
+  return owner ? elementScopeId(model, owner) : null;
+}
+
+export function getScopePath(model, scopeId = model?.id) {
+  if (!model) return [];
+  const chain = [];
+  const seen = new Set();
+  let current = scopeExists(model, scopeId) ? scopeId : model.id;
+  while (current && current !== model.id && !seen.has(current)) {
+    seen.add(current);
+    const owner = getScopeOwner(model, current);
+    if (!owner) break;
+    chain.unshift({ id: owner.id, name: owner.name || owner.id, kind: 'subProcess' });
+    current = elementScopeId(model, owner);
+  }
+  return [{ id: model.id, name: model.name || model.id, kind: 'process' }, ...chain];
+}
+
+export function getScopeGraph(model, scopeId = model?.id) {
+  if (!model) return { nodes: [], edges: [] };
+  const activeScopeId = scopeExists(model, scopeId) ? scopeId : model.id;
+  return {
+    ...model,
+    nodes: model.nodes.filter((node) => elementScopeId(model, node) === activeScopeId),
+    edges: model.edges.filter((edge) => elementScopeId(model, edge) === activeScopeId),
+  };
+}
+
+export function getDescendantScopeIds(model, ownerId) {
+  const scopes = new Set();
+  const queue = [ownerId];
+  while (queue.length) {
+    const scopeId = queue.shift();
+    if (scopes.has(scopeId)) continue;
+    scopes.add(scopeId);
+    for (const node of model.nodes) {
+      if (elementScopeId(model, node) === scopeId && isEmbeddedSubProcess(node)) queue.push(node.id);
+    }
+  }
+  return scopes;
+}
+
+export function hasScopeChildren(model, ownerId) {
+  return model.nodes.some((node) => elementScopeId(model, node) === ownerId)
+    || model.edges.some((edge) => elementScopeId(model, edge) === ownerId);
+}
+
+export function getScopeIntegrityIssues(model) {
+  if (!model) return [];
+  const issues = [];
+  for (const node of model.nodes || []) {
+    const scopeId = elementScopeId(model, node);
+    if (!scopeExists(model, scopeId)) issues.push({ kind: 'node', id: node.id, scopeId, reason: 'missing-scope' });
+    else {
+      const seen = new Set();
+      let current = scopeId;
+      while (current !== model.id && scopeExists(model, current)) {
+        if (seen.has(current)) {
+          issues.push({ kind: 'node', id: node.id, scopeId, reason: 'cyclic-scope' });
+          break;
+        }
+        seen.add(current);
+        current = getParentScopeId(model, current);
+      }
+    }
+  }
+  for (const edge of model.edges || []) {
+    const scopeId = elementScopeId(model, edge);
+    const source = model.nodes.find((node) => node.id === edge.source);
+    const target = model.nodes.find((node) => node.id === edge.target);
+    if (!scopeExists(model, scopeId)) issues.push({ kind: 'edge', id: edge.id, scopeId, reason: 'missing-scope' });
+    if (source && target && (elementScopeId(model, source) !== scopeId || elementScopeId(model, target) !== scopeId)) {
+      issues.push({ kind: 'edge', id: edge.id, scopeId, reason: 'cross-scope' });
+    }
+  }
+  return issues;
+}

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

@@ -0,0 +1,79 @@
+import type {
+  BpmnEdge,
+  BpmnNode,
+  EngineId,
+  ElementSelection,
+  LayoutOptions,
+  NodeType,
+  ProcessModel,
+} from '../core/index.js'
+import type { DiagramRenderer } from '../renderer-svg/index.js'
+import type { NovaThemeInput, NovaThemeMode, NovaThemeState, ThemeController } from '../theme/index.js'
+import type { SvgExportArtifact, SvgExportOptions, SvgExportPreviewController, SvgNodeRenderer } from '../export-svg/index.js'
+
+export interface DesignerState {
+  selection: ElementSelection | null
+  connectingSource: string | null
+  canUndo: boolean
+  canRedo: boolean
+  engine: EngineId
+}
+export interface DesignerOptions {
+  container: HTMLElement
+  model: ProcessModel
+  historyLimit?: number
+  onChange?: (model: ProcessModel, reason: string) => void
+  onSelectionChange?: (selection: ElementSelection | null, element: BpmnNode | BpmnEdge | null) => void
+  onStateChange?: (state: DesignerState) => void
+  onViewportChange?: (state: { zoom: number; pan: { x: number; y: number } }) => void
+  themeController?: ThemeController
+  theme?: NovaThemeInput
+  onThemeChange?: (state: NovaThemeState) => void
+  svgExport?: SvgExportOptions & { label?: string; nodeRenderers?: Record<string, SvgNodeRenderer> }
+}
+
+export function normalizeCanvasCoordinate(value: unknown): number
+export function canSequenceConnect(model: ProcessModel, sourceId: string, targetId: string): boolean
+export class BpmnDesigner {
+  constructor(options: DesignerOptions)
+  model: ProcessModel
+  selection: ElementSelection | null
+  connectingSource: string | null
+  renderer: DiagramRenderer
+  properties?: unknown
+  getSelectedElement(): BpmnNode | BpmnEdge | null
+  getState(): DesignerState
+  setModel(model: ProcessModel, options?: { resetHistory?: boolean }): void
+  select(selection: ElementSelection): void
+  clearSelection(): void
+  on(event: 'change', handler: (payload: { model: ProcessModel; reason: string; state: DesignerState }) => void): () => void
+  on(event: 'selection', handler: (payload: { selection: ElementSelection | null; element: BpmnNode | BpmnEdge | null; state: DesignerState }) => void): () => void
+  off(event: 'change' | 'selection', handler: Function): void
+  exportXml(engine?: EngineId): string
+  exportSvg(options?: SvgExportOptions): Promise<SvgExportArtifact>
+  openSvgExportPreview(options?: SvgExportOptions & { previewTitle?: string; onDownload?: (artifact: SvgExportArtifact) => void }): SvgExportPreviewController
+  importXml(xml: string, engineHint?: EngineId): ProcessModel
+  validate(): Array<{ level: 'error' | 'warning'; elementId?: string; message: string }>
+  setTheme(theme: NovaThemeInput): NovaThemeState
+  setThemeMode(mode: NovaThemeMode): NovaThemeState
+  getThemeState(): NovaThemeState
+  addNode(type: NodeType, x: number, y: number, overrides?: Partial<BpmnNode>): BpmnNode
+  quickAdd(sourceId: string, type?: NodeType, preset?: Partial<BpmnNode>): BpmnNode | null
+  startConnect(sourceId: string): void
+  connect(source: string, target: string, overrides?: Partial<BpmnEdge>): BpmnEdge | null
+  changeNodeType(id: string, type: NodeType): void
+  changeElementId(kind: 'process' | 'node' | 'edge', oldId: string, nextId: string): boolean
+  updateProcess(patch: Partial<ProcessModel>): void
+  updateNode(id: string, patch: Partial<BpmnNode>): void
+  updateEdge(id: string, patch: Partial<BpmnEdge>): void
+  updateEdges(patches: Array<{ id: string; patch: Partial<BpmnEdge> }>): void
+  resetEdgeRoute(id: string): void
+  rerouteEdges(options?: LayoutOptions): void
+  autoLayout(direction?: 'horizontal' | 'vertical'): void
+  beautify(options?: LayoutOptions): void
+  removeSelection(): void
+  setEngine(engine: EngineId): void
+  undo(): void
+  redo(): void
+  destroy(): void
+}