@meltemi/diagrams-edit 1.9.0 → 1.10.17

package/dist/sequence.js

@@ -1,12 +1,13 @@
-import { FRAGMENT_BRANCH_KEYWORDS, FRAGMENT_OPERATORS, PARTICIPANT_KINDS, } from "@meltemi/diagrams-model";
+import { isToken, } from "@meltemi/diagrams-language";
+import { FRAGMENT_BRANCH_KEYWORDS, FRAGMENT_OPERATORS, PARTICIPANT_KINDS, relationNameAnchor, } from "@meltemi/diagrams-model";
 import { insertStatement, reject, requireElement } from "./context.js";
 import { declarationText, usedIds } from "./create.js";
 import { deleteStatements } from "./delete.js";
-import { diagramBody, groupBlock, insertAfter, insertBefore, insertDeclaration, isDeclaration, reindent, verifyNoNewErrors, } from "./insert.js";
+import { commentsAbove, diagramBody, groupBlock, insertAfter, insertBefore, insertBeforeStatement, insertDeclaration, isDeclaration, reindent, verifyNoNewErrors, } from "./insert.js";
 import { reasons } from "./messages/index.js";
 import { insertPlacements, removeListItems, requireNewId } from "./plan.js";
 import { relationDependents } from "./relations.js";
-import { formatNumber, lineIndent, quoteString } from "./text.js";
+import { formatNumber, isCommentTrivia, lineIndent, lineStart, quoteString } from "./text.js";
 import { renameInStories } from "./stories.js";
 const PARTICIPANTS = new Set(PARTICIPANT_KINDS);
 const EVENT_KEYWORDS = new Set([
@@ -17,6 +18,7 @@ const EVENT_KEYWORDS = new Set([
     "note",
     "divider",
     "delay",
+    "return",
     ...FRAGMENT_OPERATORS,
 ]);
 /** Refuses an operation on a diagram that is not a sequence diagram. */
@@ -49,11 +51,23 @@ function requireFragment(ctx, key) {
         reject("edit.unsafe-target", reasons().sequence.notFragment(key));
     return event;
 }
-/** The block that holds an event: the diagram body or a fragment branch. */
+/** The block of a call: the block on its relation statement. */
+function callBlock(call) {
+    const node = call.node;
+    return node.kind === "RelationStatement" && node.block?.kind === "Block" ? node.block : undefined;
+}
+/** The block that holds an event: the diagram body, a fragment branch or a call's block. */
 function containerOf(ctx, event) {
     const place = event.path[event.path.length - 1];
     if (!place)
         return { block: diagramBody(ctx), owner: ctx.diagram.node.start };
+    if ("message" in place) {
+        const call = requireEvent(ctx, place.message);
+        const block = call.kind === "message" ? callBlock(call) : undefined;
+        if (!block)
+            reject("edit.unsafe-target", reasons().sequence.noCallBlock(place.message));
+        return { block, owner: call.node.start };
+    }
     const fragment = requireFragment(ctx, place.fragment);
     return { block: fragment.branches[place.branch].block, owner: fragment.node.start };
 }
@@ -133,7 +147,12 @@ export function reorderParticipant(ctx, op) {
 // ---------------------------------------------------------------------- events
 export function moveEvent(ctx, op) {
     requireSequence(ctx);
+    if ((op.direction === undefined) === (op.to === undefined)) {
+        reject("edit.invalid-value", reasons().sequence.moveForm);
+    }
     const event = requireEvent(ctx, op.event);
+    if (op.to !== undefined)
+        return moveTo(ctx, event, op.to);
     const statement = event.node;
     const { block } = containerOf(ctx, event);
     const list = siblings(block);
@@ -146,7 +165,25 @@ export function moveEvent(ctx, op) {
             FRAGMENT_OPERATORS.includes(neighbour.keyword.text)
             ? [...ctx.diagram.eventsByKey.values()].find((e) => e.node === neighbour)
             : undefined;
-        if (fragment && fragment.kind === "fragment") {
+        const call = neighbour.kind === "RelationStatement"
+            ? [...ctx.diagram.eventsByKey.values()].find((e) => e.node === neighbour)
+            : undefined;
+        if (call?.kind === "message" && call.events.length > 0) {
+            // Into the adjacent call's block: before its trailing `return` going up, so that the
+            // return stays last; at its start going down.
+            const block = callBlock(call);
+            const inner = siblings(block);
+            const last = inner[inner.length - 1];
+            const returns = last?.kind === "KeywordStatement" && last.keyword.text === "return";
+            edits = up
+                ? returns
+                    ? relocate(ctx, statement, { kind: "before", anchor: last, block })
+                    : relocate(ctx, statement, { kind: "end", block, owner: call.node.start })
+                : inner[0]
+                    ? relocate(ctx, statement, { kind: "before", anchor: inner[0], block })
+                    : relocate(ctx, statement, { kind: "start", block, owner: call.node.start });
+        }
+        else if (fragment && fragment.kind === "fragment") {
             // Into the adjacent fragment: the end of its last branch, or the start of its first.
             const branch = up ? fragment.branches[fragment.branches.length - 1] : fragment.branches[0];
             edits = relocate(ctx, statement, {
@@ -160,10 +197,22 @@ export function moveEvent(ctx, op) {
         }
     }
     else {
-        // At the edge of a branch: into the neighbouring branch, or out of the fragment.
+        // At the edge of a branch: into the neighbouring branch, or out of the fragment; at the
+        // edge of a call's block, out of the call.
         const place = event.path[event.path.length - 1];
         if (!place)
             return [];
+        if ("message" in place) {
+            const call = requireEvent(ctx, place.message);
+            const outer = containerOf(ctx, call);
+            const edits = relocate(ctx, statement, {
+                kind: up ? "before" : "after",
+                anchor: call.node,
+                block: outer.block,
+            });
+            verifyNoNewErrors(ctx, edits);
+            return edits;
+        }
         const fragment = requireFragment(ctx, place.fragment);
         const next = fragment.branches[place.branch + (up ? -1 : 1)];
         if (next) {
@@ -185,6 +234,107 @@ export function moveEvent(ctx, op) {
     verifyNoNewErrors(ctx, edits);
     return edits;
 }
+/**
+ * Moves an event's statement right after or right before the statement of another event, in the
+ * block that holds that one, at its indentation; checked once on the result. A statement with its
+ * lines to itself takes the comment lines right above it and the comment that ends its line.
+ */
+function moveTo(ctx, event, to) {
+    const written = to;
+    const after = typeof to === "object" && to !== null ? written.after : undefined;
+    const before = typeof to === "object" && to !== null ? written.before : undefined;
+    const key = after ?? before;
+    if ((after === undefined) === (before === undefined) || typeof key !== "string") {
+        reject("edit.invalid-value", reasons().sequence.destinationForm);
+    }
+    const anchor = requireEvent(ctx, key);
+    if (anchor === event) {
+        reject("edit.unsafe-target", reasons().sequence.moveBesideItself(event.key));
+    }
+    if (anchor.path.some((p) => ("fragment" in p ? p.fragment : p.message) === event.key)) {
+        reject("edit.unsafe-target", reasons().sequence.moveIntoItself(event.key, anchor.key));
+    }
+    const { block } = containerOf(ctx, anchor);
+    const statement = event.node;
+    // Already there: nothing to write.
+    const at = block.statements.indexOf(anchor.node);
+    if (block.statements[after !== undefined ? at + 1 : at - 1] === statement)
+        return [];
+    const own = ownLines(ctx, containerOf(ctx, event).block, statement);
+    const oldIndent = lineIndent(ctx.text, statement.start);
+    // The comments go along only when the statement lands on a line of its own.
+    let inline = false;
+    const render = (indent) => {
+        if (indent === null) {
+            inline = true;
+            return moved(ctx, statement, lineIndent(ctx.text, anchor.node.start));
+        }
+        if (!own)
+            return moved(ctx, statement, indent);
+        const from = own.from + lineIndent(ctx.text, own.from).length;
+        return reindent(ctx.text.slice(from, own.to), oldIndent, indent);
+    };
+    const insertion = after !== undefined
+        ? insertAfter(ctx, block, anchor.node, render)
+        : insertBeforeStatement(ctx, block, anchor.node, render);
+    const edits = own && !inline
+        ? [{ start: own.from, end: own.end, newText: "" }, insertion]
+        : [...deleteStatements(ctx.text, ctx.compilation.parse.root, [statement]), insertion];
+    verifyNoNewErrors(ctx, edits);
+    return edits;
+}
+/**
+ * The lines of a statement that has them to itself: from the comment lines right above it to the
+ * line break that ends it (`from`, `end`), the text to move ending with the comment that ends its
+ * line (`to`). Undefined when it shares a line with another statement.
+ */
+function ownLines(ctx, block, statement) {
+    const start = lineStart(ctx.text, statement.start);
+    if (start + lineIndent(ctx.text, start).length !== statement.start)
+        return undefined;
+    const children = block.children;
+    let terminator;
+    for (let i = children.indexOf(statement) + 1; i < children.length; i++) {
+        const child = children[i];
+        if (isToken(child) && child.kind === "Semicolon")
+            continue;
+        if (isToken(child) && child.kind === "Newline")
+            terminator = child;
+        break;
+    }
+    if (!terminator)
+        return undefined;
+    const above = commentsAbove(block, statement)[0];
+    const trailing = terminator.leadingTrivia.filter(isCommentTrivia);
+    return {
+        from: above ? lineStart(ctx.text, above.start) : start,
+        to: trailing.length > 0 ? trailing[trailing.length - 1].end : statement.end,
+        end: terminator.end,
+    };
+}
+/**
+ * The other end of an activation: the `deactivate` that closes an `activate` (the participant's
+ * first `deactivate` at the same depth after it, in order, fragments and calls included), or the
+ * `activate` that a `deactivate` closes; null for an activation open to the end, a `deactivate`
+ * that closes none, and every other event.
+ */
+export function activationPair(diagram, event) {
+    if (event.kind !== "activate" && event.kind !== "deactivate")
+        return null;
+    const order = withNested(diagram.events).filter((e) => (e.kind === "activate" || e.kind === "deactivate") && e.participant === event.participant);
+    const step = event.kind === "activate" ? 1 : -1;
+    let depth = 0;
+    for (let i = order.indexOf(event) + step; i >= 0 && i < order.length; i += step) {
+        const other = order[i];
+        if (other.kind === event.kind)
+            depth++;
+        else if (depth === 0)
+            return other;
+        else
+            depth--;
+    }
+    return null;
+}
 /** A fresh id for a note, a fragment or a message, as `createElement` would choose ids. */
 function freshEventId(ctx, base) {
     const used = usedIds(ctx);
@@ -204,8 +354,7 @@ function namedEvent(ctx, event) {
     if (event.kind === "message") {
         const relation = ctx.diagram.relationsByKey.get(event.relation);
         const id = freshEventId(ctx, `${relation.from}_${relation.to}`);
-        const statement = relation.node;
-        const anchor = statement.label && "end" in statement.label ? statement.label.end : statement.target.end;
+        const anchor = relationNameAnchor(relation);
         return { id, edits: [{ start: anchor, end: anchor, newText: ` as ${id}` }] };
     }
     if (event.kind === "note" || event.kind === "fragment") {
@@ -217,14 +366,18 @@ function namedEvent(ctx, event) {
 }
 export function setSpacing(ctx, op) {
     requireSequence(ctx);
-    const amount = op.amount === null || op.amount <= 0 ? null : Math.round(op.amount);
+    const side = op.side ?? "before";
+    const amount = op.amount === null || Math.round(op.amount) === 0 ? null : Math.round(op.amount);
     const statement = op.targetKind === "event" ? "space" : "gap";
+    const onSide = (p) => (p.statement === "space" || p.statement === "gap") && p.side === side;
     let id;
     const edits = [];
     if (op.targetKind === "event") {
+        if (amount !== null && amount < 0)
+            reject("edit.invalid-value", reasons().sequence.negativeSpace);
         const event = requireEvent(ctx, op.target);
         const entry = event.id
-            ? ctx.diagram.placement.find((p) => p.statement === "space" && p.target === event.id)
+            ? ctx.diagram.placement.find((p) => p.statement === "space" && p.target === event.id && onSide(p))
             : undefined;
         if (!entry && amount === null)
             return [];
@@ -237,8 +390,13 @@ export function setSpacing(ctx, op) {
         if (!PARTICIPANTS.has(element.kind))
             reject("edit.unsafe-target", reasons().sequence.notParticipant(element.id));
         id = element.id;
+        // Before the first participant and after the last there is nothing to bring closer.
+        const order = ctx.diagram.elements.filter((e) => e.kind !== "group");
+        const edge = side === "before" ? order[0]?.id === id : order[order.length - 1]?.id === id;
+        if (amount !== null && amount < 0 && edge)
+            reject("edit.invalid-value", reasons().sequence.outerGap(id));
     }
-    const entry = ctx.diagram.placement.find((p) => p.statement === statement && p.target === id);
+    const entry = ctx.diagram.placement.find((p) => p.statement === statement && p.target === id && onSide(p));
     if (entry) {
         if (amount === null) {
             edits.push(...deleteStatements(ctx.text, ctx.compilation.parse.root, [entry.node]));
@@ -253,7 +411,9 @@ export function setSpacing(ctx, op) {
         }
     }
     else if (amount !== null) {
-        edits.push(insertPlacements(ctx, [`${statement} ${id} ${formatNumber(amount)}`]));
+        // `before` is the default and never written.
+        const written = side === "after" ? " after" : "";
+        edits.push(insertPlacements(ctx, [`${statement} ${id} ${formatNumber(amount)}${written}`]));
     }
     verifyNoNewErrors(ctx, edits);
     return edits;
@@ -266,6 +426,27 @@ export function insertEvent(ctx, op) {
         const { block } = containerOf(ctx, event);
         edit = insertAfter(ctx, block, event.node, (indent) => reindent(op.statement, "", indent ?? ""));
     }
+    else if (op.inside !== undefined && "message" in op.inside) {
+        // Last in the call's block, which is created when the call has none.
+        const call = requireEvent(ctx, op.inside.message);
+        if (call.kind !== "message" || call.node.kind !== "RelationStatement") {
+            reject("edit.unsafe-target", reasons().sequence.notMessage(op.inside.message));
+        }
+        const node = call.node;
+        const block = callBlock(call);
+        if (block) {
+            edit = insertStatement(ctx, block, node.start, (indent) => reindent(op.statement, "", indent ?? ""));
+        }
+        else {
+            const indent = lineIndent(ctx.text, node.start);
+            const inner = indent + ctx.unit;
+            edit = {
+                start: node.end,
+                end: node.end,
+                newText: ` {${ctx.eol}${inner}${reindent(op.statement, "", inner)}${ctx.eol}${indent}}`,
+            };
+        }
+    }
     else if (op.inside !== undefined) {
         const fragment = requireFragment(ctx, op.inside.fragment);
         const branch = fragment.branches[op.inside.branch];
@@ -436,6 +617,9 @@ export function participantEvents(ctx, removed) {
                 for (const branch of event.branches)
                     visit(branch.events);
             }
+            else if (event.kind === "message") {
+                visit(event.events);
+            }
         }
     };
     visit(ctx.diagram.events);
@@ -447,13 +631,16 @@ export function removeEvent(ctx, op) {
     if (event.kind === "message") {
         reject("edit.unsafe-target", reasons().sequence.removeMessage);
     }
-    // A fragment goes with its events, and everything goes with what names them.
+    // A fragment goes with its events, an activation with its other end (unless it goes alone), and
+    // everything goes with what names them.
     const all = withNested([event]);
+    const pair = op.alone === true ? null : activationPair(ctx.diagram, event);
     const events = eventDependents(ctx, eventIdsOf(all));
     const relations = relationDependents(ctx, new Set(all.flatMap((e) => (e.kind === "message" && e.id !== null ? [e.id] : []))));
     const edits = [
         ...deleteStatements(ctx.text, ctx.compilation.parse.root, [
             event.node,
+            ...(pair ? [pair.node] : []),
             ...events.statements,
             ...relations.statements,
         ]),
@@ -463,7 +650,7 @@ export function removeEvent(ctx, op) {
     verifyNoNewErrors(ctx, edits);
     return edits;
 }
-/** The events with the events of the fragments among them, in order. */
+/** The events with the events of the fragments and calls among them, in order. */
 function withNested(events) {
     const all = [];
     const visit = (list) => {
@@ -472,11 +659,30 @@ function withNested(events) {
             if (event.kind === "fragment")
                 for (const branch of event.branches)
                     visit(branch.events);
+            if (event.kind === "message")
+                visit(event.events);
         }
     };
     visit(events);
     return all;
 }
+/** The events inside the blocks of the calls among `relations` (keys), at any depth. */
+export function nestedInCalls(ctx, relations) {
+    const found = [];
+    const visit = (events) => {
+        for (const event of events) {
+            if (event.kind === "fragment")
+                for (const branch of event.branches)
+                    visit(branch.events);
+            else if (event.kind === "message" && relations.has(event.relation))
+                found.push(...withNested(event.events));
+            else if (event.kind === "message")
+                visit(event.events);
+        }
+    };
+    visit(ctx.diagram.events);
+    return found;
+}
 /** The written ids of the notes and fragments among `events`. */
 export function eventIdsOf(events) {
     return new Set(events.flatMap((e) => (e.kind !== "message" && e.id !== null ? [e.id] : [])));
@@ -558,6 +764,10 @@ export function toggleActivation(ctx, op) {
     if (message.kind !== "message")
         reject("edit.unsafe-target", reasons().sequence.notMessage(op.after));
     const relation = ctx.diagram.relationsByKey.get(message.relation);
+    // A call's block activates its receiver already.
+    if (message.events.length > 0) {
+        reject("edit.invalid-value", reasons().sequence.callActivates(message.key, relation.to));
+    }
     const { block } = containerOf(ctx, message);
     const events = eventsOfBlock(ctx, message);
     const index = events.indexOf(message);
@@ -565,23 +775,7 @@ export function toggleActivation(ctx, op) {
     let edits;
     if (next?.kind === "activate" && next.participant === element.id) {
         // The matching `deactivate`: the first one at the same depth, at any later point in order.
-        const order = withNested(ctx.diagram.events);
-        let depth = 0;
-        let match;
-        for (const event of order.slice(order.indexOf(next) + 1)) {
-            if (event.kind !== "activate" && event.kind !== "deactivate")
-                continue;
-            if (event.participant !== element.id)
-                continue;
-            if (event.kind === "activate")
-                depth++;
-            else if (depth === 0) {
-                match = event;
-                break;
-            }
-            else
-                depth--;
-        }
+        const match = activationPair(ctx.diagram, next);
         edits = deleteStatements(ctx.text, ctx.compilation.parse.root, match ? [next.node, match.node] : [next.node]);
     }
     else {
@@ -612,6 +806,10 @@ function eventsOfBlock(ctx, event) {
     const place = event.path[event.path.length - 1];
     if (!place)
         return ctx.diagram.events;
+    if ("message" in place) {
+        const call = requireEvent(ctx, place.message);
+        return call.kind === "message" ? call.events : [];
+    }
     const fragment = requireFragment(ctx, place.fragment);
     return fragment.branches[place.branch].events;
 }
@@ -692,4 +890,117 @@ export function setFragmentOperator(ctx, op) {
     verifyNoNewErrors(ctx, edits);
     return edits;
 }
+// ---------------------------------------------------------------------- call blocks
+/** The start of the comment lines right above a line, with no blank line between. */
+function leadingComments(text, lineStart) {
+    let from = lineStart;
+    while (from > 0) {
+        const previous = text.lastIndexOf("\n", from - 2) + 1;
+        if (!text
+            .slice(previous, from - 1)
+            .trim()
+            .startsWith("//"))
+            break;
+        from = previous;
+    }
+    return from;
+}
+export function nestInCall(ctx, op) {
+    requireSequence(ctx);
+    const call = requireEvent(ctx, op.call);
+    if (call.kind !== "message" || call.node.kind !== "RelationStatement") {
+        reject("edit.unsafe-target", reasons().sequence.notMessage(op.call));
+    }
+    const node = call.node;
+    // The events must be the siblings right after the call, in order.
+    const siblingsOfCall = eventsOfBlock(ctx, call);
+    const at = siblingsOfCall.indexOf(call);
+    const chosen = op.events.map((key) => requireEvent(ctx, key));
+    const following = siblingsOfCall.slice(at + 1, at + 1 + chosen.length);
+    const ordered = [...chosen].sort((a, b) => a.node.start - b.node.start);
+    if (chosen.length === 0 || ordered.some((event, i) => event !== following[i])) {
+        reject("edit.unsafe-target", reasons().sequence.nestAfterCall);
+    }
+    if (ordered.some((event) => event.node.kind === "KeywordStatement" && event.node.keyword.text === "return")) {
+        reject("edit.unsafe-target", reasons().sequence.nestReturn);
+    }
+    const first = ordered[0].node;
+    const last = ordered[ordered.length - 1].node;
+    const indent = lineIndent(ctx.text, node.start);
+    const inner = indent + ctx.unit;
+    // The comment lines right above the first event move with it.
+    const firstLine = ctx.text.lastIndexOf("\n", first.start - 1) + 1;
+    const from = leadingComments(ctx.text, firstLine);
+    const own = lineIndent(ctx.text, first.start);
+    const text = reindent(ctx.text.slice(from + own.length, last.end), own, inner);
+    const block = callBlock(call);
+    const edits = [
+        ...deleteStatements(ctx.text, ctx.compilation.parse.root, ordered.map((e) => e.node)),
+    ];
+    if (from < firstLine)
+        edits.push({ start: from, end: firstLine, newText: "" });
+    edits.unshift(block
+        ? insertStatement(ctx, block, node.start, (blockIndent) => reindent(text, inner, blockIndent ?? inner))
+        : {
+            start: node.end,
+            end: node.end,
+            newText: ` {${ctx.eol}${inner}${text}${ctx.eol}${indent}}`,
+        });
+    verifyNoNewErrors(ctx, edits);
+    return edits;
+}
+export function unnestCall(ctx, op) {
+    requireSequence(ctx);
+    const call = requireEvent(ctx, op.call);
+    if (call.kind !== "message" || call.node.kind !== "RelationStatement") {
+        reject("edit.unsafe-target", reasons().sequence.notMessage(op.call));
+    }
+    const node = call.node;
+    const block = callBlock(call);
+    const events = block ? siblings(block) : [];
+    if (!block || events.length === 0) {
+        reject("edit.unsafe-target", reasons().sequence.noCallBlock(call.key));
+    }
+    const relation = ctx.diagram.relationsByKey.get(call.relation);
+    // Every `return` answering this call, at any depth of fragments inside its block, becomes a
+    // written reply in place: `<callee> --> <caller>`, its label, id and block kept.
+    const rewrites = [];
+    for (const reply of ctx.diagram.relations) {
+        if (reply.returns !== call.key || reply.node.kind !== "KeywordStatement")
+            continue;
+        const keyword = reply.node.keyword;
+        const label = reply.node.args[0]?.kind === "StringLiteral" ? reply.node.args[0] : undefined;
+        const arrow = `${relation.to} --> ${relation.from}`;
+        rewrites.push(label
+            ? { start: keyword.start, end: label.start, newText: `${arrow}: ` }
+            : { start: keyword.start, end: keyword.end, newText: arrow });
+    }
+    const first = events[0];
+    const last = events[events.length - 1];
+    const from = first.start;
+    // The moved text, with the rewrites applied inside it.
+    let slice = ctx.text.slice(from, last.end);
+    for (const rewrite of [...rewrites].sort((a, b) => b.start - a.start)) {
+        slice =
+            slice.slice(0, rewrite.start - from) + rewrite.newText + slice.slice(rewrite.end - from);
+    }
+    const indent = lineIndent(ctx.text, node.start);
+    const text = reindent(slice, lineIndent(ctx.text, first.start), indent);
+    const properties = block.statements.filter((s) => !isEventStatement(s));
+    const interleaved = properties.some((p) => p.start > first.start && p.end < last.end);
+    if (interleaved)
+        reject("edit.unsafe-target", reasons().sequence.unnestInterleaved(call.key));
+    const edits = [];
+    if (properties.length === 0) {
+        // Only events were in the block: the block goes, from the end of what precedes it.
+        const before = node.id && isToken(node.id) ? node.id.end : relationNameAnchor(relation);
+        edits.push({ start: before, end: node.end, newText: `${ctx.eol}${indent}${text}` });
+    }
+    else {
+        edits.push(...deleteStatements(ctx.text, ctx.compilation.parse.root, events));
+        edits.push({ start: node.end, end: node.end, newText: `${ctx.eol}${indent}${text}` });
+    }
+    verifyNoNewErrors(ctx, edits);
+    return edits;
+}
 //# sourceMappingURL=sequence.js.map