@yh-ui/flow 1.0.1 → 1.0.4

package/dist/__tests__/bpmn-engine.test.cjs

@@ -0,0 +1,357 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _bpmnEngine = require("../utils/bpmn-engine.cjs");
+function createMockNode(id, type, position = {
+  x: 0,
+  y: 0
+}) {
+  return {
+    id,
+    type,
+    position,
+    width: 100,
+    height: 80,
+    data: {},
+    selected: false,
+    dragging: false
+  };
+}
+function createMockEdge(id, source, target, conditionExpression) {
+  return {
+    id,
+    source,
+    target,
+    type: "smoothstep",
+    data: conditionExpression ? {
+      conditionExpression
+    } : {},
+    selected: false,
+    animated: false
+  };
+}
+(0, _vitest.describe)("flow/utils/bpmn-engine", () => {
+  let engine;
+  let eventListener;
+  (0, _vitest.beforeEach)(() => {
+    eventListener = _vitest.vi.fn();
+  });
+  (0, _vitest.describe)("constructor", () => {
+    (0, _vitest.it)("should create engine with default options", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      (0, _vitest.expect)(engine).toBeDefined();
+    });
+    (0, _vitest.it)("should create engine with custom options", () => {
+      const customExecutor = _vitest.vi.fn();
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        taskExecutor: customExecutor,
+        autoExecute: false
+      });
+      (0, _vitest.expect)(engine).toBeDefined();
+    });
+  });
+  (0, _vitest.describe)("createBpmnEngine factory", () => {
+    (0, _vitest.it)("should create engine instance", () => {
+      const e = (0, _bpmnEngine.createBpmnEngine)();
+      (0, _vitest.expect)(e).toBeInstanceOf(_bpmnEngine.BpmnProcessEngine);
+    });
+    (0, _vitest.it)("should pass options to engine", () => {
+      const e = (0, _bpmnEngine.createBpmnEngine)({
+        autoExecute: false
+      });
+      (0, _vitest.expect)(e).toBeInstanceOf(_bpmnEngine.BpmnProcessEngine);
+    });
+  });
+  (0, _vitest.describe)("loadProcess", () => {
+    (0, _vitest.it)("should load nodes and edges", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      const nodes = [createMockNode("n1", "bpmn-start"), createMockNode("n2", "bpmn-task")];
+      const edges = [createMockEdge("e1", "n1", "n2")];
+      engine.loadProcess(nodes, edges);
+      const startNodes = engine.getStartNodes();
+      (0, _vitest.expect)(startNodes).toHaveLength(1);
+      (0, _vitest.expect)(startNodes[0].id).toBe("n1");
+    });
+    (0, _vitest.it)("should skip edges without source or target", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      const nodes = [createMockNode("n1", "bpmn-start")];
+      const edges = [{
+        id: "e1",
+        source: "",
+        target: "n2",
+        type: "smoothstep"
+      }, {
+        id: "e2",
+        source: "n1",
+        target: "",
+        type: "smoothstep"
+      }, createMockEdge("e3", "n1", "n1")];
+      engine.loadProcess(nodes, edges);
+      const startNodes = engine.getStartNodes();
+      (0, _vitest.expect)(startNodes).toHaveLength(1);
+    });
+    (0, _vitest.it)("should clear previous data on reload", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      const nodes1 = [createMockNode("n1", "bpmn-start")];
+      engine.loadProcess(nodes1, []);
+      (0, _vitest.expect)(engine.getStartNodes()).toHaveLength(1);
+      const nodes2 = [];
+      engine.loadProcess(nodes2, []);
+      (0, _vitest.expect)(engine.getStartNodes()).toHaveLength(0);
+    });
+  });
+  (0, _vitest.describe)("createInstance", () => {
+    (0, _vitest.it)("should create process instance with initial variables", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance({
+        var1: "value1"
+      });
+      (0, _vitest.expect)(instance.variables.var1).toBe("value1");
+      (0, _vitest.expect)(instance.state).toBe("idle");
+      (0, _vitest.expect)(instance.id).toMatch(/^instance_\d+$/);
+    });
+    (0, _vitest.it)("should initialize all nodes in instance", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start"), createMockNode("n2", "bpmn-task")], []);
+      const instance = engine.createInstance();
+      (0, _vitest.expect)(instance.nodes.has("n1")).toBe(true);
+      (0, _vitest.expect)(instance.nodes.has("n2")).toBe(true);
+    });
+    (0, _vitest.it)("should initialize all edges in instance", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start"), createMockNode("n2", "bpmn-task")], [createMockEdge("e1", "n1", "n2")]);
+      const instance = engine.createInstance();
+      (0, _vitest.expect)(instance.edges.has("e1")).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("getInstance", () => {
+    (0, _vitest.it)("should return instance by id", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const created = engine.createInstance();
+      const retrieved = engine.getInstance(created.id);
+      (0, _vitest.expect)(retrieved?.id).toBe(created.id);
+    });
+    (0, _vitest.it)("should return undefined for non-existent id", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      (0, _vitest.expect)(engine.getInstance("non-existent")).toBeUndefined();
+    });
+  });
+  (0, _vitest.describe)("getStartNodes / getEndNodes", () => {
+    (0, _vitest.it)("should return start nodes", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("end", "bpmn-end"), createMockNode("task", "bpmn-task")], []);
+      (0, _vitest.expect)(engine.getStartNodes()).toHaveLength(1);
+      (0, _vitest.expect)(engine.getStartNodes()[0].type).toBe("bpmn-start");
+    });
+    (0, _vitest.it)("should return end nodes", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("end1", "bpmn-end"), createMockNode("end2", "bpmn-end")], []);
+      (0, _vitest.expect)(engine.getEndNodes()).toHaveLength(2);
+    });
+  });
+  (0, _vitest.describe)("getOutgoingEdges / getIncomingEdges", () => {
+    (0, _vitest.it)("should return outgoing edges", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start"), createMockNode("n2", "bpmn-task"), createMockNode("n3", "bpmn-task")], [createMockEdge("e1", "n1", "n2"), createMockEdge("e2", "n1", "n3")]);
+      const outgoing = engine.getOutgoingEdges("n1");
+      (0, _vitest.expect)(outgoing).toHaveLength(2);
+    });
+    (0, _vitest.it)("should return incoming edges", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start"), createMockNode("n2", "bpmn-task")], [createMockEdge("e1", "n1", "n2")]);
+      const incoming = engine.getIncomingEdges("n2");
+      (0, _vitest.expect)(incoming).toHaveLength(1);
+    });
+  });
+  (0, _vitest.describe)("setVariable / getVariable", () => {
+    (0, _vitest.it)("should set and get variables", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance();
+      engine.setVariable(instance.id, "key", "value");
+      (0, _vitest.expect)(engine.getVariable(instance.id, "key")).toBe("value");
+    });
+    (0, _vitest.it)("should return undefined for non-existent variable", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance();
+      (0, _vitest.expect)(engine.getVariable(instance.id, "unknown")).toBeUndefined();
+    });
+  });
+  (0, _vitest.describe)("pause / resume", () => {
+    (0, _vitest.it)("should pause running instance", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance();
+      engine.start(instance.id);
+      engine.pause(instance.id);
+      const retrieved = engine.getInstance(instance.id);
+      (0, _vitest.expect)(retrieved?.state).toBe("paused");
+    });
+    (0, _vitest.it)("should resume paused instance", async () => {
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance();
+      engine.start(instance.id);
+      engine.pause(instance.id);
+      await engine.resume(instance.id);
+    });
+    (0, _vitest.it)("should do nothing when pausing non-running instance", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine();
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance();
+      engine.pause(instance.id);
+      (0, _vitest.expect)(engine.getInstance(instance.id)?.state).toBe("idle");
+    });
+  });
+  (0, _vitest.describe)("terminate", () => {
+    (0, _vitest.it)("should terminate instance", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      const instance = engine.createInstance();
+      engine.start(instance.id);
+      engine.terminate(instance.id);
+      const retrieved = engine.getInstance(instance.id);
+      (0, _vitest.expect)(retrieved?.state).toBe("terminated");
+      (0, _vitest.expect)(retrieved?.endTime).toBeDefined();
+    });
+  });
+  (0, _vitest.describe)("getAllInstances", () => {
+    (0, _vitest.it)("should return all instances", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      engine.createInstance();
+      engine.createInstance();
+      (0, _vitest.expect)(engine.getAllInstances()).toHaveLength(2);
+    });
+  });
+  (0, _vitest.describe)("event listener", () => {
+    (0, _vitest.it)("should call event listener on events", () => {
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        eventListener,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("n1", "bpmn-start")], []);
+      engine.createInstance();
+      engine.start("instance_1");
+      (0, _vitest.expect)(eventListener).toHaveBeenCalled();
+    });
+  });
+  (0, _vitest.describe)("start with no start nodes", () => {
+    (0, _vitest.it)("should complete immediately when no start nodes exist", async () => {
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("n1", "bpmn-task")], []);
+      const instance = engine.createInstance();
+      await engine.start(instance.id);
+      (0, _vitest.expect)(instance.state).toBe("completed");
+    });
+  });
+  (0, _vitest.describe)("task executor", () => {
+    (0, _vitest.it)("should create engine with task executor option", () => {
+      const executor = _vitest.vi.fn();
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        taskExecutor: executor,
+        autoExecute: false
+      });
+      (0, _vitest.expect)(engine).toBeDefined();
+    });
+  });
+  (0, _vitest.describe)("variable evaluator", () => {
+    (0, _vitest.it)("should evaluate equality condition", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(true);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", "${approved == true}")]);
+      const instance = engine.createInstance();
+      engine.setVariable(instance.id, "approved", true);
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should evaluate greater than condition", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(false);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", "${count > 5}")]);
+      const instance = engine.createInstance();
+      engine.setVariable(instance.id, "count", 10);
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalledWith("${count > 5}", {
+        count: 10
+      });
+    });
+    (0, _vitest.it)("should evaluate less than condition", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(false);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", "${count < 5}")]);
+      const instance = engine.createInstance();
+      engine.setVariable(instance.id, "count", 3);
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should evaluate not equal condition", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(false);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", '${status != "closed"}')]);
+      const instance = engine.createInstance();
+      engine.setVariable(instance.id, "status", "open");
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should handle simple variable reference", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(true);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", "${isActive}")]);
+      const instance = engine.createInstance();
+      engine.setVariable(instance.id, "isActive", true);
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should handle true literal", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(true);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", "${true}")]);
+      const instance = engine.createInstance();
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should handle false literal", async () => {
+      const evaluator = _vitest.vi.fn().mockReturnValue(false);
+      engine = new _bpmnEngine.BpmnProcessEngine({
+        variableEvaluator: evaluator,
+        autoExecute: false
+      });
+      engine.loadProcess([createMockNode("start", "bpmn-start"), createMockNode("task", "bpmn-task")], [createMockEdge("e1", "start", "task", "${false}")]);
+      const instance = engine.createInstance();
+      await engine.start(instance.id);
+      (0, _vitest.expect)(evaluator).toHaveBeenCalled();
+    });
+  });
+});

package/dist/__tests__/bpmn-engine.test.d.ts

@@ -0,0 +1 @@
+export {};