@yh-ui/flow 0.1.21

package/dist/__tests__/bpmn.ssr.test.cjs

@@ -0,0 +1,278 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _BpmnStartEvent = _interopRequireDefault(require("../components/nodes/bpmn/BpmnStartEvent.vue"));
+var _BpmnEndEvent = _interopRequireDefault(require("../components/nodes/bpmn/BpmnEndEvent.vue"));
+var _BpmnTask = _interopRequireDefault(require("../components/nodes/bpmn/BpmnTask.vue"));
+var _BpmnServiceTask = _interopRequireDefault(require("../components/nodes/bpmn/BpmnServiceTask.vue"));
+var _BpmnUserTask = _interopRequireDefault(require("../components/nodes/bpmn/BpmnUserTask.vue"));
+var _BpmnExclusiveGateway = _interopRequireDefault(require("../components/nodes/bpmn/BpmnExclusiveGateway.vue"));
+var _BpmnParallelGateway = _interopRequireDefault(require("../components/nodes/bpmn/BpmnParallelGateway.vue"));
+var _BpmnInclusiveGateway = _interopRequireDefault(require("../components/nodes/bpmn/BpmnInclusiveGateway.vue"));
+var _ssr = require("./utils/ssr.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("BPMN Nodes SSR", () => {
+  (0, _vitest.describe)("BpmnStartEvent", () => {
+    (0, _vitest.it)("should render start event in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnStartEvent.default, {
+        id: "start-1",
+        type: "bpmn-start",
+        data: {
+          label: "Start"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u5F00\u59CB");
+    });
+    (0, _vitest.it)("should render with selected class in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnStartEvent.default, {
+        id: "start-1",
+        type: "bpmn-start",
+        data: {
+          label: "Start"
+        },
+        selected: true,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRHasClass)(html, "selected");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnStartEvent.default, {
+        id: "start-1",
+        type: "bpmn-start",
+        data: {
+          label: "Start"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnEndEvent", () => {
+    (0, _vitest.it)("should render end event in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnEndEvent.default, {
+        id: "end-1",
+        type: "bpmn-end",
+        data: {
+          label: "End"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u7ED3\u675F");
+    });
+    (0, _vitest.it)("should render with selected class in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnEndEvent.default, {
+        id: "end-1",
+        type: "bpmn-end",
+        data: {
+          label: "End"
+        },
+        selected: true,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRHasClass)(html, "selected");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnEndEvent.default, {
+        id: "end-1",
+        type: "bpmn-end",
+        data: {
+          label: "End"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnTask", () => {
+    (0, _vitest.it)("should render task in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnTask.default, {
+        id: "task-1",
+        type: "bpmn-task",
+        data: {
+          label: "Process Task"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u4EFB\u52A1");
+    });
+    (0, _vitest.it)("should render with dragging class in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnTask.default, {
+        id: "task-1",
+        type: "bpmn-task",
+        data: {
+          label: "Task"
+        },
+        selected: false,
+        dragging: true,
+        connectable: true
+      });
+      (0, _ssr.expectSSRHasClass)(html, "dragging");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnTask.default, {
+        id: "task-1",
+        type: "bpmn-task",
+        data: {
+          label: "Process Task"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnServiceTask", () => {
+    (0, _vitest.it)("should render service task in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnServiceTask.default, {
+        id: "service-1",
+        type: "bpmn-service-task",
+        data: {
+          label: "Service Task"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u670D\u52A1\u4EFB\u52A1");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnServiceTask.default, {
+        id: "service-1",
+        type: "bpmn-service-task",
+        data: {
+          label: "Service Task"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnUserTask", () => {
+    (0, _vitest.it)("should render user task in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnUserTask.default, {
+        id: "user-1",
+        type: "bpmn-user-task",
+        data: {
+          label: "User Task"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u7528\u6237\u4EFB\u52A1");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnUserTask.default, {
+        id: "user-1",
+        type: "bpmn-user-task",
+        data: {
+          label: "User Task"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnExclusiveGateway", () => {
+    (0, _vitest.it)("should render exclusive gateway in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnExclusiveGateway.default, {
+        id: "gw-1",
+        type: "bpmn-exclusive-gateway",
+        data: {
+          label: "Decision"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\xD7");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnExclusiveGateway.default, {
+        id: "gw-1",
+        type: "bpmn-exclusive-gateway",
+        data: {
+          label: "Decision"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnParallelGateway", () => {
+    (0, _vitest.it)("should render parallel gateway in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnParallelGateway.default, {
+        id: "gw-2",
+        type: "bpmn-parallel-gateway",
+        data: {
+          label: "Parallel"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "+");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnParallelGateway.default, {
+        id: "gw-2",
+        type: "bpmn-parallel-gateway",
+        data: {
+          label: "Parallel"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("BpmnInclusiveGateway", () => {
+    (0, _vitest.it)("should render inclusive gateway in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_BpmnInclusiveGateway.default, {
+        id: "gw-3",
+        type: "bpmn-inclusive-gateway",
+        data: {
+          label: "Inclusive"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u25CB");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_BpmnInclusiveGateway.default, {
+        id: "gw-3",
+        type: "bpmn-inclusive-gateway",
+        data: {
+          label: "Inclusive"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+});

package/dist/__tests__/bpmn.ssr.test.d.ts

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

package/dist/__tests__/bpmn.ssr.test.mjs

@@ -0,0 +1,237 @@
+import { describe, it, expect } from "vitest";
+import BpmnStartEvent from "../components/nodes/bpmn/BpmnStartEvent.vue";
+import BpmnEndEvent from "../components/nodes/bpmn/BpmnEndEvent.vue";
+import BpmnTask from "../components/nodes/bpmn/BpmnTask.vue";
+import BpmnServiceTask from "../components/nodes/bpmn/BpmnServiceTask.vue";
+import BpmnUserTask from "../components/nodes/bpmn/BpmnUserTask.vue";
+import BpmnExclusiveGateway from "../components/nodes/bpmn/BpmnExclusiveGateway.vue";
+import BpmnParallelGateway from "../components/nodes/bpmn/BpmnParallelGateway.vue";
+import BpmnInclusiveGateway from "../components/nodes/bpmn/BpmnInclusiveGateway.vue";
+import { renderSSR, expectSSRHasClass, expectSSRContains, testHydration } from "./utils/ssr.mjs";
+describe("BPMN Nodes SSR", () => {
+  describe("BpmnStartEvent", () => {
+    it("should render start event in SSR", async () => {
+      const html = await renderSSR(BpmnStartEvent, {
+        id: "start-1",
+        type: "bpmn-start",
+        data: { label: "Start" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\u5F00\u59CB");
+    });
+    it("should render with selected class in SSR", async () => {
+      const html = await renderSSR(BpmnStartEvent, {
+        id: "start-1",
+        type: "bpmn-start",
+        data: { label: "Start" },
+        selected: true,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRHasClass(html, "selected");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnStartEvent, {
+        id: "start-1",
+        type: "bpmn-start",
+        data: { label: "Start" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnEndEvent", () => {
+    it("should render end event in SSR", async () => {
+      const html = await renderSSR(BpmnEndEvent, {
+        id: "end-1",
+        type: "bpmn-end",
+        data: { label: "End" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\u7ED3\u675F");
+    });
+    it("should render with selected class in SSR", async () => {
+      const html = await renderSSR(BpmnEndEvent, {
+        id: "end-1",
+        type: "bpmn-end",
+        data: { label: "End" },
+        selected: true,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRHasClass(html, "selected");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnEndEvent, {
+        id: "end-1",
+        type: "bpmn-end",
+        data: { label: "End" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnTask", () => {
+    it("should render task in SSR", async () => {
+      const html = await renderSSR(BpmnTask, {
+        id: "task-1",
+        type: "bpmn-task",
+        data: { label: "Process Task" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\u4EFB\u52A1");
+    });
+    it("should render with dragging class in SSR", async () => {
+      const html = await renderSSR(BpmnTask, {
+        id: "task-1",
+        type: "bpmn-task",
+        data: { label: "Task" },
+        selected: false,
+        dragging: true,
+        connectable: true
+      });
+      expectSSRHasClass(html, "dragging");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnTask, {
+        id: "task-1",
+        type: "bpmn-task",
+        data: { label: "Process Task" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnServiceTask", () => {
+    it("should render service task in SSR", async () => {
+      const html = await renderSSR(BpmnServiceTask, {
+        id: "service-1",
+        type: "bpmn-service-task",
+        data: { label: "Service Task" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\u670D\u52A1\u4EFB\u52A1");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnServiceTask, {
+        id: "service-1",
+        type: "bpmn-service-task",
+        data: { label: "Service Task" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnUserTask", () => {
+    it("should render user task in SSR", async () => {
+      const html = await renderSSR(BpmnUserTask, {
+        id: "user-1",
+        type: "bpmn-user-task",
+        data: { label: "User Task" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\u7528\u6237\u4EFB\u52A1");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnUserTask, {
+        id: "user-1",
+        type: "bpmn-user-task",
+        data: { label: "User Task" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnExclusiveGateway", () => {
+    it("should render exclusive gateway in SSR", async () => {
+      const html = await renderSSR(BpmnExclusiveGateway, {
+        id: "gw-1",
+        type: "bpmn-exclusive-gateway",
+        data: { label: "Decision" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\xD7");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnExclusiveGateway, {
+        id: "gw-1",
+        type: "bpmn-exclusive-gateway",
+        data: { label: "Decision" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnParallelGateway", () => {
+    it("should render parallel gateway in SSR", async () => {
+      const html = await renderSSR(BpmnParallelGateway, {
+        id: "gw-2",
+        type: "bpmn-parallel-gateway",
+        data: { label: "Parallel" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "+");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnParallelGateway, {
+        id: "gw-2",
+        type: "bpmn-parallel-gateway",
+        data: { label: "Parallel" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+  describe("BpmnInclusiveGateway", () => {
+    it("should render inclusive gateway in SSR", async () => {
+      const html = await renderSSR(BpmnInclusiveGateway, {
+        id: "gw-3",
+        type: "bpmn-inclusive-gateway",
+        data: { label: "Inclusive" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expectSSRContains(html, "\u25CB");
+    });
+    it("should hydrate without mismatch", async () => {
+      const result = await testHydration(BpmnInclusiveGateway, {
+        id: "gw-3",
+        type: "bpmn-inclusive-gateway",
+        data: { label: "Inclusive" },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      expect(result.isMatch).toBe(true);
+    });
+  });
+});

package/dist/__tests__/bpmn.test.cjs

@@ -0,0 +1,103 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _customTypes = require("../utils/custom-types.cjs");
+var _bpmn = require("../components/nodes/bpmn/index.cjs");
+(0, _vitest.describe)("flow/components/nodes/bpmn", () => {
+  (0, _vitest.beforeEach)(() => {
+    (0, _customTypes.clearCustomTypes)();
+  });
+  (0, _vitest.describe)("BPMN Node Types", () => {
+    (0, _vitest.it)("should have correct BPMN node type constants", () => {
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.StartEvent).toBe("bpmn-start");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.EndEvent).toBe("bpmn-end");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.Task).toBe("bpmn-task");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.ServiceTask).toBe("bpmn-service-task");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.UserTask).toBe("bpmn-user-task");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.ExclusiveGateway).toBe("bpmn-exclusive-gateway");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.ParallelGateway).toBe("bpmn-parallel-gateway");
+      (0, _vitest.expect)(_bpmn.BPMN_NODE_TYPES.InclusiveGateway).toBe("bpmn-inclusive-gateway");
+    });
+    (0, _vitest.it)("should have 8 BPMN node types", () => {
+      const types = Object.values(_bpmn.BPMN_NODE_TYPES);
+      (0, _vitest.expect)(types).toHaveLength(8);
+    });
+  });
+  (0, _vitest.describe)("BPMN Node Registration", () => {
+    (0, _vitest.it)("should register all BPMN node types", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const allNodes = (0, _customTypes.getAllCustomNodes)();
+      (0, _vitest.expect)(allNodes).toHaveLength(8);
+    });
+    (0, _vitest.it)("should register start event node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.StartEvent);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.StartEvent);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register end event node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.EndEvent);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.EndEvent);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register task node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.Task);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.Task);
+    });
+    (0, _vitest.it)("should register service task node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.ServiceTask);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.ServiceTask);
+    });
+    (0, _vitest.it)("should register user task node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.UserTask);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.UserTask);
+    });
+    (0, _vitest.it)("should register exclusive gateway node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.ExclusiveGateway);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.ExclusiveGateway);
+    });
+    (0, _vitest.it)("should register parallel gateway node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.ParallelGateway);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.ParallelGateway);
+    });
+    (0, _vitest.it)("should register inclusive gateway node", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const node = (0, _customTypes.getCustomNode)(_bpmn.BPMN_NODE_TYPES.InclusiveGateway);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_bpmn.BPMN_NODE_TYPES.InclusiveGateway);
+    });
+    (0, _vitest.it)("should check if BPMN nodes are registered", () => {
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.StartEvent)).toBe(false);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.EndEvent)).toBe(false);
+      (0, _bpmn.registerBpmnNodes)();
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.StartEvent)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.EndEvent)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.Task)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.ServiceTask)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.UserTask)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.ExclusiveGateway)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.ParallelGateway)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_bpmn.BPMN_NODE_TYPES.InclusiveGateway)).toBe(true);
+    });
+    (0, _vitest.it)("should not duplicate nodes on re-registration", () => {
+      (0, _bpmn.registerBpmnNodes)();
+      const firstCount = (0, _customTypes.getAllCustomNodes)().length;
+      (0, _bpmn.registerBpmnNodes)();
+      const secondCount = (0, _customTypes.getAllCustomNodes)().length;
+      (0, _vitest.expect)(firstCount).toBe(secondCount);
+    });
+  });
+});

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

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