sysml-diagram 0.25.0 → 0.26.0

package/out/main.js

@@ -162649,7 +162649,12 @@ function keywordFor(node) {
     JoinNode: "join",
     TerminateNode: "terminate",
     PerformStmt: "perform action",
-    EventDecl: "event occurrence"
+    EventDecl: "event occurrence",
+    // REQ-198, issue #113: a state sub-action drawn as a state-transition
+    // node keeps the keyword that says WHEN it runs (OMG 8.2.2.18.1).
+    EntryAction: "entry action",
+    DoAction: "do action",
+    ExitAction: "exit action"
   };
   if (t === "ActionDecl" && n2.inlineBody?.$type === "AcceptNode") {
     return "accept action";
@@ -167625,7 +167630,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const def = this.resolveType(holder, index2);
       return def && def !== holder && def.isDef === true ? def : void 0;
     };
-    const ownStates = (holder) => membersOf(holder).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
+    const ownStates = (holder) => membersOf(holder).map((member) => this.thenActionMemberNode(member) ?? member).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
     const nestedStates = (holder) => {
       const out = ownStates(holder);
       const def = definitionOf(holder);
@@ -167664,9 +167669,28 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       drawnStates.push({ node: anchor, id: anchorFrameId });
       idByState.set(anchor, anchorFrameId);
     }
+    const drawnRowKeys = /* @__PURE__ */ new Set();
+    const rowKey = (source) => source ? `${source.uri} ${source.range.start.line} ${source.range.start.character}` : void 0;
+    const registerDrawn = (member) => {
+      const key = rowKey(sourceOf2(member, uri));
+      if (key)
+        drawnRowKeys.add(key);
+    };
+    const namesByFrame = /* @__PURE__ */ new Map();
+    const namesIn = (frameId) => {
+      const key = frameId ?? "";
+      const existing = namesByFrame.get(key);
+      if (existing)
+        return existing;
+      const created = /* @__PURE__ */ new Map();
+      namesByFrame.set(key, created);
+      return created;
+    };
     const renderState = (s, parentFrame, depth, seen) => {
       const id2 = qnameOf(s) || nameOf2(s);
       byName.set(nameOf2(s), id2);
+      namesIn(parentFrame).set(nameOf2(s), id2);
+      registerDrawn(s);
       drawnStates.push({ node: s, id: id2 });
       idByState.set(s, id2);
       const def = s.isDef === true ? void 0 : this.resolveType(s, index2);
@@ -167704,6 +167728,75 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     };
     for (const s of topStates)
       renderState(s, anchorFrameId, 0, /* @__PURE__ */ new Set());
+    const endpointName = (path10) => typeof path10 === "string" ? path10.split(/::|\./).pop() || void 0 : void 0;
+    const controlNodeInfo = (m) => {
+      switch (m.$type) {
+        case "ActionDecl":
+          return m.isDef === true || !nameOf2(m) ? void 0 : { shape: "action", label: nameOf2(m) };
+        // A `perform` names the action it performs, which for a feature
+        // chain (`perform machine.selfTest;`) is the LAST segment.
+        case "PerformStmt": {
+          const segments = [nameOf2(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
+          return { shape: "action", label: segments.at(-1) ?? typeText(m) ?? "perform" };
+        }
+        // User direction 2026-08-30: fork and join only. They express
+        // concurrency, which a transition cannot say: nothing about a
+        // guard or a trigger splits control into parallel regions or
+        // gathers it again. `decide` and `merge` are dropped because a
+        // branch between states IS a guarded transition, which this
+        // view already draws and labels, so a diamond would say the
+        // same thing a second time in the action-flow idiom.
+        // `terminate` is dropped with them: the node carries no name,
+        // so no succession can reach it and it could only ever stand
+        // alone. All three remain in the OMG 8.2.3.18 node set.
+        case "JoinNode":
+          return { shape: "join", label: nameOf2(m) ?? "" };
+        case "ForkNode":
+          return { shape: "fork", label: nameOf2(m) ?? "" };
+        default:
+          return void 0;
+      }
+    };
+    const isInitialMarker = (member) => {
+      const entry = member;
+      return !!entry && entry.$type === "EntryAction" && !entry.name && !entry.actionKw && !entry.send && !entry.accept && !entry.assign;
+    };
+    const machineNodeIds = /* @__PURE__ */ new Map();
+    const machineNodeMembers = [];
+    let anonymousNodes = 0;
+    const emitMachineNodes = (holder, frameId) => {
+      const members = membersOf(holder);
+      const drawnHere = namesIn(frameId);
+      for (const raw of members) {
+        const member = this.thenActionMemberNode(raw) ?? raw;
+        const info = controlNodeInfo(member);
+        if (!info)
+          continue;
+        const name = nameOf2(member);
+        if (name && drawnHere.has(name))
+          continue;
+        const id2 = name ? qnameOf(member) || `${frameId}::${name}` : `${frameId}::__stv_${member.$type}_${anonymousNodes++}__`;
+        if (nodes.some((n2) => n2.id === id2) || frames.some((f) => f.id === id2))
+          continue;
+        if (name) {
+          drawnHere.set(name, id2);
+          if (!byName.has(name))
+            byName.set(name, id2);
+        }
+        machineNodeIds.set(member, id2);
+        machineNodeMembers.push({ member, id: id2 });
+        nodes.push({
+          id: id2,
+          name: info.label,
+          keyword: keywordFor(member),
+          isDef: false,
+          shape: info.shape,
+          compartments: this.compartmentsFor(member, uri, index2),
+          frame: frameId,
+          source: sourceOf2(member, uri)
+        });
+      }
+    };
     const edges = [];
     let e = 0;
     const resolveState = (nm) => {
@@ -167719,53 +167812,201 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
       return void 0;
     };
-    const transitionScope = [anchor, ...definitionOf(anchor) ? [definitionOf(anchor)] : []];
-    for (const t of transitionScope.flatMap((holder) => [...ast_utils_exports.streamAllContents(holder)])) {
-      if (t.$type !== "TransitionDecl")
-        continue;
-      const tn = t;
-      const from = resolveState(tn.from);
-      const to = resolveState(tn.to);
+    const drawnEdges = /* @__PURE__ */ new Set();
+    const stateLike = /* @__PURE__ */ new Set(["state", "initial", "final"]);
+    const isStateEndpoint = (id2) => {
+      const node = nodes.find((n2) => n2.id === id2);
+      return node ? stateLike.has(node.shape) : frames.some((f) => f.id === id2);
+    };
+    const link = (from, to, label, src) => {
       if (!from || !to)
-        continue;
+        return;
+      const kind = isStateEndpoint(from) && isStateEndpoint(to) ? "transition" : "succession";
+      const key = `${from}\0${to}\0${label ?? ""}`;
+      if (drawnEdges.has(key))
+        return;
+      drawnEdges.add(key);
+      if (src)
+        registerDrawn(src);
       edges.push({
         id: `e${e++}`,
         from,
         to,
-        kind: "transition",
-        label: this.transitionLabel(t),
-        source: sourceOf2(t, uri)
+        kind,
+        label,
+        source: src ? sourceOf2(src, uri) : void 0
       });
+    };
+    const guardText = (guard) => {
+      const text = guard?.$cstNode?.text?.replace(/\s+/g, " ").trim();
+      return text ? `[${text}]` : void 0;
+    };
+    const resolveEndpoint = (path10, initialId, frameId) => {
+      if (typeof path10 !== "string")
+        return void 0;
+      const short = endpointName(path10);
+      const local = namesByFrame.get(frameId ?? "");
+      return (short ? local?.get(short) : void 0) ?? resolveState(path10) ?? resolveState(short) ?? (short === "start" ? initialId : void 0);
+    };
+    const transitionScope = [anchor, ...definitionOf(anchor) ? [definitionOf(anchor)] : []];
+    for (const t of transitionScope.flatMap((holder) => [...ast_utils_exports.streamAllContents(holder)])) {
+      if (t.$type !== "TransitionDecl")
+        continue;
+      const tn = t;
+      link(resolveState(tn.from), resolveState(tn.to), this.transitionLabel(t), t);
     }
-    const designatedInitial = (owner) => {
+    const designatedInitial = (owner, frameId) => {
       const members = owner.members;
       if (!Array.isArray(members))
         return void 0;
-      for (let i = 0; i < members.length - 1; i++) {
-        const entry = members[i];
-        if (entry.$type !== "EntryAction" || entry.name || entry.actionKw || entry.send || entry.accept || entry.assign)
+      for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        if (member.$type === "FirstThenChain") {
+          const chain = member;
+          if (endpointName(chain.head) !== "start")
+            continue;
+          const target2 = resolveEndpoint((chain.steps ?? [])[0], void 0, frameId);
+          if (target2) {
+            registerDrawn(member);
+            return target2;
+          }
+          continue;
+        }
+        if (!isInitialMarker(member))
           continue;
         const then = members[i + 1];
         if (then?.$type !== "ThenActionMember" || typeof then.target !== "string")
           continue;
         const target = resolveState(lastSeg(then.target));
-        if (target)
+        if (target) {
+          registerDrawn(then);
           return target;
+        }
       }
       return void 0;
     };
-    const anchorDefinition = definitionOf(anchor);
-    const firstStateId = designatedInitial(anchor) ?? (anchorDefinition ? designatedInitial(anchorDefinition) : void 0) ?? (topStates.length ? byName.get(nameOf2(topStates[0])) : void 0);
-    if (firstStateId) {
-      edges.push({ id: `e${e++}`, from: "__initial__", to: firstStateId, kind: "transition" });
+    const machineScope = (holder) => {
+      const def = definitionOf(holder);
+      return def ? [holder, def] : [holder];
+    };
+    if (anchorFrameId) {
+      for (const holder of machineScope(anchor))
+        emitMachineNodes(holder, anchorFrameId);
     }
     for (const { state, frameId } of compositeFrames) {
-      const target = designatedInitial(state);
+      for (const holder of machineScope(state))
+        emitMachineNodes(holder, frameId);
+    }
+    const anchorDefinition = definitionOf(anchor);
+    const firstStateId = designatedInitial(anchor, anchorFrameId) ?? (anchorDefinition ? designatedInitial(anchorDefinition, anchorFrameId) : void 0) ?? (topStates.length ? byName.get(nameOf2(topStates[0])) : void 0);
+    if (firstStateId)
+      link("__initial__", firstStateId, void 0, void 0);
+    const compositeInitial = /* @__PURE__ */ new Map();
+    for (const { state, frameId } of compositeFrames) {
+      const target = designatedInitial(state, frameId);
       if (!target)
         continue;
       const id2 = `__initial__${frameId}`;
       nodes.push({ id: id2, name: "", keyword: "initial", isDef: false, shape: "initial", frame: frameId });
-      edges.push({ id: `e${e++}`, from: id2, to: target, kind: "transition" });
+      compositeInitial.set(state, id2);
+      link(id2, target, void 0, void 0);
+    }
+    const sequentialTransitions = (holder, initialId, frameId) => {
+      let cursor;
+      const idOf = (member) => machineNodeIds.get(member) ?? idByState.get(member) ?? (nameOf2(member) ? resolveEndpoint(nameOf2(member), void 0, frameId) : void 0);
+      const endpoint = (path10) => resolveEndpoint(path10, initialId, frameId);
+      for (const member of membersOf(holder)) {
+        switch (member.$type) {
+          case "StateDecl": {
+            cursor = idOf(member) ?? cursor;
+            break;
+          }
+          // `entry;` IS the start pseudostate, so the succession written
+          // after it leaves that pseudostate rather than the last state.
+          case "EntryAction": {
+            if (isInitialMarker(member)) {
+              cursor = initialId;
+              break;
+            }
+            cursor = machineNodeIds.get(member) ?? cursor;
+            break;
+          }
+          // OMG 8.2.3.18 names this edge `st-succession`, so the
+          // keyworded form is a first-class state-transition edge,
+          // not action-language sugar the state view may skip.
+          // Its ends are ConnectorEnds, not bare paths.
+          case "SuccessionStmt": {
+            const succession = member;
+            let previous = endpoint(this.connectorEndPath(succession.first));
+            let firstHop = true;
+            for (const step of succession.steps ?? []) {
+              const to = endpoint(this.connectorEndPath(step));
+              link(previous, to, firstHop ? guardText(succession.guard) : void 0, member);
+              previous = to;
+              firstHop = false;
+            }
+            if (previous)
+              cursor = previous;
+            break;
+          }
+          case "FirstThenChain": {
+            const chain = member;
+            let previous = endpoint(chain.head);
+            let firstHop = true;
+            for (const step of chain.steps ?? []) {
+              const to = endpoint(step);
+              link(previous, to, firstHop ? guardText(chain.guard) : void 0, member);
+              previous = to;
+              firstHop = false;
+            }
+            if (previous)
+              cursor = previous;
+            break;
+          }
+          case "AcceptNode": {
+            const accept = member;
+            if (typeof accept.thenTarget !== "string")
+              break;
+            link(cursor, endpoint(accept.thenTarget), this.acceptShorthandLabel(member), member);
+            break;
+          }
+          case "ThenActionMember": {
+            const then = member;
+            const declared = this.thenActionMemberNode(member);
+            const to = (declared ? idOf(declared) : void 0) ?? endpoint(then.target);
+            link(cursor, to, void 0, member);
+            if (to)
+              cursor = to;
+            break;
+          }
+          // issue #113: a guarded or default target succession fans out
+          // of the SAME source (a decision node, normally), so neither
+          // branch may advance the cursor past its siblings.
+          case "IfActionNode": {
+            const branch = member;
+            if (typeof branch.thenTarget !== "string")
+              break;
+            link(cursor, endpoint(branch.thenTarget), guardText(branch.cond), member);
+            break;
+          }
+          case "ElseSuccessionMember": {
+            link(cursor, endpoint(member.target), "else", member);
+            break;
+          }
+          default: {
+            cursor = machineNodeIds.get(member) ?? cursor;
+            break;
+          }
+        }
+      }
+    };
+    for (const holder of machineScope(anchor)) {
+      sequentialTransitions(holder, hostsStateMachine ? "__initial__" : void 0, anchorFrameId);
+    }
+    for (const { state, frameId } of compositeFrames) {
+      for (const holder of machineScope(state)) {
+        sequentialTransitions(holder, compositeInitial.get(state), frameId);
+      }
     }
     const exhibitorsByState = /* @__PURE__ */ new Map();
     const exhibitScope = this.packageScopeOf(anchor);
@@ -167847,6 +168088,37 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         edges.push({ id: `e${e++}`, from, to, kind: "causation", label: "\xABcausation\xBB", source: sourceOf2(c, uri) });
       }
     }
+    const wired = /* @__PURE__ */ new Set();
+    for (const edge of edges) {
+      wired.add(edge.from);
+      wired.add(edge.to);
+    }
+    const stranded = new Set(machineNodeMembers.filter(({ id: id2 }) => !wired.has(id2)).map(({ id: id2 }) => id2));
+    if (stranded.size) {
+      for (let at = nodes.length - 1; at >= 0; at--) {
+        if (stranded.has(nodes[at].id))
+          nodes.splice(at, 1);
+      }
+    }
+    for (const { member, id: id2 } of machineNodeMembers) {
+      if (!stranded.has(id2))
+        registerDrawn(member);
+    }
+    for (const frame2 of frames) {
+      const full = frame2.compartments;
+      if (!full?.length)
+        continue;
+      const kept = full.map((compartment) => ({
+        title: compartment.title,
+        items: compartment.items.filter((row) => {
+          const key = rowKey(row.source);
+          return !key || !drawnRowKeys.has(key);
+        })
+      })).filter((compartment) => compartment.items.length > 0);
+      if (kept.length === full.length && kept.every((c, at) => c.items.length === full[at].items.length))
+        continue;
+      frame2.compartments = kept.length ? kept : void 0;
+    }
     const model = this.model("stv", anchor, nodes, edges);
     if (frames.length) {
       model.frames = frames;
@@ -170032,9 +170304,25 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return item(m, val ? `= ${val}` : "(value)");
     }));
     add("states", usages(isStateDecl).map((m) => item(m)));
-    const stateActions = members.map((m) => ({ m, kind: { EntryAction: "entry", DoAction: "do", ExitAction: "exit" }[m.$type] })).filter((x) => !!x.kind);
-    add("state actions", stateActions.map(({ m, kind }) => item(m, `${kind} ${nameOf2(m) ?? ""}`.trim())));
+    const isInitialStateMarker = (m, at) => {
+      const entry = m;
+      if (m.$type !== "EntryAction" || entry.name || entry.actionKw || entry.send || entry.accept || entry.assign)
+        return false;
+      const next = members[at + 1];
+      return next?.$type === "ThenActionMember" || next?.$type === "FirstThenChain";
+    };
+    const stateActionTitle = {
+      EntryAction: "entry",
+      DoAction: "during",
+      ExitAction: "exit"
+    };
+    const stateActionText = (m) => nameOf2(m) ?? (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").replace(/^(entry|do|exit)\s+(action\s+)?/, "").trim();
+    for (const title of ["entry", "during", "exit"]) {
+      add(title, members.filter((m, at) => stateActionTitle[m.$type] === title && !isInitialStateMarker(m, at)).map((m) => item(m, stateActionText(m))).filter((row) => !!row.text));
+    }
     add("state transition", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
+    const successionText = (m) => (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").trim();
+    add("successions", members.filter((m) => m.$type === "FirstThenChain" || m.$type === "SuccessionStmt" || m.$type === "ThenActionMember" && typeof m.target === "string" || m.$type === "ElseSuccessionMember" || (m.$type === "AcceptNode" || m.$type === "IfActionNode") && typeof m.thenTarget === "string").map((m) => item(m, successionText(m))).filter((row) => !!row.text));
     add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText3(m) || nameOf2(m) || "assert constraint")));
     add("invariants", members.filter((m) => m.$type === "InvShorthand").map((m) => {
       const inv = m;
@@ -170125,9 +170413,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // REQ-186/REQ-198 — transition label: `trigger [guard] / effect`.
   transitionLabel(t) {
     const tn = t;
-    const trigger = this.acceptTriggerLabel(tn.accept);
-    const guard = tn.guard?.$cstNode?.text?.replace(/\s+/g, " ").trim();
-    const effect = this.effectLabel(tn.effect);
+    return this.transitionLabelOf(tn.accept, tn.guard, tn.effect);
+  }
+  // REQ-198: the label of a source-less transition shorthand (`accept Sig if g
+  // do effect then t;`, OMG SysML 8.2.2.18.3). The accept node itself carries
+  // the trigger, so it reads exactly like an explicit `transition`.
+  acceptShorthandLabel(accept) {
+    const node = accept;
+    return this.transitionLabelOf(accept, node.guard, node.effect);
+  }
+  transitionLabelOf(accept, guardExpr, effectClause) {
+    const trigger = this.acceptTriggerLabel(accept);
+    const guard = guardExpr?.$cstNode?.text?.replace(/\s+/g, " ").trim();
+    const effect = this.effectLabel(effectClause);
     const parts = [];
     if (trigger)
       parts.push(String(trigger));
@@ -196775,7 +197073,7 @@ var AFV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set([
   "succession",
   "successionFlow"
 ]);
-var STV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set(["transition"]);
+var STV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set(["transition", "succession"]);
 function behaviorLayoutEdgeKinds(kind) {
   return kind === "afv" ? AFV_LAYOUT_EDGE_KINDS : kind === "stv" ? STV_LAYOUT_EDGE_KINDS : void 0;
 }
@@ -201984,6 +202282,10 @@ var TOOLBOX = {
     ],
     relations: [
       rel("transition", "transition", "\u2192", "click the source state, then the target state"),
+      // issue #113 - a machine's action and control nodes are sequenced by
+      // a succession, not by a transition: `transition` needs a state at
+      // both ends (OMG SysML 8.2.2.18.3), while `first a then b` does not.
+      rel("succession", "succession", "\u21E2", "click the source node, then the target node"),
       // issue #115 — nothing could mark the initial state, so a state
       // machine could not be STARTED from a blank canvas. The gesture runs
       // from the always-drawn initial pseudostate to the first state.
@@ -202142,7 +202444,11 @@ function normalizedElementKeyword(keyword) {
     "loop action",
     "for-loop action",
     "perform action",
-    "assign"
+    "assign",
+    // issue #113 — a state sub-action drawn as a node is an action node.
+    "entry action",
+    "do action",
+    "exit action"
   ].includes(base)) {
     base = "action";
   } else if (["fork", "join", "merge", "decide", "decision"].includes(base)) {
@@ -202244,7 +202550,12 @@ function relationToolsForNode(keyword, viewKind, shape) {
       if (base === "port") return false;
       return base === "pin" && (tool.kind === "flow" || tool.kind === "successionFlow" || tool.kind === "bind");
     }
-    if (viewKind === "stv") return base === "state" && tool.kind !== "initial";
+    if (viewKind === "stv") {
+      if (base === "action" || base === "control") {
+        return tool.kind === "succession" || tool.kind === TERMINAL_RELATION;
+      }
+      return base === "state" && tool.kind !== "initial";
+    }
     if (viewKind === "sv") return shape === "lifeline" && (base === "part" || base === "lifeline");
     if (viewKind === "cv") {
       if (base === "actor") return tool.kind === "actor";
@@ -204707,7 +205018,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.25.0" : "dev";
+var VERSION2 = true ? "0.26.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;