@yh-ui/flow 0.1.21

package/dist/utils/bpmn-engine.cjs

@@ -0,0 +1,390 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BpmnProcessEngine = void 0;
+exports.createBpmnEngine = createBpmnEngine;
+function defaultVariableEvaluator(expr, context) {
+  try {
+    const match = expr.match(/\$\{(.+)\}/);
+    if (!match) return !!expr;
+    const expression = match[1].trim();
+    if (expression.includes("==")) {
+      const [left, right] = expression.split("==").map(s => s.trim());
+      return context[left] == right.replace(/['"]/g, "");
+    }
+    if (expression.includes("!=")) {
+      const [left, right] = expression.split("!=").map(s => s.trim());
+      return context[left] != right.replace(/['"]/g, "");
+    }
+    if (expression.includes(">")) {
+      const [left, right] = expression.split(">").map(s => s.trim());
+      return Number(context[left]) > Number(right);
+    }
+    if (expression.includes("<")) {
+      const [left, right] = expression.split("<").map(s => s.trim());
+      return Number(context[left]) < Number(right);
+    }
+    const val = context[expression];
+    if (typeof val === "boolean") return val;
+    if (expression === "true") return true;
+    if (expression === "false") return false;
+    return !!val;
+  } catch {
+    return false;
+  }
+}
+class BpmnProcessEngine {
+  nodes = /* @__PURE__ */new Map();
+  edges = /* @__PURE__ */new Map();
+  instances = /* @__PURE__ */new Map();
+  options;
+  instanceCounter = 0;
+  constructor(options = {}) {
+    this.options = {
+      variableEvaluator: options.variableEvaluator || defaultVariableEvaluator,
+      taskExecutor: options.taskExecutor || (async () => {}),
+      eventListener: options.eventListener || (() => {}),
+      autoExecute: options.autoExecute ?? true,
+      executionDelay: options.executionDelay ?? 500
+    };
+  }
+  /**
+   * 加载流程定义
+   */
+  loadProcess(nodes, edges) {
+    this.nodes.clear();
+    this.edges.clear();
+    for (const node of nodes) {
+      this.nodes.set(node.id, node);
+    }
+    for (const edge of edges) {
+      if (edge.source && edge.target) {
+        this.edges.set(edge.id, edge);
+      }
+    }
+  }
+  /**
+   * 创建流程实例
+   */
+  createInstance(initialVariables = {}) {
+    const instanceId = `instance_${++this.instanceCounter}`;
+    const instance = {
+      id: instanceId,
+      processDefinitionId: "process",
+      state: "idle",
+      startTime: Date.now(),
+      nodes: /* @__PURE__ */new Map(),
+      edges: /* @__PURE__ */new Map(),
+      tokens: /* @__PURE__ */new Map(),
+      variables: {
+        ...initialVariables
+      },
+      currentNodes: [],
+      completedNodes: [],
+      history: []
+    };
+    for (const [nodeId, node] of this.nodes) {
+      instance.nodes.set(nodeId, {
+        nodeId: node.id,
+        nodeType: node.type,
+        status: "waiting",
+        variables: {},
+        incomingTokens: [],
+        outgoingTokens: []
+      });
+    }
+    for (const [edgeId, edge] of this.edges) {
+      instance.edges.set(edgeId, {
+        edgeId: edge.id,
+        sourceNodeId: edge.source || "",
+        targetNodeId: edge.target || "",
+        taken: false
+      });
+    }
+    this.instances.set(instanceId, instance);
+    return instance;
+  }
+  /**
+   * 启动流程实例
+   */
+  async start(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (!instance) return null;
+    instance.state = "running";
+    const startNodes = Array.from(this.nodes.values()).filter(n => n.type === "bpmn-start");
+    if (startNodes.length === 0) {
+      instance.state = "completed";
+      instance.endTime = Date.now();
+      return instance;
+    }
+    for (const startNode of startNodes) {
+      await this.enterNode(instance, startNode.id);
+    }
+    if (this.options.autoExecute) {
+      await this.executeAll(instance);
+    }
+    return instance;
+  }
+  /**
+   * 进入节点
+   */
+  async enterNode(instance, nodeId) {
+    const nodeInstance = instance.nodes.get(nodeId);
+    if (!nodeInstance) return;
+    const node = this.nodes.get(nodeId);
+    if (!node) return;
+    const tokenId = `token_${nodeId}_${Date.now()}`;
+    instance.tokens.set(tokenId, {
+      nodeId,
+      state: "active"
+    });
+    nodeInstance.incomingTokens.push(tokenId);
+    this.emitEvent(instance, {
+      type: "node_entered",
+      timestamp: Date.now(),
+      nodeId,
+      tokenId
+    });
+    nodeInstance.status = "active";
+    nodeInstance.startTime = Date.now();
+    if (!instance.currentNodes.includes(nodeId)) {
+      instance.currentNodes.push(nodeId);
+    }
+    await this.executeNode(instance, node);
+    if (node.type === "bpmn-end") {
+      nodeInstance.status = "completed";
+      nodeInstance.endTime = Date.now();
+      instance.completedNodes.push(nodeId);
+      instance.currentNodes = instance.currentNodes.filter(id => id !== nodeId);
+      for (const tokenId2 of [...nodeInstance.incomingTokens]) {
+        instance.tokens.delete(tokenId2);
+        this.emitEvent(instance, {
+          type: "token_consumed",
+          timestamp: Date.now(),
+          nodeId,
+          tokenId: tokenId2
+        });
+      }
+      if (instance.tokens.size === 0 && instance.currentNodes.length === 0) {
+        instance.state = "completed";
+        instance.endTime = Date.now();
+      }
+      return;
+    }
+    await this.exitNode(instance, nodeId);
+  }
+  /**
+   * 执行节点
+   */
+  async executeNode(instance, node) {
+    const nodeInstance = instance.nodes.get(node.id);
+    if (!nodeInstance) return;
+    if (["bpmn-task", "bpmn-service-task", "bpmn-user-task"].includes(node.type)) {
+      await this.options.taskExecutor(nodeInstance, instance.variables);
+    }
+    this.emitEvent(instance, {
+      type: "node_exited",
+      timestamp: Date.now(),
+      nodeId: node.id,
+      data: instance.variables
+    });
+  }
+  /**
+   * 离开节点
+   */
+  async exitNode(instance, nodeId) {
+    const nodeInstance = instance.nodes.get(nodeId);
+    if (!nodeInstance) return;
+    const node = this.nodes.get(nodeId);
+    if (!node) return;
+    for (const tokenId of nodeInstance.incomingTokens) {
+      instance.tokens.delete(tokenId);
+      this.emitEvent(instance, {
+        type: "token_consumed",
+        timestamp: Date.now(),
+        nodeId,
+        tokenId
+      });
+    }
+    const outgoingEdges = Array.from(this.edges.values()).filter(e => e.source === nodeId);
+    if (node.type === "bpmn-exclusive-gateway") {
+      let taken = false;
+      for (const edge of outgoingEdges) {
+        const canTake = this.evaluateEdgeCondition(instance, edge);
+        if (canTake) {
+          await this.takeFlow(instance, edge);
+          taken = true;
+          break;
+        }
+      }
+      if (!taken && outgoingEdges.length > 0) {
+        const defaultEdge = outgoingEdges.find(e => !e.data?.conditionExpression) || outgoingEdges[0];
+        await this.takeFlow(instance, defaultEdge);
+      }
+    } else {
+      for (const edge of outgoingEdges) {
+        if (this.evaluateEdgeCondition(instance, edge)) {
+          await this.takeFlow(instance, edge);
+        }
+      }
+    }
+    nodeInstance.status = "completed";
+    nodeInstance.endTime = Date.now();
+    instance.currentNodes = instance.currentNodes.filter(id => id !== nodeId);
+    instance.completedNodes.push(nodeId);
+  }
+  /**
+   * 评估边的条件
+   */
+  evaluateEdgeCondition(instance, edge) {
+    if (!edge.data?.conditionExpression) return true;
+    const result = !!this.options.variableEvaluator(edge.data.conditionExpression, instance.variables);
+    this.emitEvent(instance, {
+      type: "condition_evaluated",
+      timestamp: Date.now(),
+      edgeId: edge.id,
+      nodeId: edge.source,
+      data: {
+        expression: edge.data.conditionExpression,
+        result
+      }
+    });
+    return result;
+  }
+  /**
+   * 采用流（连线）
+   */
+  async takeFlow(instance, edge) {
+    const edgeInstance = instance.edges.get(edge.id);
+    if (!edgeInstance) return;
+    edgeInstance.taken = true;
+    const tokenId = `token_${edge.target}_${Date.now()}`;
+    instance.tokens.set(tokenId, {
+      nodeId: edge.target,
+      state: "waiting"
+    });
+    const targetNodeInstance = instance.nodes.get(edge.target);
+    if (targetNodeInstance) {
+      targetNodeInstance.outgoingTokens.push(tokenId);
+    }
+    this.emitEvent(instance, {
+      type: "token_created",
+      timestamp: Date.now(),
+      edgeId: edge.id,
+      tokenId,
+      targetRef: edge.target
+    });
+    setTimeout(() => {
+      this.enterNode(instance, edge.target);
+    }, 10);
+  }
+  /**
+   * 执行所有待处理节点
+   */
+  async executeAll(instance) {
+    while (instance.currentNodes.length > 0 && instance.state === "running") {
+      await new Promise(resolve => setTimeout(resolve, this.options.executionDelay));
+      if (instance.currentNodes.length === 0) {
+        const hasActiveTokens = Array.from(instance.tokens.values()).some(t => t.state === "active");
+        if (!hasActiveTokens) {
+          instance.state = "completed";
+          instance.endTime = Date.now();
+        }
+      }
+    }
+  }
+  /**
+   * 触发事件
+   */
+  emitEvent(instance, event) {
+    instance.history.push(event);
+    this.options.eventListener(event);
+  }
+  /**
+   * 获取实例状态
+   */
+  getInstance(instanceId) {
+    return this.instances.get(instanceId);
+  }
+  /**
+   * 设置变量
+   */
+  setVariable(instanceId, key, value) {
+    const instance = this.instances.get(instanceId);
+    if (instance) {
+      instance.variables[key] = value;
+    }
+  }
+  /**
+   * 获取变量
+   */
+  getVariable(instanceId, key) {
+    const instance = this.instances.get(instanceId);
+    return instance?.variables[key];
+  }
+  /**
+   * 暂停流程
+   */
+  pause(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (instance && instance.state === "running") {
+      instance.state = "paused";
+    }
+  }
+  /**
+   * 恢复流程
+   */
+  async resume(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (instance && instance.state === "paused") {
+      instance.state = "running";
+      await this.executeAll(instance);
+    }
+  }
+  /**
+   * 终止流程
+   */
+  terminate(instanceId) {
+    const instance = this.instances.get(instanceId);
+    if (instance) {
+      instance.state = "terminated";
+      instance.endTime = Date.now();
+    }
+  }
+  /**
+   * 获取所有实例
+   */
+  getAllInstances() {
+    return Array.from(this.instances.values());
+  }
+  /**
+   * 获取可用的开始节点
+   */
+  getStartNodes() {
+    return Array.from(this.nodes.values()).filter(n => n.type === "bpmn-start");
+  }
+  /**
+   * 获取可用的结束节点
+   */
+  getEndNodes() {
+    return Array.from(this.nodes.values()).filter(n => n.type === "bpmn-end");
+  }
+  /**
+   * 获取节点的输出边
+   */
+  getOutgoingEdges(nodeId) {
+    return Array.from(this.edges.values()).filter(e => e.source === nodeId);
+  }
+  /**
+   * 获取节点的输入边
+   */
+  getIncomingEdges(nodeId) {
+    return Array.from(this.edges.values()).filter(e => e.target === nodeId);
+  }
+}
+exports.BpmnProcessEngine = BpmnProcessEngine;
+function createBpmnEngine(options) {
+  return new BpmnProcessEngine(options);
+}

package/dist/utils/bpmn-engine.d.ts

@@ -0,0 +1,164 @@
+/**
+ * ============================================
+ * BPMN Process Engine
+ * BPMN 流程执行/模拟引擎
+ * ============================================
+ */
+import type { Node, Edge } from '../types';
+export type ProcessState = 'idle' | 'running' | 'paused' | 'completed' | 'terminated';
+export type TokenState = 'waiting' | 'active' | 'completed' | 'terminated';
+export interface NodeInstance {
+    nodeId: string;
+    nodeType: string;
+    status: TokenState;
+    startTime?: number;
+    endTime?: number;
+    variables: Record<string, unknown>;
+    incomingTokens: string[];
+    outgoingTokens: string[];
+}
+export interface EdgeInstance {
+    edgeId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    taken: boolean;
+    conditionResult?: boolean;
+}
+export interface ProcessInstance {
+    id: string;
+    processDefinitionId: string;
+    state: ProcessState;
+    startTime: number;
+    endTime?: number;
+    nodes: Map<string, NodeInstance>;
+    edges: Map<string, EdgeInstance>;
+    tokens: Map<string, {
+        nodeId: string;
+        state: TokenState;
+    }>;
+    variables: Record<string, unknown>;
+    currentNodes: string[];
+    completedNodes: string[];
+    history: ProcessEvent[];
+}
+export interface ProcessEvent {
+    type: 'node_entered' | 'node_exited' | 'token_created' | 'token_consumed' | 'condition_evaluated' | 'error';
+    timestamp: number;
+    nodeId?: string;
+    edgeId?: string;
+    tokenId?: string;
+    targetRef?: string;
+    message?: string;
+    data?: unknown;
+}
+export interface BpmnEngineOptions {
+    /** 变量求值器 */
+    variableEvaluator?: (expr: string, context: Record<string, unknown>) => boolean | unknown;
+    /** 任务执行器 */
+    taskExecutor?: (node: NodeInstance, context: Record<string, unknown>) => Promise<void> | void;
+    /** 事件监听器 */
+    eventListener?: (event: ProcessEvent) => void;
+    /** 自动执行 */
+    autoExecute?: boolean;
+    /** 执行延迟 (ms) */
+    executionDelay?: number;
+}
+/**
+ * BPMN 流程引擎类
+ */
+export declare class BpmnProcessEngine {
+    private nodes;
+    private edges;
+    private instances;
+    private options;
+    private instanceCounter;
+    constructor(options?: BpmnEngineOptions);
+    /**
+     * 加载流程定义
+     */
+    loadProcess(nodes: Node[], edges: Edge[]): void;
+    /**
+     * 创建流程实例
+     */
+    createInstance(initialVariables?: Record<string, unknown>): ProcessInstance;
+    /**
+     * 启动流程实例
+     */
+    start(instanceId: string): Promise<ProcessInstance | null>;
+    /**
+     * 进入节点
+     */
+    private enterNode;
+    /**
+     * 执行节点
+     */
+    private executeNode;
+    /**
+     * 离开节点
+     */
+    private exitNode;
+    /**
+     * 评估边的条件
+     */
+    private evaluateEdgeCondition;
+    /**
+     * 采用流（连线）
+     */
+    private takeFlow;
+    /**
+     * 执行所有待处理节点
+     */
+    private executeAll;
+    /**
+     * 触发事件
+     */
+    private emitEvent;
+    /**
+     * 获取实例状态
+     */
+    getInstance(instanceId: string): ProcessInstance | undefined;
+    /**
+     * 设置变量
+     */
+    setVariable(instanceId: string, key: string, value: unknown): void;
+    /**
+     * 获取变量
+     */
+    getVariable(instanceId: string, key: string): unknown;
+    /**
+     * 暂停流程
+     */
+    pause(instanceId: string): void;
+    /**
+     * 恢复流程
+     */
+    resume(instanceId: string): Promise<void>;
+    /**
+     * 终止流程
+     */
+    terminate(instanceId: string): void;
+    /**
+     * 获取所有实例
+     */
+    getAllInstances(): ProcessInstance[];
+    /**
+     * 获取可用的开始节点
+     */
+    getStartNodes(): Node[];
+    /**
+     * 获取可用的结束节点
+     */
+    getEndNodes(): Node[];
+    /**
+     * 获取节点的输出边
+     */
+    getOutgoingEdges(nodeId: string): Edge[];
+    /**
+     * 获取节点的输入边
+     */
+    getIncomingEdges(nodeId: string): Edge[];
+}
+/**
+ * 创建 BPMN 引擎实例的工厂函数
+ */
+export declare function createBpmnEngine(options?: BpmnEngineOptions): BpmnProcessEngine;