@diagrammo/dgmo 0.8.23 → 0.8.26

package/dist/internal.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,19 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/internal.ts
-var internal_exports = {};
-__export(internal_exports, {
-  buildNoteMessageMap: () => buildNoteMessageMap,
-  collectNoteLineNumbers: () => collectNoteLineNumbers,
-  computeCardArchive: () => computeCardArchive,
-  computeCardMove: () => computeCardMove,
-  groupMessagesBySection: () => groupMessagesBySection,
-  isArchiveColumn: () => isArchiveColumn,
-  parseDataRowValues: () => parseDataRowValues
-});
-module.exports = __toCommonJS(internal_exports);
-
 // src/utils/parsing.ts
 function normalizeNumericToken(token) {
   if (!token.includes(",") && !token.includes("_")) return null;
@@ -63,10 +53,15 @@ function normalizeNumericToken(token) {
     return sign + unsigned.replace(/_/g, "");
   return null;
 }
+var init_parsing = __esm({
+  "src/utils/parsing.ts"() {
+    "use strict";
+  }
+});
 
 // src/chart.ts
-function parseDataRowValues(line, options) {
-  const segments = line.split(",");
+function parseDataRowValues(line2, options) {
+  const segments = line2.split(",");
   const normalized = [];
   for (let i = 0; i < segments.length; i++) {
     const seg = segments[i].trim();
@@ -143,9 +138,14 @@ function parseDataRowValues(line, options) {
   if (!label) return null;
   return { label, values: [num] };
 }
+var init_chart = __esm({
+  "src/chart.ts"() {
+    "use strict";
+    init_parsing();
+  }
+});
 
 // src/kanban/mutations.ts
-var ARCHIVE_COLUMN_NAME = "archive";
 function computeCardMove(content, parsed, cardId, targetColumnId, targetIndex) {
   let sourceCard = null;
   let sourceColumn = null;
@@ -249,9 +249,13 @@ function computeCardArchive(content, parsed, cardId) {
 function isArchiveColumn(name) {
   return name.toLowerCase() === ARCHIVE_COLUMN_NAME;
 }
-
-// src/sequence/renderer.ts
-var d3Selection = __toESM(require("d3-selection"), 1);
+var ARCHIVE_COLUMN_NAME;
+var init_mutations = __esm({
+  "src/kanban/mutations.ts"() {
+    "use strict";
+    ARCHIVE_COLUMN_NAME = "archive";
+  }
+});
 
 // src/sequence/parser.ts
 function isSequenceBlock(el) {
@@ -263,24 +267,13 @@ function isSequenceSection(el) {
 function isSequenceNote(el) {
   return "kind" in el && el.kind === "note";
 }
+var init_parser = __esm({
+  "src/sequence/parser.ts"() {
+    "use strict";
+  }
+});
 
 // src/sequence/renderer.ts
-var PARTICIPANT_GAP = 160;
-var PARTICIPANT_BOX_WIDTH = 120;
-var NOTE_MAX_W = 200;
-var NOTE_FOLD = 10;
-var NOTE_PAD_H = 8;
-var NOTE_GAP = 15;
-var NOTE_CHAR_W = 6;
-var NOTE_CHARS_PER_LINE = Math.floor(
-  (NOTE_MAX_W - NOTE_PAD_H * 2 - NOTE_FOLD) / NOTE_CHAR_W
-);
-var ACTIVATION_WIDTH = 10;
-var NOTE_LANE_MAX = PARTICIPANT_GAP - ACTIVATION_WIDTH - NOTE_GAP;
-var LABEL_CHAR_WIDTH = 7.5;
-var LABEL_MAX_CHARS = Math.floor(
-  (PARTICIPANT_BOX_WIDTH - 10) / LABEL_CHAR_WIDTH
-);
 function groupMessagesBySection(elements, messages) {
   const groups = [];
   let currentGroup = null;
@@ -321,6 +314,180 @@ function groupMessagesBySection(elements, messages) {
   }
   return groups;
 }
+function buildRenderSequence(messages) {
+  const steps = [];
+  const stack = [];
+  for (let mi = 0; mi < messages.length; mi++) {
+    const msg = messages[mi];
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      if (top.to === msg.from) break;
+      stack.pop();
+      steps.push({
+        type: "return",
+        from: top.to,
+        to: top.from,
+        label: "",
+        messageIndex: top.messageIndex
+      });
+    }
+    steps.push({
+      type: "call",
+      from: msg.from,
+      to: msg.to,
+      label: msg.label,
+      messageIndex: mi,
+      ...msg.async ? { async: true } : {}
+    });
+    if (msg.async) {
+      continue;
+    }
+    if (msg.from === msg.to) {
+      steps.push({
+        type: "return",
+        from: msg.to,
+        to: msg.from,
+        label: "",
+        messageIndex: mi
+      });
+    } else {
+      stack.push({
+        from: msg.from,
+        to: msg.to,
+        messageIndex: mi
+      });
+    }
+  }
+  while (stack.length > 0) {
+    const top = stack.pop();
+    steps.push({
+      type: "return",
+      from: top.to,
+      to: top.from,
+      label: "",
+      messageIndex: top.messageIndex
+    });
+  }
+  return steps;
+}
+function computeActivations(steps) {
+  const activations = [];
+  const stacks = /* @__PURE__ */ new Map();
+  const getStack = (id) => {
+    if (!stacks.has(id)) stacks.set(id, []);
+    return stacks.get(id);
+  };
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (step.type === "call") {
+      const s = getStack(step.to);
+      s.push(i);
+    } else {
+      const s = getStack(step.from);
+      if (s.length > 0) {
+        const startIdx = s.pop();
+        activations.push({
+          participantId: step.from,
+          startStep: startIdx,
+          endStep: i,
+          depth: s.length
+        });
+      }
+    }
+  }
+  return activations;
+}
+function applyPositionOverrides(participants) {
+  if (!participants.some((p) => p.position !== void 0)) return participants;
+  const total = participants.length;
+  const positioned = [];
+  const unpositioned = [];
+  for (const p of participants) {
+    if (p.position !== void 0) {
+      let idx = p.position < 0 ? total + p.position : p.position;
+      idx = Math.max(0, Math.min(total - 1, idx));
+      positioned.push({ participant: p, index: idx });
+    } else {
+      unpositioned.push(p);
+    }
+  }
+  positioned.sort((a, b) => a.index - b.index);
+  const result = new Array(total).fill(null);
+  const usedIndices = /* @__PURE__ */ new Set();
+  for (const { participant, index } of positioned) {
+    let idx = index;
+    if (usedIndices.has(idx)) {
+      for (let offset = 1; offset < total; offset++) {
+        if (idx + offset < total && !usedIndices.has(idx + offset)) {
+          idx = idx + offset;
+          break;
+        }
+        if (idx - offset >= 0 && !usedIndices.has(idx - offset)) {
+          idx = idx - offset;
+          break;
+        }
+      }
+    }
+    result[idx] = participant;
+    usedIndices.add(idx);
+  }
+  let uIdx = 0;
+  for (let i = 0; i < total; i++) {
+    if (result[i] === null) {
+      result[i] = unpositioned[uIdx++];
+    }
+  }
+  return result;
+}
+function applyGroupOrdering(participants, groups, messages = []) {
+  if (groups.length === 0) return participants;
+  const idToGroup = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const id of group.participantIds) {
+      idToGroup.set(id, group);
+    }
+  }
+  const appearanceOrder = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    for (const id of [msg.from, msg.to]) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        appearanceOrder.push(id);
+      }
+    }
+  }
+  for (const p of participants) {
+    if (!seen.has(p.id)) {
+      seen.add(p.id);
+      appearanceOrder.push(p.id);
+    }
+  }
+  const result = [];
+  const placed = /* @__PURE__ */ new Set();
+  const placedGroups = /* @__PURE__ */ new Set();
+  for (const id of appearanceOrder) {
+    if (placed.has(id)) continue;
+    const group = idToGroup.get(id);
+    if (group && !placedGroups.has(group)) {
+      placedGroups.add(group);
+      for (const gid of group.participantIds) {
+        const p = participants.find((pp) => pp.id === gid);
+        if (p && !placed.has(gid)) {
+          result.push(p);
+          placed.add(gid);
+        }
+      }
+    } else if (!group) {
+      const p = participants.find((pp) => pp.id === id);
+      if (p) {
+        result.push(p);
+        placed.add(id);
+      }
+    }
+  }
+  return result;
+}
 function buildNoteMessageMap(elements) {
   const map = /* @__PURE__ */ new Map();
   let lastMessageLine = -1;
@@ -347,34 +514,164 @@ function buildNoteMessageMap(elements) {
   walk(elements);
   return map;
 }
-function collectNoteLineNumbers(elements) {
-  const result = [];
-  const walk = (els) => {
-    for (const el of els) {
-      if (isSequenceNote(el)) {
-        result.push(el.lineNumber);
-      } else if (isSequenceBlock(el)) {
-        walk(el.children);
-        if (el.elseIfBranches) {
-          for (const branch of el.elseIfBranches) {
-            walk(branch.children);
+var d3Selection, PARTICIPANT_GAP, PARTICIPANT_BOX_WIDTH, NOTE_MAX_W, NOTE_FOLD, NOTE_PAD_H, NOTE_GAP, NOTE_CHAR_W, NOTE_CHARS_PER_LINE, ACTIVATION_WIDTH, NOTE_LANE_MAX, LABEL_CHAR_WIDTH, LABEL_MAX_CHARS;
+var init_renderer = __esm({
+  "src/sequence/renderer.ts"() {
+    "use strict";
+    d3Selection = __toESM(require("d3-selection"), 1);
+    init_parser();
+    PARTICIPANT_GAP = 160;
+    PARTICIPANT_BOX_WIDTH = 120;
+    NOTE_MAX_W = 200;
+    NOTE_FOLD = 10;
+    NOTE_PAD_H = 8;
+    NOTE_GAP = 15;
+    NOTE_CHAR_W = 6;
+    NOTE_CHARS_PER_LINE = Math.floor(
+      (NOTE_MAX_W - NOTE_PAD_H * 2 - NOTE_FOLD) / NOTE_CHAR_W
+    );
+    ACTIVATION_WIDTH = 10;
+    NOTE_LANE_MAX = PARTICIPANT_GAP - ACTIVATION_WIDTH - NOTE_GAP;
+    LABEL_CHAR_WIDTH = 7.5;
+    LABEL_MAX_CHARS = Math.floor(
+      (PARTICIPANT_BOX_WIDTH - 10) / LABEL_CHAR_WIDTH
+    );
+  }
+});
+
+// src/d3.ts
+function orderArcNodes(links, order, groups) {
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (const link of links) {
+    nodeSet.add(link.source);
+    nodeSet.add(link.target);
+  }
+  const allNodes = Array.from(nodeSet);
+  if (order === "name") {
+    return allNodes.slice().sort((a, b) => a.localeCompare(b));
+  }
+  if (order === "degree") {
+    const degree = /* @__PURE__ */ new Map();
+    for (const node of allNodes) degree.set(node, 0);
+    for (const link of links) {
+      degree.set(link.source, degree.get(link.source) + link.value);
+      degree.set(link.target, degree.get(link.target) + link.value);
+    }
+    return allNodes.slice().sort((a, b) => {
+      const diff = degree.get(b) - degree.get(a);
+      return diff !== 0 ? diff : a.localeCompare(b);
+    });
+  }
+  if (order === "group") {
+    if (groups.length > 0) {
+      const ordered = [];
+      const placed = /* @__PURE__ */ new Set();
+      for (const group of groups) {
+        for (const node of group.nodes) {
+          if (!placed.has(node)) {
+            ordered.push(node);
+            placed.add(node);
           }
         }
-        walk(el.elseChildren);
       }
+      for (const node of allNodes) {
+        if (!placed.has(node)) {
+          ordered.push(node);
+          placed.add(node);
+        }
+      }
+      return ordered;
     }
-  };
-  walk(elements);
-  return result;
+    const adj = /* @__PURE__ */ new Map();
+    for (const node of allNodes) adj.set(node, /* @__PURE__ */ new Set());
+    for (const link of links) {
+      adj.get(link.source).add(link.target);
+      adj.get(link.target).add(link.source);
+    }
+    const degree = /* @__PURE__ */ new Map();
+    for (const node of allNodes) degree.set(node, 0);
+    for (const link of links) {
+      degree.set(link.source, degree.get(link.source) + link.value);
+      degree.set(link.target, degree.get(link.target) + link.value);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const components = [];
+    const remaining = new Set(allNodes);
+    while (remaining.size > 0) {
+      let root = "";
+      let maxDeg = -1;
+      for (const node of remaining) {
+        if (degree.get(node) > maxDeg) {
+          maxDeg = degree.get(node);
+          root = node;
+        }
+      }
+      const component = [];
+      const queue = [root];
+      visited.add(root);
+      remaining.delete(root);
+      while (queue.length > 0) {
+        const curr = queue.shift();
+        component.push(curr);
+        for (const neighbor of adj.get(curr)) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            remaining.delete(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      components.push(component);
+    }
+    components.sort((a, b) => b.length - a.length);
+    return components.flat();
+  }
+  return allNodes;
 }
+var d3Scale, d3Selection2, d3Shape, d3Array, import_d3_cloud;
+var init_d3 = __esm({
+  "src/d3.ts"() {
+    "use strict";
+    d3Scale = __toESM(require("d3-scale"), 1);
+    d3Selection2 = __toESM(require("d3-selection"), 1);
+    d3Shape = __toESM(require("d3-shape"), 1);
+    d3Array = __toESM(require("d3-array"), 1);
+    import_d3_cloud = __toESM(require("d3-cloud"), 1);
+  }
+});
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  applyGroupOrdering: () => applyGroupOrdering,
+  applyPositionOverrides: () => applyPositionOverrides,
+  buildNoteMessageMap: () => buildNoteMessageMap,
+  buildRenderSequence: () => buildRenderSequence,
+  computeActivations: () => computeActivations,
+  computeCardArchive: () => computeCardArchive,
+  computeCardMove: () => computeCardMove,
+  groupMessagesBySection: () => groupMessagesBySection,
+  isArchiveColumn: () => isArchiveColumn,
+  orderArcNodes: () => orderArcNodes,
+  parseDataRowValues: () => parseDataRowValues
+});
+module.exports = __toCommonJS(internal_exports);
+init_chart();
+init_mutations();
+init_renderer();
+init_d3();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  applyGroupOrdering,
+  applyPositionOverrides,
   buildNoteMessageMap,
-  collectNoteLineNumbers,
+  buildRenderSequence,
+  computeActivations,
   computeCardArchive,
   computeCardMove,
   groupMessagesBySection,
   isArchiveColumn,
+  orderArcNodes,
   parseDataRowValues
 });
 //# sourceMappingURL=internal.cjs.map