@zenuml/core 4.0.0 → 4.2.0

package/dist/cli/zenuml.mjs

@@ -2738,7 +2738,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	returnAsyncMessage() {
-	    let localctx = new ReturnAsyncMessageContext$2(this, this._ctx, this.state);
+	    let localctx = new ReturnAsyncMessageContext$3(this, this._ctx, this.state);
 	    this.enterRule(localctx, 30, sequenceParser.RULE_returnAsyncMessage);
 	    var _la = 0; // Token type
 	    try {
@@ -5800,7 +5800,7 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 	};
 
 	returnAsyncMessage() {
-	    return this.getTypedRuleContext(ReturnAsyncMessageContext$2,0);
+	    return this.getTypedRuleContext(ReturnAsyncMessageContext$3,0);
 	};
 
 	enterRule(listener) {
@@ -5820,7 +5820,7 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 
 
 
-let ReturnAsyncMessageContext$2 = class ReturnAsyncMessageContext extends antlr4.ParserRuleContext {
+let ReturnAsyncMessageContext$3 = class ReturnAsyncMessageContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -8714,7 +8714,7 @@ sequenceParser.WidthContext = WidthContext;
 sequenceParser.EmojiContext = EmojiContext; 
 sequenceParser.BlockContext = BlockContext; 
 sequenceParser.RetContext = RetContext$3; 
-sequenceParser.ReturnAsyncMessageContext = ReturnAsyncMessageContext$2; 
+sequenceParser.ReturnAsyncMessageContext = ReturnAsyncMessageContext$3; 
 sequenceParser.DividerContext = DividerContext$1; 
 sequenceParser.DividerNoteContext = DividerNoteContext; 
 sequenceParser.StatContext = StatContext$3; 
@@ -8779,6 +8779,10 @@ const blankParticipant = {
 };
 let Participant$1 = class Participant {
   name;
+  // Fields the renderer-facing ParticipantView (ir/contract.ts) exposes are
+  // public; they were already fully exposed via ToValue(), so the previous
+  // `private` was inconsistent encapsulation. `width` stays private — it is not
+  // part of ParticipantView.
   stereotype;
   width;
   groupId;
@@ -9204,7 +9208,7 @@ const seqParser$7 = sequenceParser;
 const CreationContext$6 = seqParser$7.CreationContext;
 const MessageContext$6 = seqParser$7.MessageContext;
 const AsyncMessageContext$2 = seqParser$7.AsyncMessageContext;
-const ReturnAsyncMessageContext$1 = seqParser$7.ReturnAsyncMessageContext;
+const ReturnAsyncMessageContext$2 = seqParser$7.ReturnAsyncMessageContext;
 const RetMessageContext = seqParser$7.RetContext;
 
 CreationContext$6.prototype.Assignee = function () {
@@ -9264,12 +9268,12 @@ AsyncMessageContext$2.prototype.Owner = function () {
   return this.To() || getOwnerFromAncestor(this.parentCtx);
 };
 
-ReturnAsyncMessageContext$1.prototype.To = function () {
+ReturnAsyncMessageContext$2.prototype.To = function () {
   const toCtx = this.to();
   return toCtx?.name?.()?.getFormattedText() || toCtx?.getFormattedText();
 };
 
-ReturnAsyncMessageContext$1.prototype.Owner = function () {
+ReturnAsyncMessageContext$2.prototype.Owner = function () {
   return this.To() || getOwnerFromAncestor(this.parentCtx);
 };
 
@@ -9386,13 +9390,13 @@ RefContext.prototype.Participants = function() {
   return this.name().slice(1) ?? [];
 };
 
-const ParserRuleContext = antlr4.ParserRuleContext;
+const ParserRuleContext$1 = antlr4.ParserRuleContext;
 const StatContext$2 = sequenceParser.StatContext;
 const ProgContext = sequenceParser.ProgContext;
 const MessageContext$4 = sequenceParser.MessageContext;
 const CreationContext$4 = sequenceParser.CreationContext;
 
-ParserRuleContext.prototype.Origin = function () {
+ParserRuleContext$1.prototype.Origin = function () {
   let ctx = this.parentCtx;
   while (ctx && !(ctx instanceof StatContext$2 || ctx instanceof ProgContext)) {
     ctx = this.parentCtx;
@@ -9438,8 +9442,8 @@ function formatParameter(param) {
   if (param.namedParameter?.()) {
     const namedParam = param.namedParameter();
     if (namedParam) {
-      const expr = namedParam.expr();
-      const value = expr ? expr.getFormattedText() : "";
+      const expr2 = namedParam.expr();
+      const value = expr2 ? expr2.getFormattedText() : "";
       return `${namedParam.ID().getText()}=${value}`;
     }
   }
@@ -9449,8 +9453,9 @@ function formatParameter(param) {
       return `${decl.type().getText()} ${decl.ID().getText()}`;
     }
   }
-  if (param.expr?.()) {
-    return param.expr().getFormattedText();
+  const expr = param.expr?.();
+  if (expr) {
+    return expr.getFormattedText();
   }
   return param.getFormattedText();
 }
@@ -9462,6 +9467,7 @@ const ParametersContext = sequenceParser.ParametersContext;
 const AsyncMessageContext$1 = sequenceParser.AsyncMessageContext;
 const CreationContext$3 = sequenceParser.CreationContext;
 const RetContext$1 = sequenceParser.RetContext;
+const ReturnAsyncMessageContext$1 = sequenceParser.ReturnAsyncMessageContext;
 MessageContext$3.prototype.SignatureText = function() {
   return this.messageBody()?.func()?.signature()?.map((s) => s?.getFormattedText()).join(".") ?? "";
 };
@@ -9482,7 +9488,7 @@ CreationContext$3.prototype.isParamValid = function() {
 RetContext$1.prototype.SignatureText = function() {
   return this.asyncMessage()?.content()?.getFormattedText() ?? this.returnAsyncMessage()?.content()?.getFormattedText() ?? this.expr()?.getFormattedText() ?? "";
 };
-sequenceParser.ReturnAsyncMessageContext.prototype.SignatureText = function() {
+ReturnAsyncMessageContext$1.prototype.SignatureText = function() {
   return this.content()?.getFormattedText() ?? "";
 };
 ParametersContext.prototype.getFormattedText = function() {
@@ -9557,46 +9563,47 @@ LoopContext.prototype.Statements = function() {
 };
 
 const seqParser$1 = sequenceParser;
-const CreationContext = seqParser$1.CreationContext;
 const StatContext$1 = seqParser$1.StatContext;
+const CreationContext = seqParser$1.CreationContext;
 const MessageContext = seqParser$1.MessageContext;
 const AsyncMessageContext = seqParser$1.AsyncMessageContext;
 const ReturnAsyncMessageContext = seqParser$1.ReturnAsyncMessageContext;
 const RetContext = seqParser$1.RetContext;
 CreationContext.prototype.From = function() {
   if (this.parentCtx instanceof StatContext$1) {
-    return this.ClosestAncestorStat().Origin();
+    return this.ClosestAncestorStat()?.Origin();
   }
   return void 0;
 };
 MessageContext.prototype.ProvidedFrom = function() {
-  const fromCtx = this.messageBody()?.fromTo()?.from();
-  return fromCtx?.name?.()?.getFormattedText() || fromCtx?.getFormattedText();
+  const fromCtx = this.messageBody()?.fromTo?.()?.from?.();
+  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 };
 MessageContext.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat().Origin();
+  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 };
 AsyncMessageContext.prototype.ProvidedFrom = function() {
   const fromCtx = this.from();
-  return fromCtx?.name?.()?.getFormattedText() || fromCtx?.getFormattedText();
+  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 };
 AsyncMessageContext.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat().Origin();
+  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 };
 ReturnAsyncMessageContext.prototype.ProvidedFrom = function() {
   const fromCtx = this.from();
-  return fromCtx?.name?.()?.getFormattedText() || fromCtx?.getFormattedText();
+  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 };
 ReturnAsyncMessageContext.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat().Origin();
+  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 };
 RetContext.prototype.From = function() {
-  return this.asyncMessage()?.From() || this.returnAsyncMessage()?.From() || this.ClosestAncestorStat().Origin();
+  return this.asyncMessage()?.From?.() || this.returnAsyncMessage()?.From?.() || this.ClosestAncestorStat()?.Origin();
 };
 
 const seqParser = sequenceParser;
 const StatContext = seqParser.StatContext;
-antlr4.ParserRuleContext.prototype.ClosestAncestorStat = function() {
+const ParserRuleContext = antlr4.ParserRuleContext;
+ParserRuleContext.prototype.ClosestAncestorStat = function() {
   if (this instanceof StatContext) {
     return this;
   }
@@ -9609,7 +9616,7 @@ antlr4.ParserRuleContext.prototype.ClosestAncestorStat = function() {
   }
   return void 0;
 };
-antlr4.ParserRuleContext.prototype.ClosestAncestorBlock = function() {
+ParserRuleContext.prototype.ClosestAncestorBlock = function() {
   const parentCtx = this.ClosestAncestorStat()?.parentCtx;
   if (parentCtx instanceof seqParser.BlockContext) {
     return parentCtx;
@@ -9648,6 +9655,21 @@ class SeqErrorListener extends antlr4.error.ErrorListener {
   }
 }
 
+// Reentrant error listener: collects syntax errors into its OWN instance array
+// instead of the shared module-level `errors`/`errorDetails`. This is what lets
+// validate()/parse() below run repeatedly or concurrently (e.g. server-side)
+// without the clear-before/clear-after dance the legacy globals require.
+class CollectingErrorListener extends antlr4.error.ErrorListener {
+  constructor() {
+    super();
+    /** @type {{ line: number, column: number, msg: string }[]} */
+    this.errorDetails = [];
+  }
+  syntaxError(recognizer, offendingSymbol, line, column, msg) {
+    this.errorDetails.push({ line, column, msg });
+  }
+}
+
 function createParser(code, { silent = false } = {}) {
   const chars = new antlr4.InputStream(code);
   const lexer = new sequenceLexer(chars);
@@ -9722,6 +9744,43 @@ antlr4.ParserRuleContext.prototype.getComment = function () {
   );
 };
 
+/**
+ * Parse ZenUML DSL with a per-call (reentrant) error listener and return both
+ * the error-recovered parse tree and a structured error list. Safe to call
+ * repeatedly/concurrently — it does not touch the module-level Errors/ErrorDetails.
+ *
+ * @param {string} code ZenUML DSL source
+ * @returns {{ rootContext: object, pass: boolean, errorDetails: { line: number, column: number, msg: string }[] }}
+ */
+function parse(code) {
+  const listener = new CollectingErrorListener();
+  const chars = new antlr4.InputStream(code);
+  const lexer = new sequenceLexer(chars);
+  lexer.removeErrorListeners();
+  lexer.addErrorListener(listener);
+  const tokens = new antlr4.CommonTokenStream(lexer);
+  const parser = new sequenceParser(tokens);
+  parser.removeErrorListeners();
+  parser.addErrorListener(listener);
+  const tree = parser.prog();
+  return {
+    rootContext: tree,
+    pass: listener.errorDetails.length === 0,
+    errorDetails: listener.errorDetails,
+  };
+}
+
+/**
+ * Validate ZenUML DSL syntax without exposing the parse tree. Reentrant.
+ *
+ * @param {string} code ZenUML DSL source
+ * @returns {{ pass: boolean, errorDetails: { line: number, column: number, msg: string }[] }}
+ */
+function validate(code) {
+  const { pass, errorDetails } = parse(code);
+  return { pass, errorDetails };
+}
+
 sequenceParser.ProgContext;
 const RootContext = rootContext;
 sequenceParser.GroupContext;
@@ -9740,6 +9799,8 @@ const Parser = {
     const toCollector = ToCollector;
     return toCollector.getParticipants(ctx);
   },
+  parse,
+  validate,
   Errors: errors,
   ErrorDetails: errorDetails,
   /**
@@ -9866,33 +9927,31 @@ function OrderedParticipants(rootContext) {
   const cached = orderedParticipantsCache.get(rootContext);
   if (cached) return cached;
   const participants = ToCollector.getParticipants(rootContext);
-  const participantEntries = Array.from(participants.participants.entries());
+  const participantEntries = participants.Array().map((p) => p.ToValue());
   const allMessages = AllMessages(rootContext);
   const emptyContext = allMessages.length === 0 && participantEntries.length === 0;
   const someMessagesMissFrom = allMessages.some((m) => !m.from);
   const needDefaultStarter = emptyContext || someMessagesMissFrom;
   if (needDefaultStarter) {
-    participantEntries.unshift([
-      _STARTER_,
-      { ...blankParticipant, name: _STARTER_, isStarter: true }
-    ]);
-  }
-  const result = participantEntries.map(
-    (entry, index, entries) => {
-      const participant = entry[1];
-      const previousName = index > 0 ? entries[index - 1][1].name : "";
-      return new Participant(
-        participant.name,
-        previousName,
-        participant.label,
-        participant.type,
-        participant.stereotype,
-        participant.color,
-        participant.groupId,
-        participant.emoji
-      );
-    }
-  );
+    participantEntries.unshift({
+      ...blankParticipant,
+      name: _STARTER_,
+      isStarter: true
+    });
+  }
+  const result = participantEntries.map((participant, index, entries) => {
+    const previousName = index > 0 ? entries[index - 1].name : "";
+    return new Participant(
+      participant.name,
+      previousName,
+      participant.label,
+      participant.type,
+      participant.stereotype,
+      participant.color,
+      participant.groupId,
+      participant.emoji
+    );
+  });
   orderedParticipantsCache.set(rootContext, result);
   return result;
 }
@@ -9991,7 +10050,7 @@ function longestPathTable(graph, gaps) {
   }
   return [tracker.delta, table];
 }
-function freezeCriticalGaps(table, graph, gaps) {
+function freezeCriticalGaps(table, gaps) {
   let j = table.length - 1;
   while (j > 0) {
     const argument = table[j].argument;
@@ -10028,7 +10087,7 @@ function find_optimal(matrix) {
       return positionsFromTable(table);
     }
     if (table[n - 1].maximum.velocity > 0) {
-      freezeCriticalGaps(table, graph, gaps);
+      freezeCriticalGaps(table, gaps);
     } else {
       advanceGaps(gaps, delta);
     }
@@ -11466,7 +11525,7 @@ function snapX(x) {
   return x;
 }
 const COMMENT_FONT_ASCENT = 15;
-function buildFragmentGeometry(info, coord, coordinates, verticalCoordinates, allParticipants, measureText, commentHeight = 0, commentText, commentStyle, commentYBase) {
+function buildFragmentGeometry(info, coord, coordinates, verticalCoordinates, allParticipants, _measureText, commentHeight = 0, commentText, commentStyle, commentYBase) {
   const statNode = info.statNode;
   if (!statNode) return null;
   const fragmentCtx = findFragmentContext(statNode);