@yh-ui/flow 0.1.21

package/dist/utils/bpmn-engine.mjs

@@ -0,0 +1,378 @@
+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;
+  }
+}
+export 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);
+  }
+}
+export function createBpmnEngine(options) {
+  return new BpmnProcessEngine(options);
+}