= start && this.cursor <= stop;
},
- isSelf: function () {
- return this.source === this.target;
- },
messageTextStyle() {
return this.commentObj?.messageStyle;
},
diff --git a/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Return/Return.vue b/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Return/Return.vue
index 29b546e1..7064f2a3 100644
--- a/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Return/Return.vue
+++ b/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Return/Return.vue
@@ -5,16 +5,18 @@
v-on:click.stop="onClick"
data-type="return"
:data-signature="signature"
+ :data-origin="origin"
:data-to="target"
:data-source="source"
:data-target="target"
:class="{
'right-to-left': rightToLeft,
- 'bare-source': bareSource,
- 'bare-target': bareTarget,
highlight: isCurrent,
}"
- :style="{ ...borderWidth, width: width + 'px', left: left + 'px' }"
+ :style="{
+ width: interactionWidth + 'px',
+ transform: 'translateX(' + translateX + 'px)',
+ }"
>
@@ -50,8 +52,6 @@ import Comment from "../Comment/Comment.vue";
import Message from "../Message/Message.vue";
import { mapGetters } from "vuex";
import { CodeRange } from "@/parser/CodeRange";
-import WidthProviderOnBrowser from "@/positioning/WidthProviderFunc";
-import { TextType } from "@/positioning/Coordinate";
import ArrowMixin from "@/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/ArrowMixin";
import { DirectionMixin } from "@/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/DirectionMixin";
import { _STARTER_ } from "@/parser/OrderedParticipants";
@@ -61,7 +61,7 @@ export default {
props: ["context", "comment", "commentObj", "number"],
mixins: [ArrowMixin, DirectionMixin],
computed: {
- ...mapGetters(["distance", "cursor", "onElementClick", "participants"]),
+ ...mapGetters(["cursor", "onElementClick"]),
/**
* ret
* : RETURN expr? SCOL?
@@ -74,16 +74,6 @@ export default {
asyncMessage: function () {
return this.ret?.asyncMessage();
},
- width: function () {
- return this.isSelf
- ? WidthProviderOnBrowser(this.signature, TextType.MessageContent)
- : Math.abs(this.distance(this.target, this.source));
- },
- left: function () {
- return this.rightToLeft
- ? this.distance(this.target, this.origin)
- : this.distance(this.source, this.origin);
- },
signature: function () {
return (
this.asyncMessage?.content()?.getFormattedText() ||
@@ -104,9 +94,6 @@ export default {
isCurrent: function () {
return false;
},
- isSelf: function () {
- return this.source === this.target;
- },
messageTextStyle() {
return this.commentObj?.messageStyle;
},
diff --git a/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Statement.vue b/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Statement.vue
index 2e15471f..786acf21 100644
--- a/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Statement.vue
+++ b/src/components/DiagramFrame/SeqDiagram/MessageLayer/Block/Statement/Statement.vue
@@ -9,7 +9,6 @@
:context="context"
:comment="comment"
:commentObj="commentObj"
- :selfCallIndent="selfCallIndent"
:number="number"
:inheritFromOccurrence="inheritFromOccurrence"
>
@@ -33,14 +32,7 @@ import Comment from "../../../../../Comment/Comment";
export default {
name: "statement",
- props: [
- "orgin",
- "context",
- "selfCallIndent",
- "number",
- "collapsed",
- "inheritFromOccurrence",
- ],
+ props: ["orgin", "context", "number", "collapsed", "inheritFromOccurrence"],
computed: {
comment: function () {
return this.context.getComment() ? this.context.getComment() : "";
diff --git a/src/components/DiagramFrame/SeqDiagram/MessageLayer/MessageLayer.vue b/src/components/DiagramFrame/SeqDiagram/MessageLayer/MessageLayer.vue
index 04d60450..8f6b1923 100644
--- a/src/components/DiagramFrame/SeqDiagram/MessageLayer/MessageLayer.vue
+++ b/src/components/DiagramFrame/SeqDiagram/MessageLayer/MessageLayer.vue
@@ -59,65 +59,6 @@ onUpdated(() => {
border: dashed transparent 0;
}
- .interaction.sync {
- /* This border width configuration make sure the content width is
- the same as from the source occurrence's right border to target
- occurrence's left boarder (boarder not inclusive).*/
- border-right-width: 7px;
- }
-
- .occurrence {
- .occurrence {
- .interaction.sync {
- border-right-width: 7px;
- }
- }
- }
-
- .occurrence {
- .interaction.sync {
- border-left-width: 7px;
- }
- .interaction.sync.right-to-left {
- border-right-width: 7px;
- }
- .interaction.async.right-to-left {
- border-right-width: 7px;
- border-left-width: 7px;
- }
- .interaction.async.right-to-left {
- border-left-width: 0;
- }
- .interaction.sync.from-no-occurrence {
- border-left-width: 0;
- }
- .interaction.async.from-no-occurrence.right-to-left {
- border-right-width: 0;
- }
- .interaction.sync.right-to-left.from-no-occurrence {
- border-left-width: 7px;
- border-right-width: 0;
- }
- .interaction.async.right-to-left.to-occurrence {
- border-left-width: 7px;
- }
- .interaction.sync.from-no-occurrence.right-to-left {
- border-right-width: 0;
- }
- }
- .interaction.sync.right-to-left {
- /* This border width configuration make sure the content width is
- the same as from the source occurrence's right border to target
- occurrence's left boarder (boarder not inclusive).*/
- border-right-width: 0;
- border-left-width: 7px;
- }
-
- .interaction.inited-from-occurrence,
- .interaction.self-invocation {
- border-left-width: 7px;
- }
-
.interaction:hover {
cursor: pointer;
}
diff --git a/src/core.spec.ts b/src/core.spec.ts
index 7d497985..a0e4f120 100644
--- a/src/core.spec.ts
+++ b/src/core.spec.ts
@@ -10,27 +10,66 @@ vi.stubGlobal(
}),
);
describe("@ZenUML/core", function () {
+ let hiddenDiv: HTMLDivElement;
+
+ beforeEach(() => {
+ // Create the hidden div before each test
+ hiddenDiv = document.createElement("div");
+ hiddenDiv.className = "textarea-hidden-div";
+ hiddenDiv.style.fontSize = "1rem";
+ hiddenDiv.style.fontFamily = "Helvetica, Verdana, serif";
+ hiddenDiv.style.display = "inline";
+ hiddenDiv.style.whiteSpace = "nowrap";
+ hiddenDiv.style.visibility = "hidden";
+ hiddenDiv.style.position = "absolute";
+ hiddenDiv.style.top = "0";
+ hiddenDiv.style.left = "0";
+ hiddenDiv.style.overflow = "hidden";
+ hiddenDiv.style.width = "0px";
+ hiddenDiv.style.paddingLeft = "0px";
+ hiddenDiv.style.paddingRight = "0px";
+ hiddenDiv.style.margin = "0px";
+ hiddenDiv.style.border = "0px";
+ document.body.appendChild(hiddenDiv);
+ });
+
+ afterEach(() => {
+ // Clean up after each test
+ document.body.innerHTML = "";
+ // Clear the cache to prevent test interference
+ vi.clearAllMocks();
+ // You might need to clear your rendering cache here too
+ });
+
it("should render and cache the code and theme", async () => {
const el = document.createElement("div");
+ document.body.appendChild(el);
const zenUml = new ZenUml(el);
- expect(zenUml).toBeInstanceOf(ZenUml);
- expect(
- await zenUml.render("A.method", { theme: "theme-blue" }),
- ).toBeInstanceOf(ZenUml);
- expect(zenUml.code).toBe("A.method");
- expect(zenUml.theme).toBe("theme-blue");
- await zenUml.render("B.method", { theme: "theme-red" });
- expect(zenUml.code).toBe("B.method");
- expect(zenUml.theme).toBe("theme-red");
- await zenUml.render("C.method", undefined);
- expect(zenUml.code).toBe("C.method");
- expect(zenUml.theme).toBe("theme-red");
- await zenUml.render(undefined, { theme: "theme-green" });
- expect(zenUml.code).toBe("C.method");
- expect(zenUml.theme).toBe("theme-green");
+
+ // Wrap each render in a try-catch for debugging
+ try {
+ await zenUml.render("A.method", { theme: "theme-blue" });
+ expect(zenUml).toBeInstanceOf(ZenUml);
+ expect(zenUml.code).toBe("A.method");
+ expect(zenUml.theme).toBe("theme-blue");
+
+ await zenUml.render("B.method", { theme: "theme-red" });
+ expect(zenUml.code).toBe("B.method");
+ expect(zenUml.theme).toBe("theme-red");
+
+ await zenUml.render("C.method", undefined);
+ expect(zenUml.code).toBe("C.method");
+ expect(zenUml.theme).toBe("theme-red");
+
+ await zenUml.render(undefined, { theme: "theme-green" });
+ expect(zenUml.code).toBe("C.method");
+ expect(zenUml.theme).toBe("theme-green");
+ } catch (error) {
+ console.error("Test failed:", error);
+ throw error;
+ }
});
});
-
describe("VueSequence", () => {
it("should export a VueSequence", () => {
expect(VueSequence).toBeDefined();
diff --git a/src/parser/AncestorPath.spec.ts b/src/parser/AncestorPath.spec.ts
new file mode 100644
index 00000000..2b0765c1
--- /dev/null
+++ b/src/parser/AncestorPath.spec.ts
@@ -0,0 +1,27 @@
+import { Fixture } from "../../test/unit/parser/fixture/Fixture";
+import { expect } from "vitest";
+import sequenceParser from "@/generated-parser/sequenceParser";
+import antlr4 from "antlr4";
+
+describe("Ancestor", () => {
+ // preparation
+ const firstChild = Fixture.firstChild("A.method() { C->C.method }");
+ expect(firstChild.getFormattedText()).toBe("C->C.method");
+
+ it("Null predict", () => {
+ const ancestors = firstChild.getAncestors();
+ expect(ancestors.length).toBe(7);
+ expect(ancestors[0].constructor.name).toBe("StatContext");
+ });
+
+ it("should return the ancestor path", () => {
+ function predict(ctx: antlr4.ParserRuleContext) {
+ return ctx instanceof sequenceParser.MessageContext;
+ }
+
+ const ancestors = firstChild.getAncestors(predict);
+ expect(ancestors.length).toBe(1);
+ expect(ancestors[0].constructor.name).toBe("MessageContext");
+ expect(ancestors[0].getFormattedText()).toBe("A.method() { C->C.method }");
+ });
+});
diff --git a/src/parser/AncestorPath.ts b/src/parser/AncestorPath.ts
new file mode 100644
index 00000000..c5391dcc
--- /dev/null
+++ b/src/parser/AncestorPath.ts
@@ -0,0 +1,16 @@
+import { default as antlr4 } from "antlr4";
+
+// TypeScript cannot infer that the method exists on the prototype chain
+(antlr4.ParserRuleContext.prototype as any).getAncestors = function (
+ predicate?: (ctx: antlr4.ParserRuleContext) => boolean,
+): antlr4.ParserRuleContext[] {
+ let current = this;
+ const ancestors = [];
+ while (current) {
+ if (!predicate || predicate(current)) {
+ ancestors.push(current);
+ }
+ current = current.parentCtx;
+ }
+ return ancestors;
+};
diff --git a/src/parser/MessageCollector.ts b/src/parser/MessageCollector.ts
index e7bf06c6..4ee26cdb 100644
--- a/src/parser/MessageCollector.ts
+++ b/src/parser/MessageCollector.ts
@@ -13,8 +13,13 @@ export class MessageCollector extends sequenceParserListener {
this._addOwnedMessage(OwnableMessageType.AsyncMessage)(ctx);
enterCreation = (ctx: any) =>
this._addOwnedMessage(OwnableMessageType.CreationMessage)(ctx);
- enterRet = (ctx: any) =>
+ enterRet = (ctx: any) => {
+ if (ctx.asyncMessage()) {
+ // it will visit the asyncMessage later
+ return;
+ }
this._addOwnedMessage(OwnableMessageType.ReturnMessage)(ctx);
+ };
private _addOwnedMessage = (type: OwnableMessageType) => (ctx: any) => {
if (this.isBlind) {
diff --git a/src/parser/index.js b/src/parser/index.js
index 348131a6..4f2a1053 100644
--- a/src/parser/index.js
+++ b/src/parser/index.js
@@ -16,7 +16,8 @@ import "./Messages/MessageContext";
import "./From";
import "./key/Key";
import "./utils/cloest-ancestor/ClosestAncestor";
-import { formatText } from "../utils/StringUtil";
+import "./AncestorPath";
+import { formatText } from "@/utils/StringUtil";
const errors = [];
class SeqErrorListener extends antlr4.error.ErrorListener {
diff --git a/src/positioning/Anchor2.spec.ts b/src/positioning/Anchor2.spec.ts
new file mode 100644
index 00000000..00a44551
--- /dev/null
+++ b/src/positioning/Anchor2.spec.ts
@@ -0,0 +1,263 @@
+import Anchor2 from "@/positioning/Anchor2";
+
+describe("Anchor2", () => {
+ describe("Center of Right Wall", () => {
+ test.each([
+ {
+ name: "0 layers",
+ position: 100,
+ layers: 0,
+ expected: 100,
+ explanation: "position",
+ },
+ {
+ name: "1 layer",
+ position: 100,
+ layers: 1,
+ expected: 100,
+ explanation: "position + WALL_OVERLAP * (layers - 1)",
+ },
+ {
+ name: "2 layers",
+ position: 100,
+ layers: 2,
+ expected: 107,
+ explanation: "position + WALL_OVERLAP * (layers - 1)",
+ },
+ ])(
+ "$name => $explanation = $expected",
+ ({ position, layers, expected }) => {
+ const a = new Anchor2(position, layers);
+
+ expect(a.centerOfRightWall()).toBe(expected);
+ },
+ );
+ });
+
+ describe("Right Edge of Right Wall", () => {
+ test.each([
+ {
+ name: "0 layers",
+ position: 100,
+ layers: 0,
+ expected: 100,
+ explanation: "position",
+ },
+ {
+ name: "1 layer",
+ position: 100,
+ layers: 1,
+ expected: 107,
+ explanation: "position + WALL_OVERLAP * layers",
+ },
+ {
+ name: "2 layers",
+ position: 100,
+ layers: 2,
+ expected: 114,
+ explanation: "position + WALL_OVERLAP * layers",
+ },
+ ])(
+ "$name => $explanation = $expected",
+ ({ position, layers, expected }) => {
+ const a = new Anchor2(position, layers);
+
+ expect(a.rightEdgeOfRightWall()).toBe(expected);
+ },
+ );
+ });
+
+ describe("Left Edge of Right Wall", () => {
+ test.each([
+ {
+ name: "0 layers",
+ position: 100,
+ layers: 0,
+ expected: 100,
+ explanation: "position",
+ },
+ {
+ name: "1 layer",
+ position: 100,
+ layers: 1,
+ expected: 93,
+ explanation: "position - WALL_OVERLAP * (layers - 1)",
+ },
+ {
+ name: "2 layers",
+ position: 100,
+ layers: 2,
+ expected: 100,
+ explanation: "position - WALL_OVERLAP * (layers - 1)",
+ },
+ ])(
+ "$name => $explanation = $expected",
+ ({ position, layers, expected }) => {
+ const a = new Anchor2(position, layers);
+
+ expect(a.leftEdgeOfRightWall()).toBe(expected);
+ },
+ );
+ });
+
+ /**
+ * centerToEdge is used for translateX calculations.
+ */
+ describe("centerToEdge", () => {
+ test.each([
+ {
+ name: "0 layer anchors",
+ anchor1: { position: 100, layers: 0 },
+ anchor2: { position: 200, layers: 0 },
+ expectedLtr: 100,
+ expectedRtl: -100,
+ explanation: "just position difference (200 - 100)",
+ },
+ {
+ name: "0 layer left anchor",
+ anchor1: { position: 100, layers: 0 },
+ anchor2: { position: 200, layers: 1 },
+ expectedLtr: 107,
+ expectedRtl: -100,
+ explanation: "(200 - 7) - 100 - 1; 100 - 200",
+ },
+ {
+ name: "0 layer right anchor 1",
+ anchor1: { position: 100, layers: 1 },
+ anchor2: { position: 200, layers: 0 },
+ expectedLtr: 100,
+ expectedRtl: -93,
+ explanation: "200 - 100; 200 - (100 + 7) - 1",
+ },
+ {
+ name: "0 layer right anchor 2",
+ anchor1: { position: 100, layers: 2 },
+ anchor2: { position: 200, layers: 0 },
+ expectedLtr: 93,
+ expectedRtl: -86,
+ explanation: "200 - 100; 200 - (100 + 7) - 1",
+ },
+ {
+ name: "single layer anchors",
+ anchor1: { position: 100, layers: 1 },
+ anchor2: { position: 200, layers: 1 },
+ expectedLtr: 107,
+ expectedRtl: -93,
+ explanation: "200 - (100 + 7) - 1; 100 - (200 - 7) + 1",
+ },
+ {
+ name: "single layer anchors same position",
+ anchor1: { position: 100, layers: 1 },
+ anchor2: { position: 100, layers: 1 },
+ expectedLtr: 7,
+ expectedRtl: 7,
+ explanation: "200 - (100 + 7) - 1; 100 - (200 - 7) + 1",
+ },
+ {
+ name: "multiple layer anchors",
+ anchor1: { position: 100, layers: 2 },
+ anchor2: { position: 200, layers: 3 },
+ expectedLtr: 114,
+ expectedRtl: -100,
+ explanation: "200 - (100 + 7) - 1; 100 - (200 - 7) + 1",
+ },
+ ])(
+ "$name => $explanation = $expected",
+ ({ anchor1, anchor2, expectedLtr, expectedRtl }) => {
+ const a1 = new Anchor2(anchor1.position, anchor1.layers);
+ const a2 = new Anchor2(anchor2.position, anchor2.layers);
+
+ expect(a1.centerToEdge(a2)).toBe(expectedLtr);
+ expect(a2.centerToEdge(a1)).toBe(expectedRtl);
+ },
+ );
+ });
+
+ /**
+ * edgeOffset is used for interactionWidth calculations.
+ */
+ describe("edgeOffset", () => {
+ test.each([
+ {
+ name: "0 layer anchors",
+ anchor1: { position: 100, layers: 0 },
+ anchor2: { position: 200, layers: 0 },
+ expected: 99,
+ explanation: "200 - 100 - 1",
+ },
+ {
+ name: "0 layer at left 1",
+ anchor1: { position: 100, layers: 0 },
+ anchor2: { position: 200, layers: 1 },
+ expected: 92,
+ explanation: "(200 - 7 * 1) - 100 - 1",
+ },
+ {
+ name: "0 layer at left",
+ anchor1: { position: 100, layers: 0 },
+ anchor2: { position: 200, layers: 2 },
+ expected: 99,
+ explanation: "(200 - 7 + 7 * (2-1)) - 100 - 1",
+ },
+ {
+ name: "0 layer at right",
+ anchor1: { position: 100, layers: 1 },
+ anchor2: { position: 200, layers: 0 },
+ expected: 92,
+ explanation: "200 - (100 + 7 * 1) - 1",
+ },
+ {
+ name: "single layer anchors",
+ anchor1: { position: 100, layers: 1 },
+ anchor2: { position: 200, layers: 1 },
+ expected: 85,
+ explanation: "200 - 7 - (100 + 7) - 1",
+ },
+ {
+ name: "multiple layers on first anchor",
+ anchor1: { position: 100, layers: 2 },
+ anchor2: { position: 200, layers: 1 },
+ expected: 78,
+ explanation: "200 - 7 - (100 + 7 * 2) - 1",
+ },
+ {
+ name: "multiple layers on first anchor",
+ anchor1: { position: 100, layers: 3 },
+ anchor2: { position: 200, layers: 1 },
+ expected: 71,
+ explanation: "(200 - 7 + 7 * (1 - 1) - (100 + 7 * 3) - 1",
+ },
+ {
+ name: "multiple layers on second anchor",
+ anchor1: { position: 100, layers: 1 },
+ anchor2: { position: 200, layers: 2 },
+ expected: 92,
+ explanation: "(200 - 7 + 7 * (2 - 1)) - (100 + 7) - 1",
+ },
+ {
+ name: "multiple layers on both anchors",
+ anchor1: { position: 100, layers: 3 },
+ anchor2: { position: 200, layers: 2 },
+ expected: 78,
+ explanation: "(200 - 7 + 7 * (2 - 1)) - (100 + 7 * 3) - 1",
+ },
+ ])(
+ "$name => $explanation = $expected",
+ ({ anchor1, anchor2, expected }) => {
+ const a1 = new Anchor2(anchor1.position, anchor1.layers);
+ const a2 = new Anchor2(anchor2.position, anchor2.layers);
+
+ expect(a1.edgeOffset(a2)).toBe(expected);
+ expect(a2.edgeOffset(a1)).toBe(expected * -1);
+ },
+ );
+
+ test("Same anchor", () => {
+ const a1 = new Anchor2(100, 2);
+ const a2 = new Anchor2(100, 2);
+
+ expect(a1.edgeOffset(a2)).toBe(-15);
+ expect(a2.edgeOffset(a1)).toBe(-15);
+ });
+ });
+});
diff --git a/src/positioning/Anchor2.ts b/src/positioning/Anchor2.ts
new file mode 100644
index 00000000..6b860683
--- /dev/null
+++ b/src/positioning/Anchor2.ts
@@ -0,0 +1,57 @@
+import {
+ LIFELINE_WIDTH,
+ OCCURRENCE_BAR_SIDE_WIDTH,
+} from "@/positioning/Constants";
+
+export default class Anchor2 {
+ constructor(
+ private position: number,
+ private layers: number,
+ ) {}
+
+ /**
+ * centerToEdge is used for translateX calculations.
+ */
+ centerToEdge(other: Anchor2): number {
+ return other.rightEdgeOfRightWall() - this.centerOfRightWall();
+ }
+
+ /**
+ * edgeOffset is used for interactionWidth calculations.
+ */
+ edgeOffset(other: Anchor2): number {
+ const isRightToLeft = other.position < this.position;
+
+ let leftAnchor: Anchor2;
+ let rightAnchor: Anchor2;
+ if (isRightToLeft) {
+ leftAnchor = other;
+ rightAnchor = this;
+ } else {
+ leftAnchor = this;
+ rightAnchor = other;
+ }
+
+ const rightEdgeOfLeftAnchor = leftAnchor.rightEdgeOfRightWall();
+ const leftEdgeOfRightAnchor = rightAnchor.leftEdgeOfRightWall();
+ const distance =
+ leftEdgeOfRightAnchor - rightEdgeOfLeftAnchor - LIFELINE_WIDTH;
+ return isRightToLeft ? distance * -1 : distance;
+ }
+
+ centerOfRightWall(): number {
+ return this.layers <= 1
+ ? this.position
+ : this.position + OCCURRENCE_BAR_SIDE_WIDTH * (this.layers - 1);
+ }
+
+ rightEdgeOfRightWall() {
+ return this.position + OCCURRENCE_BAR_SIDE_WIDTH * this.layers;
+ }
+
+ leftEdgeOfRightWall() {
+ return this.layers === 0
+ ? this.position
+ : this.centerOfRightWall() - OCCURRENCE_BAR_SIDE_WIDTH;
+ }
+}
diff --git a/src/positioning/Constants.ts b/src/positioning/Constants.ts
index e54afb0a..73824b43 100644
--- a/src/positioning/Constants.ts
+++ b/src/positioning/Constants.ts
@@ -3,7 +3,7 @@ export const FRAGMENT_MIN_WIDTH = 100;
export const MARGIN = 20;
export const ARROW_HEAD_WIDTH = 10;
export const OCCURRENCE_WIDTH = 15;
-export const OCCURRENCE_BAR_SIDE_WIDTH = (OCCURRENCE_WIDTH - 2) / 2; // Width of each side of the occurrence bar
+export const OCCURRENCE_BAR_SIDE_WIDTH = (OCCURRENCE_WIDTH - 1) / 2; // Width of each side of the occurrence bar
// also used in css `.zenuml .participant { min-width: 88px; }`
export const MIN_PARTICIPANT_WIDTH = 80;
diff --git a/src/positioning/MessageCollector.spec.ts b/src/positioning/MessageCollector.spec.ts
index 2ccc8314..80dc7797 100644
--- a/src/positioning/MessageCollector.spec.ts
+++ b/src/positioning/MessageCollector.spec.ts
@@ -12,6 +12,18 @@ describe("MessageCollector", () => {
};
describe("Return", () => {
+ it("@return A->B:m", () => {
+ const code = `@return A->B:m`;
+
+ expect(collectMessages(code)).toStrictEqual([
+ {
+ from: "A",
+ signature: "m",
+ to: "B",
+ type: OwnableMessageType.AsyncMessage,
+ },
+ ]);
+ });
it("should handle one return message", () => {
const code = `
return result
diff --git a/test/unit/parser/fixture/Fixture.ts b/test/unit/parser/fixture/Fixture.ts
index 0cdb360a..a7f69fa6 100644
--- a/test/unit/parser/fixture/Fixture.ts
+++ b/test/unit/parser/fixture/Fixture.ts
@@ -9,6 +9,10 @@ export class Fixture {
return rootContext && rootContext.block().stat()[0];
}
+ static firstMessage(code: string) {
+ return Fixture.firstStatement(code).message();
+ }
+
static firstChild(code: string) {
return Fixture.firstStatement(code)
.children[0].braceBlock()
diff --git a/test/unit/parser/participant/Participants.Order.spec.ts b/test/unit/parser/participant/Participants.Order.spec.ts
index f8e93bd6..3fbb8a1c 100644
--- a/test/unit/parser/participant/Participants.Order.spec.ts
+++ b/test/unit/parser/participant/Participants.Order.spec.ts
@@ -34,6 +34,7 @@ import {
_STARTER_,
OrderedParticipants,
} from "../../../../src/parser/OrderedParticipants";
+import { expect } from "vitest";
function getFlattenedParticipants(code: string) {
const rootContext = RootContext(code);
@@ -41,6 +42,12 @@ function getFlattenedParticipants(code: string) {
}
describe("Participants.Order", () => {
+ it("@return", () => {
+ expect(getFlattenedParticipants("@return A->B:m")).toEqual([
+ { name: "A", left: "" },
+ { name: "B", left: "A" },
+ ]);
+ });
it("should return the order of participants", () => {
expect(getFlattenedParticipants("A as A1 B C.m")).toEqual([
{ name: _STARTER_, left: "" },
diff --git a/test/unit/parser/to-collector.spec.js b/test/unit/parser/to-collector.spec.js
index d0d59df0..9093e1a1 100644
--- a/test/unit/parser/to-collector.spec.js
+++ b/test/unit/parser/to-collector.spec.js
@@ -4,6 +4,12 @@ import ToCollector from "../../../src/parser/ToCollector";
import { expect } from "vitest";
import { blankParticipant } from "../../../src/parser/Participants";
+test("@return", () => {
+ let participants = getParticipants("@return A->B.m");
+ expect(participants.Size()).toBe(2);
+ expect(participants.First().name).toBe("A");
+});
+
test("if block", () => {
let participants = getParticipants("if(x) { A->B.m }");
expect(participants.Size()).toBe(2);
diff --git a/vite.config.js b/vite.config.js
index fe3c4d26..21c8288c 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -50,8 +50,13 @@ export default defineConfig(({ mode }) => ({
svgLoader(),
],
test: {
+ // used by vitest: https://vitest.dev/guide/#configuring-vitest
environment: "jsdom",
+ reportOnFailure: true,
globals: true,
+ coverage: {
+ provider: "v8", // or 'v8'
+ },
deps: {
inline: ["@vue/test-utils"],
},