anx-esop-engine 1.0.0

package/README.md

@@ -0,0 +1,66 @@
+# convert-bpmn-to-react-flow
+
+Convert BPMN XML to a React Flow friendly domain model and export it back to BPMN XML.
+
+## Installation
+
+```bash
+npm install convert-bpmn-to-react-flow
+```
+
+## Usage
+
+```ts
+import {
+  BpmnImporter,
+  BpmnExporter,
+  BpmnValidator,
+  type DomainWorkflow,
+} from 'convert-bpmn-to-react-flow';
+
+const workflow: DomainWorkflow = await BpmnImporter.importXml(xmlString);
+
+const validation = BpmnValidator.validateWorkflow(workflow.nodes, workflow.edges);
+
+const exportedXml = await BpmnExporter.exportToXml(workflow);
+```
+
+## API
+
+- `BpmnImporter.importXml(xml: string): Promise<DomainWorkflow>`
+- `BpmnExporter.exportToXml(workflow: DomainWorkflow): Promise<string>`
+- `BpmnLayout.applyAutoLayout(nodes, edges, direction?)`
+- `BpmnValidator.canConnect(source, target, connectionType)`
+- `BpmnValidator.validateWorkflow(nodes, edges)`
+- `REPLACE_OPTIONS`
+
+## Publish Checklist
+
+1. Update package name/version in package.json.
+2. Ensure repository URL points to your GitHub repo.
+3. Login with `npm login`.
+4. Run `npm run publish:dry` to verify.
+5. Run `npm run publish:ps1` to publish.
+
+## PowerShell Publish Script
+
+The project includes [scripts/publish.ps1](scripts/publish.ps1) with these options:
+
+- `-DryRun`: publish dry-run
+- `-Tag <tag>`: publish tag, default `latest`
+- `-Access <public|restricted>`: npm access, default `public`
+- `-Otp <code>`: OTP for 2FA publish
+- `-SkipChecks`: skip `npm whoami`, build, and pack checks
+
+Examples:
+
+```powershell
+# Dry run with checks
+powershell -ExecutionPolicy Bypass -File .\scripts\publish.ps1 -DryRun
+
+# Real publish
+powershell -ExecutionPolicy Bypass -File .\scripts\publish.ps1
+
+# Publish with beta tag
+powershell -ExecutionPolicy Bypass -File .\scripts\publish.ps1 -Tag beta
+```

package/dist/BpmnLayout-27HW6WAW.mjs

@@ -0,0 +1,6 @@
+import {
+  BpmnLayout
+} from "./chunk-ZM2PR2CO.mjs";
+export {
+  BpmnLayout
+};

package/dist/chunk-ZM2PR2CO.mjs

@@ -0,0 +1,179 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/bpmn/BpmnLayout.ts
+var BpmnLayout = class {
+  /**
+   * Applies an automatic layout to nodes and edges using Dagre if available,
+   * otherwise falling back to a structured grid layout.
+   */
+  static async applyAutoLayout(nodes, edges, direction = "LR") {
+    if (nodes.length === 0) return [];
+    try {
+      const dagre = (await import("@dagrejs/dagre")).default;
+      const g = new dagre.graphlib.Graph();
+      g.setGraph({ rankdir: direction, align: "UL", nodesep: 70, edgesep: 50, ranksep: 100 });
+      g.setDefaultEdgeLabel(() => ({}));
+      const getDims = (node) => {
+        if (node.isExpanded) {
+          if (node.type === "boundaryEvent" || node.type === "start" || node.type === "end" || node.type === "intermediateCatch" || node.type === "intermediateThrow") {
+            return { w: 96, h: 96 };
+          }
+          if (["subProcess", "eventSubProcess", "transaction", "adhocSubProcess"].includes(node.type)) {
+            return { w: 260, h: 140 };
+          }
+          return { w: 244, h: 120 };
+        } else {
+          if (["start", "end", "boundaryEvent", "intermediateCatch", "intermediateThrow"].includes(node.type)) return { w: 44, h: 44 };
+          if (["exclusiveGateway", "parallelGateway", "inclusiveGateway"].includes(node.type)) return { w: 48, h: 48 };
+          return { w: 100, h: 80 };
+        }
+      };
+      nodes.forEach((node) => {
+        if (node.type === "pool" || node.type === "lane") return;
+        const { w, h } = getDims(node);
+        g.setNode(node.id, { width: w, height: h });
+      });
+      edges.forEach((edge) => {
+        if (edge.semantic === "control" && g.hasNode(edge.source) && g.hasNode(edge.target)) {
+          g.setEdge(edge.source, edge.target);
+        }
+      });
+      dagre.layout(g);
+      let laidOutNodes = nodes.map((node) => {
+        if (node.type === "pool" || node.type === "lane") {
+          return { ...node };
+        }
+        const layoutNode = g.node(node.id);
+        if (layoutNode) {
+          const { w, h } = getDims(node);
+          return {
+            ...node,
+            position: {
+              x: Math.round(layoutNode.x - w / 2),
+              y: Math.round(layoutNode.y - h / 2)
+            },
+            width: w,
+            height: h
+          };
+        }
+        return { ...node };
+      });
+      const LANE_PADDING = 40;
+      const POOL_HEADER_W = 32;
+      laidOutNodes = laidOutNodes.map((node) => {
+        if (node.type !== "lane") return node;
+        const children = laidOutNodes.filter((n) => n.parentId === node.id);
+        if (children.length === 0) return node;
+        const minX = Math.min(...children.map((c) => c.position.x));
+        const maxX = Math.max(...children.map((c) => c.position.x + (c.width || 100)));
+        const minY = Math.min(...children.map((c) => c.position.y));
+        const maxY = Math.max(...children.map((c) => c.position.y + (c.height || 80)));
+        return {
+          ...node,
+          position: { x: minX - LANE_PADDING, y: minY - LANE_PADDING },
+          width: maxX - minX + LANE_PADDING * 2,
+          height: maxY - minY + LANE_PADDING * 2
+        };
+      });
+      laidOutNodes = laidOutNodes.map((node) => {
+        if (node.type !== "pool") return node;
+        const lanes = laidOutNodes.filter((n) => n.parentId === node.id && n.type === "lane");
+        const directChildren = laidOutNodes.filter((n) => n.parentId === node.id && n.type !== "lane");
+        const candidates = lanes.length > 0 ? lanes : directChildren;
+        if (candidates.length === 0) return node;
+        const minX = Math.min(...candidates.map((c) => c.position.x));
+        const maxX = Math.max(...candidates.map((c) => c.position.x + c.width));
+        const minY = Math.min(...candidates.map((c) => c.position.y));
+        const maxY = Math.max(...candidates.map((c) => c.position.y + (c.height || 80)));
+        return {
+          ...node,
+          position: { x: minX - POOL_HEADER_W, y: minY },
+          width: maxX - minX + POOL_HEADER_W,
+          height: maxY - minY
+        };
+      });
+      const absolutePositions = /* @__PURE__ */ new Map();
+      laidOutNodes.forEach((n) => absolutePositions.set(n.id, { x: n.position.x, y: n.position.y }));
+      return laidOutNodes.map((node) => {
+        if (node.parentId) {
+          const parentPos = absolutePositions.get(node.parentId);
+          if (parentPos) {
+            return {
+              ...node,
+              position: {
+                x: node.position.x - parentPos.x,
+                y: node.position.y - parentPos.y
+              }
+            };
+          }
+        }
+        return node;
+      });
+    } catch (e) {
+      console.warn("Dagre layout failed or unavailable, falling back to grid layout:", e);
+      return this.applyGridLayout(nodes);
+    }
+  }
+  /**
+   * Simple grid-based fallback layout when Dagre is unavailable
+   */
+  static applyGridLayout(nodes) {
+    const spacingX = 200;
+    const spacingY = 150;
+    const itemsPerRow = 5;
+    const laidOutNodes = nodes.map((node, index) => {
+      const row = Math.floor(index / itemsPerRow);
+      const col = index % itemsPerRow;
+      return {
+        ...node,
+        position: {
+          x: col * spacingX + 50,
+          y: row * spacingY + 50
+        }
+      };
+    });
+    const absolutePositions = /* @__PURE__ */ new Map();
+    laidOutNodes.forEach((n) => absolutePositions.set(n.id, { x: n.position.x, y: n.position.y }));
+    return laidOutNodes.map((node) => {
+      if (node.parentId) {
+        const parentPos = absolutePositions.get(node.parentId);
+        if (parentPos) {
+          return {
+            ...node,
+            position: {
+              x: node.position.x - parentPos.x,
+              y: node.position.y - parentPos.y
+            }
+          };
+        }
+      }
+      return node;
+    });
+  }
+};
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  BpmnLayout
+};

package/dist/index.d.mts

@@ -0,0 +1,233 @@
+import React from 'react';
+import * as zustand from 'zustand';
+
+interface DomainNode {
+    id: string;
+    type: 'start' | 'end' | 'task' | 'userTask' | 'serviceTask' | 'scriptTask' | 'manualTask' | 'exclusiveGateway' | 'parallelGateway' | 'inclusiveGateway' | 'subProcess' | 'eventSubProcess' | 'transaction' | 'adhocSubProcess' | 'boundaryEvent' | 'intermediateCatch' | 'intermediateThrow' | 'textAnnotation' | 'dataStoreReference' | 'dataObjectReference' | 'pool' | 'lane' | 'custom';
+    label: string;
+    bpmnType: string;
+    documentation?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    parentId?: string;
+    attachedTo?: string;
+    eventType?: string;
+    isExpanded: boolean;
+    properties: Record<string, any>;
+}
+interface DomainEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    sourceSide?: 'top' | 'right' | 'bottom' | 'left';
+    targetSide?: 'top' | 'right' | 'bottom' | 'left';
+    label?: string;
+    bpmnType: string;
+    conditionExpression?: string;
+    semantic: 'control' | 'message' | 'data' | 'annotation';
+    isDefault?: boolean;
+    isConditional?: boolean;
+    associationDirection?: 'none' | 'one' | 'both';
+    waypoints?: {
+        x: number;
+        y: number;
+    }[];
+    properties?: Record<string, any>;
+}
+interface DomainPool {
+    id: string;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    lanes: DomainLane[];
+}
+interface DomainLane {
+    id: string;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+}
+interface DomainWorkflow {
+    id: string;
+    name: string;
+    nodes: DomainNode[];
+    edges: DomainEdge[];
+    pools?: DomainPool[];
+}
+
+declare class BpmnImporter {
+    /**
+     * Imports a BPMN XML string and converts it to a clean DomainWorkflow model.
+     * Leverages bpmn-moddle with automatic fallback to DOMParser.
+     */
+    static importXml(xml: string): Promise<DomainWorkflow>;
+    private static parseWithBpmnModdle;
+    private static parseWithDOMParser;
+}
+
+declare class BpmnExporter {
+    /**
+     * Serializes a BPMN DomainWorkflow back to standard BPMN 2.0 XML string.
+     */
+    static exportToXml(workflow: DomainWorkflow): Promise<string>;
+}
+
+declare class BpmnLayout {
+    /**
+     * Applies an automatic layout to nodes and edges using Dagre if available,
+     * otherwise falling back to a structured grid layout.
+     */
+    static applyAutoLayout(nodes: DomainNode[], edges: DomainEdge[], direction?: 'LR' | 'TB'): Promise<DomainNode[]>;
+    /**
+     * Simple grid-based fallback layout when Dagre is unavailable
+     */
+    private static applyGridLayout;
+}
+
+interface ValidationError {
+    elementId: string;
+    severity: 'error' | 'warning';
+    message: string;
+}
+declare class BpmnValidator {
+    /**
+     * Evaluates if a connection is semantically valid under BPMN 2.0 specifications.
+     * Checks source/target node types against the connection type.
+     */
+    static canConnect(source: DomainNode, target: DomainNode, connectionType: 'control' | 'message' | 'data' | 'annotation'): {
+        isValid: boolean;
+        reason?: string;
+    };
+    /**
+     * Validates the graph structure of a DomainWorkflow and returns warnings/errors.
+     */
+    static validateWorkflow(nodes: DomainNode[], edges: DomainEdge[]): ValidationError[];
+}
+
+interface ReplaceOption {
+    label: string;
+    actionName: string;
+    className: string;
+    target: {
+        type: DomainNode['type'];
+        bpmnType: string;
+        isExpanded?: boolean;
+        isInterrupting?: boolean;
+        triggeredByEvent?: boolean;
+        cancelActivity?: boolean;
+        eventDefinitionType?: string;
+        instantiate?: boolean;
+        eventGatewayType?: string;
+    };
+}
+declare const REPLACE_OPTIONS: Record<string, ReplaceOption[]>;
+
+declare function BpmnModeler({ displayLeftPanel, editMode }: {
+    displayLeftPanel: boolean;
+    editMode: boolean;
+}): React.JSX.Element;
+
+declare const BpmnNode: ({ data, id, selected }: any) => React.JSX.Element;
+
+declare const BpmnEdge: ({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, data, selected, label, }: any) => React.JSX.Element;
+
+declare const BpmnPalette: () => React.JSX.Element;
+
+declare const BpmnPropertiesPanel: () => React.JSX.Element;
+
+declare const BpmnContextPad: () => null;
+
+interface BpmnQuickAppendProps {
+    onSelect: (option: ReplaceOption) => void;
+    trigger?: React.ReactNode;
+    tooltip?: string;
+    placement?: 'top' | 'right' | 'bottom' | 'left';
+    size?: 'small' | 'medium';
+}
+declare const BpmnQuickAppend: React.FC<BpmnQuickAppendProps>;
+
+declare const BPMN_ICON_PATHS: {
+    TASK_ICON_COMMERCIAL: string;
+    TASK_ICON_CUSTOMER_SERVICE: string;
+    TASK_ICON_FINANCE: string;
+    TASK_ICON_EQUIPMENT: string;
+    TASK_ICON_LOGISTICS: string;
+    TASK_ICON_MARINE: string;
+    TASK_ICON_DOCUMENT: string;
+    DATA_OBJECT: string;
+    DATA_STORE: string;
+    MARKER_PARALLEL: string;
+    MARKER_SEQUENTIAL: string;
+    MARKER_LOOP: string;
+    TIMER: string;
+    MESSAGE: string;
+    SIGNAL: string;
+    ERROR: string;
+    ESCALATION: string;
+    CONDITIONAL: string;
+    COMPENSATION: string;
+    LINK: string;
+    TERMINATE: string;
+    CANCEL: string;
+    GATEWAY_EXCLUSIVE: string;
+    GATEWAY_PARALLEL: string;
+    GATEWAY_INCLUSIVE: string;
+    GATEWAY_COMPLEX: string;
+    GATEWAY_EVENT_BASED: string;
+};
+
+interface BpmnState {
+    workflow: DomainWorkflow;
+    past: DomainWorkflow[];
+    future: DomainWorkflow[];
+    errors: ValidationError[];
+    clipboard: {
+        nodes: DomainNode[];
+        edges: DomainEdge[];
+    };
+    selectedNodeId: string | null;
+    selectedEdgeId: string | null;
+    editingNodeId: string | null;
+    activeTool: 'hand' | 'lasso' | 'space' | 'connection';
+    setWorkflow: (workflow: DomainWorkflow) => void;
+    addNode: (node: DomainNode) => void;
+    removeNode: (nodeId: string) => void;
+    updateNode: (nodeId: string, updates: Partial<DomainNode>) => void;
+    updateNodes: (updates: {
+        id: string;
+        changes: Partial<DomainNode>;
+    }[]) => void;
+    addEdge: (edge: DomainEdge) => void;
+    removeEdge: (edgeId: string) => void;
+    updateEdge: (edgeId: string, updates: Partial<DomainEdge>) => void;
+    setSelectedNodeId: (id: string | null) => void;
+    setSelectedEdgeId: (id: string | null) => void;
+    setEditingNodeId: (id: string | null) => void;
+    setActiveTool: (tool: 'hand' | 'lasso' | 'space' | 'connection') => void;
+    copySelection: (nodeIds: string[]) => void;
+    pasteSelection: (positionOffset?: {
+        x: number;
+        y: number;
+    }) => void;
+    undo: () => void;
+    redo: () => void;
+    clearHistory: () => void;
+    applyLayout: (direction: 'LR' | 'TB') => Promise<void>;
+}
+declare const useBpmnStore: zustand.UseBoundStore<zustand.StoreApi<BpmnState>>;
+
+export { BPMN_ICON_PATHS, BpmnContextPad, BpmnEdge, BpmnExporter, BpmnImporter, BpmnLayout, BpmnModeler, BpmnNode, BpmnPalette, BpmnPropertiesPanel, BpmnQuickAppend, type BpmnQuickAppendProps, type BpmnState, BpmnValidator, type DomainEdge, type DomainLane, type DomainNode, type DomainPool, type DomainWorkflow, REPLACE_OPTIONS, type ReplaceOption, type ValidationError, useBpmnStore };