@diagrammo/dgmo 0.8.22 → 0.8.25

package/dist/internal.cjs

@@ -0,0 +1,677 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/parsing.ts
+function normalizeNumericToken(token) {
+  if (!token.includes(",") && !token.includes("_")) return null;
+  if (token.includes(",") && token.includes("_")) return null;
+  let sign = "";
+  let unsigned = token;
+  if (unsigned.startsWith("-")) {
+    sign = "-";
+    unsigned = unsigned.substring(1);
+  }
+  if (!unsigned) return null;
+  if (unsigned.includes(",")) {
+    if (/^\d{1,3}(,\d{3})+$/.test(unsigned))
+      return sign + unsigned.replace(/,/g, "");
+    if (/^\d{1,3}(,\d{3})+\.\d+$/.test(unsigned))
+      return sign + unsigned.replace(/,/g, "");
+    return null;
+  }
+  if (/^\d+(_\d+)+$/.test(unsigned)) return sign + unsigned.replace(/_/g, "");
+  if (/^\d+(_\d+)*\.\d+$/.test(unsigned) && unsigned.includes("_"))
+    return sign + unsigned.replace(/_/g, "");
+  return null;
+}
+var init_parsing = __esm({
+  "src/utils/parsing.ts"() {
+    "use strict";
+  }
+});
+
+// src/chart.ts
+function parseDataRowValues(line2, options) {
+  const segments = line2.split(",");
+  const normalized = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i].trim();
+    if (i > 0 && /^\d{3}(\.\d+)?$/.test(seg) && !/^\s/.test(segments[i])) {
+      const prevSeg = normalized[normalized.length - 1].trimEnd();
+      if (/\d{1,3}$/.test(prevSeg)) {
+        const prevMatch = prevSeg.match(/(\d{1,3})$/);
+        if (prevMatch) {
+          normalized[normalized.length - 1] = prevSeg + seg;
+          continue;
+        }
+      }
+    }
+    normalized.push(segments[i]);
+  }
+  const rebuilt = normalized.join(",");
+  const commaParts = rebuilt.split(",");
+  if (commaParts.length > 1) {
+    let numericCount = 0;
+    for (let j = commaParts.length - 1; j >= 0; j--) {
+      const part = normalizeNumericToken(commaParts[j].trim()) ?? commaParts[j].trim();
+      if (part && !isNaN(parseFloat(part)) && isFinite(Number(part))) {
+        numericCount++;
+      } else {
+        break;
+      }
+    }
+    if (numericCount > 0) {
+      const splitAt = commaParts.length - numericCount;
+      const extraValueParts = commaParts.slice(splitAt);
+      const firstPart = commaParts.slice(0, splitAt).join(",").trim();
+      const lastSpaceIdx = firstPart.lastIndexOf(" ");
+      if (lastSpaceIdx >= 0) {
+        const rawFirstVal = firstPart.substring(lastSpaceIdx + 1).trim();
+        const possibleFirstVal = normalizeNumericToken(rawFirstVal) ?? rawFirstVal;
+        if (possibleFirstVal && !isNaN(parseFloat(possibleFirstVal)) && isFinite(Number(possibleFirstVal))) {
+          const label2 = firstPart.substring(0, lastSpaceIdx).trim();
+          if (label2) {
+            const values = [parseFloat(possibleFirstVal)];
+            for (const p of extraValueParts) {
+              const normP = normalizeNumericToken(p.trim()) ?? p.trim();
+              values.push(parseFloat(normP));
+            }
+            return { label: label2, values };
+          }
+        }
+      }
+    }
+  }
+  const tokens = rebuilt.split(/\s+/);
+  if (tokens.length < 2) return null;
+  if (options?.multiValue) {
+    const limit = options.expectedValues ?? Infinity;
+    const values = [];
+    let idx = tokens.length - 1;
+    while (idx >= 1 && values.length < limit) {
+      const tok = tokens[idx];
+      const normTok = normalizeNumericToken(tok) ?? tok;
+      const num2 = parseFloat(normTok);
+      if (isNaN(num2) || !isFinite(Number(normTok))) break;
+      values.unshift(num2);
+      idx--;
+    }
+    if (values.length === 0) return null;
+    const label2 = tokens.slice(0, idx + 1).join(" ");
+    if (!label2) return null;
+    return { label: label2, values };
+  }
+  const lastToken = tokens[tokens.length - 1];
+  const normalizedLast = normalizeNumericToken(lastToken) ?? lastToken;
+  const num = parseFloat(normalizedLast);
+  if (isNaN(num) || !isFinite(Number(normalizedLast))) return null;
+  const label = tokens.slice(0, -1).join(" ");
+  if (!label) return null;
+  return { label, values: [num] };
+}
+var init_chart = __esm({
+  "src/chart.ts"() {
+    "use strict";
+    init_parsing();
+  }
+});
+
+// src/kanban/mutations.ts
+function computeCardMove(content, parsed, cardId, targetColumnId, targetIndex) {
+  let sourceCard = null;
+  let sourceColumn = null;
+  for (const col of parsed.columns) {
+    for (const card of col.cards) {
+      if (card.id === cardId) {
+        sourceCard = card;
+        sourceColumn = col;
+        break;
+      }
+    }
+    if (sourceCard) break;
+  }
+  if (!sourceCard || !sourceColumn) return null;
+  const targetColumn = parsed.columns.find((c) => c.id === targetColumnId);
+  if (!targetColumn) return null;
+  const lines = content.split("\n");
+  const startIdx = sourceCard.lineNumber - 1;
+  const endIdx = sourceCard.endLineNumber - 1;
+  const cardLines = lines.slice(startIdx, endIdx + 1);
+  const withoutCard = [
+    ...lines.slice(0, startIdx),
+    ...lines.slice(endIdx + 1)
+  ];
+  let insertIdx;
+  const removedCount = endIdx - startIdx + 1;
+  const adjustLine = (ln) => {
+    if (ln > endIdx + 1) return ln - removedCount;
+    return ln;
+  };
+  if (targetIndex === 0) {
+    const adjColLine = adjustLine(targetColumn.lineNumber);
+    insertIdx = adjColLine;
+  } else {
+    const targetCards = targetColumn.cards.filter((c) => c.id !== cardId);
+    const clampedIdx = Math.min(targetIndex, targetCards.length);
+    const precedingCard = targetCards[clampedIdx - 1];
+    if (!precedingCard) {
+      const adjColLine = adjustLine(targetColumn.lineNumber);
+      insertIdx = adjColLine;
+    } else {
+      const adjEndLine = adjustLine(precedingCard.endLineNumber);
+      insertIdx = adjEndLine;
+    }
+  }
+  const result = [
+    ...withoutCard.slice(0, insertIdx),
+    ...cardLines,
+    ...withoutCard.slice(insertIdx)
+  ];
+  return result.join("\n");
+}
+function computeCardArchive(content, parsed, cardId) {
+  let sourceCard = null;
+  for (const col of parsed.columns) {
+    for (const card of col.cards) {
+      if (card.id === cardId) {
+        sourceCard = card;
+        break;
+      }
+    }
+    if (sourceCard) break;
+  }
+  if (!sourceCard) return null;
+  const lines = content.split("\n");
+  const startIdx = sourceCard.lineNumber - 1;
+  const endIdx = sourceCard.endLineNumber - 1;
+  const cardLines = lines.slice(startIdx, endIdx + 1);
+  const withoutCard = [
+    ...lines.slice(0, startIdx),
+    ...lines.slice(endIdx + 1)
+  ];
+  const archiveCol = parsed.columns.find(
+    (c) => c.name.toLowerCase() === ARCHIVE_COLUMN_NAME
+  );
+  if (archiveCol) {
+    const removedCount = endIdx - startIdx + 1;
+    let archiveEndLine = archiveCol.lineNumber;
+    if (archiveCol.cards.length > 0) {
+      const lastCard = archiveCol.cards[archiveCol.cards.length - 1];
+      archiveEndLine = lastCard.endLineNumber;
+    }
+    if (archiveEndLine > endIdx + 1) {
+      archiveEndLine -= removedCount;
+    }
+    const insertIdx = archiveEndLine;
+    return [
+      ...withoutCard.slice(0, insertIdx),
+      ...cardLines,
+      ...withoutCard.slice(insertIdx)
+    ].join("\n");
+  } else {
+    const trimmedEnd = withoutCard.length > 0 && withoutCard[withoutCard.length - 1].trim() === "" ? withoutCard : [...withoutCard, ""];
+    return [
+      ...trimmedEnd,
+      "[Archive]",
+      ...cardLines
+    ].join("\n");
+  }
+}
+function isArchiveColumn(name) {
+  return name.toLowerCase() === ARCHIVE_COLUMN_NAME;
+}
+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) {
+  return "kind" in el && el.kind === "block";
+}
+function isSequenceSection(el) {
+  return "kind" in el && el.kind === "section";
+}
+function isSequenceNote(el) {
+  return "kind" in el && el.kind === "note";
+}
+var init_parser = __esm({
+  "src/sequence/parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/sequence/renderer.ts
+function groupMessagesBySection(elements, messages) {
+  const groups = [];
+  let currentGroup = null;
+  const collectIndices = (els) => {
+    const indices = [];
+    for (const el of els) {
+      if (isSequenceBlock(el)) {
+        indices.push(
+          ...collectIndices(el.children),
+          ...collectIndices(el.elseChildren)
+        );
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            indices.push(...collectIndices(branch.children));
+          }
+        }
+      } else if (isSequenceSection(el) || isSequenceNote(el)) {
+        continue;
+      } else {
+        const idx = messages.indexOf(el);
+        if (idx >= 0) indices.push(idx);
+      }
+    }
+    return indices;
+  };
+  for (const el of elements) {
+    if (isSequenceSection(el)) {
+      currentGroup = { section: el, messageIndices: [] };
+      groups.push(currentGroup);
+    } else if (currentGroup) {
+      if (isSequenceBlock(el)) {
+        currentGroup.messageIndices.push(...collectIndices([el]));
+      } else if (!isSequenceNote(el)) {
+        const idx = messages.indexOf(el);
+        if (idx >= 0) currentGroup.messageIndices.push(idx);
+      }
+    }
+  }
+  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;
+  const walk = (els) => {
+    for (const el of els) {
+      if (isSequenceNote(el)) {
+        if (lastMessageLine >= 0) {
+          map.set(el.lineNumber, lastMessageLine);
+        }
+      } else if (isSequenceBlock(el)) {
+        walk(el.children);
+        if (el.elseIfBranches) {
+          for (const branch of el.elseIfBranches) {
+            walk(branch.children);
+          }
+        }
+        walk(el.elseChildren);
+      } else if (!isSequenceSection(el)) {
+        const msg = el;
+        lastMessageLine = msg.lineNumber;
+      }
+    }
+  };
+  walk(elements);
+  return map;
+}
+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);
+          }
+        }
+      }
+      for (const node of allNodes) {
+        if (!placed.has(node)) {
+          ordered.push(node);
+          placed.add(node);
+        }
+      }
+      return ordered;
+    }
+    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,
+  buildRenderSequence,
+  computeActivations,
+  computeCardArchive,
+  computeCardMove,
+  groupMessagesBySection,
+  isArchiveColumn,
+  orderArcNodes,
+  parseDataRowValues
+});
+//# sourceMappingURL=internal.cjs.map