@diagrammo/dgmo 0.8.21 → 0.8.23

package/dist/internal.cjs

@@ -0,0 +1,380 @@
+"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 __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/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;
+  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;
+}
+
+// src/chart.ts
+function parseDataRowValues(line, options) {
+  const segments = line.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] };
+}
+
+// src/kanban/mutations.ts
+var ARCHIVE_COLUMN_NAME = "archive";
+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;
+}
+
+// src/sequence/renderer.ts
+var d3Selection = __toESM(require("d3-selection"), 1);
+
+// 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";
+}
+
+// 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;
+  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 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;
+}
+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);
+          }
+        }
+        walk(el.elseChildren);
+      }
+    }
+  };
+  walk(elements);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildNoteMessageMap,
+  collectNoteLineNumbers,
+  computeCardArchive,
+  computeCardMove,
+  groupMessagesBySection,
+  isArchiveColumn,
+  parseDataRowValues
+});
+//# sourceMappingURL=internal.cjs.map