@diagrammo/dgmo 0.8.21 → 0.8.23

package/dist/internal.d.cts

@@ -0,0 +1,179 @@
+type DgmoSeverity = 'error' | 'warning';
+interface DgmoError {
+    line: number;
+    column?: number;
+    message: string;
+    severity: DgmoSeverity;
+    /**
+     * Optional stable diagnostic code (e.g. 'E_ARROW_SUBSTRING_IN_LABEL').
+     * Additive; pre-existing diagnostics omit this field and existing
+     * substring-on-`.message` assertions keep working unchanged.
+     */
+    code?: string;
+}
+
+/**
+ * Parse a data row line: everything before the last numeric token(s) is the label,
+ * numeric tokens at the end are the values. Supports comma-separated multi-values,
+ * space-separated multi-values, and comma-grouped numbers (e.g., "1,087").
+ *
+ * Examples:
+ *   "Jan 120"             → { label: "Jan", values: [120] }
+ *   "North America 250"   → { label: "North America", values: [250] }
+ *   "Q1 10, 20, 30"       → { label: "Q1", values: [10, 20, 30] }
+ *   "Q1 10 20 30"         → { label: "Q1", values: [10, 20, 30] }
+ *   "Revenue 1,200"       → { label: "Revenue", values: [1200] }
+ *   "Revenue 3,984,078.65"→ { label: "Revenue", values: [3984078.65] }
+ *
+ * Returns null if the line has no numeric value at the end.
+ */
+declare function parseDataRowValues(line: string, options?: {
+    multiValue?: boolean;
+    expectedValues?: number;
+}): {
+    label: string;
+    values: number[];
+} | null;
+
+/** A single entry inside a tag group: `Value(color)` */
+interface TagEntry {
+    value: string;
+    color: string;
+    lineNumber: number;
+}
+/** A tag group block: heading + entries */
+interface TagGroup {
+    name: string;
+    alias?: string;
+    entries: TagEntry[];
+    /** Default value for nodes without explicit metadata. First entry unless another is marked `default`. */
+    defaultValue?: string;
+    lineNumber: number;
+}
+
+/** @deprecated Use `TagGroup` from `utils/tag-groups` */
+type KanbanTagGroup = TagGroup;
+interface KanbanCard {
+    id: string;
+    title: string;
+    tags: Record<string, string>;
+    details: string[];
+    lineNumber: number;
+    endLineNumber: number;
+    color?: string;
+}
+interface KanbanColumn {
+    id: string;
+    name: string;
+    wipLimit?: number;
+    color?: string;
+    metadata?: Record<string, string>;
+    cards: KanbanCard[];
+    lineNumber: number;
+}
+interface ParsedKanban {
+    type: 'kanban';
+    title?: string;
+    titleLineNumber?: number;
+    columns: KanbanColumn[];
+    tagGroups: KanbanTagGroup[];
+    options: Record<string, string>;
+    diagnostics: DgmoError[];
+    error: string | null;
+}
+
+/**
+ * Compute new file content after moving a card to a different position.
+ *
+ * @param content     - original file content string
+ * @param parsed      - parsed kanban board
+ * @param cardId      - id of the card to move
+ * @param targetColumnId - id of the destination column
+ * @param targetIndex - position within target column (0 = first card)
+ * @returns new content string, or null if move is invalid
+ */
+declare function computeCardMove(content: string, parsed: ParsedKanban, cardId: string, targetColumnId: string, targetIndex: number): string | null;
+/**
+ * Move a card to the Archive section at the end of the file.
+ * Creates `== Archive ==` if it doesn't exist.
+ *
+ * @returns new content string, or null if the card is not found
+ */
+declare function computeCardArchive(content: string, parsed: ParsedKanban, cardId: string): string | null;
+/** Check if a column name is the archive column (case-insensitive). */
+declare function isArchiveColumn(name: string): boolean;
+
+/**
+ * A message between two participants.
+ */
+interface SequenceMessage {
+    from: string;
+    to: string;
+    label: string;
+    lineNumber: number;
+    async?: boolean;
+    /** Pipe-delimited tag metadata (e.g. `| c: Caching`) */
+    metadata?: Record<string, string>;
+}
+/**
+ * A conditional or loop block in the sequence diagram.
+ */
+interface ElseIfBranch {
+    label: string;
+    children: SequenceElement[];
+    lineNumber: number;
+}
+interface SequenceBlock {
+    kind: 'block';
+    type: 'if' | 'loop' | 'parallel';
+    label: string;
+    children: SequenceElement[];
+    elseChildren: SequenceElement[];
+    elseIfBranches?: ElseIfBranch[];
+    elseLineNumber?: number;
+    lineNumber: number;
+}
+/**
+ * A labeled horizontal divider between message phases.
+ */
+interface SequenceSection {
+    kind: 'section';
+    label: string;
+    lineNumber: number;
+}
+/**
+ * An annotation attached to a message, rendered as a folded-corner box.
+ */
+interface SequenceNote {
+    kind: 'note';
+    text: string;
+    position: 'right' | 'left';
+    participantId: string;
+    lineNumber: number;
+    endLineNumber: number;
+}
+type SequenceElement = SequenceMessage | SequenceBlock | SequenceSection | SequenceNote;
+
+interface SectionMessageGroup {
+    section: SequenceSection;
+    messageIndices: number[];
+}
+/**
+ * Group messages by the top-level section that precedes them.
+ * Messages before the first section are ungrouped (always visible).
+ * Only top-level sections are collapsible — sections inside blocks are excluded.
+ */
+declare function groupMessagesBySection(elements: SequenceElement[], messages: SequenceMessage[]): SectionMessageGroup[];
+/**
+ * Build a mapping from each note's lineNumber to the lineNumber of its
+ * associated message (the last message before the note in document order).
+ * Used by the app to expand notes when cursor is on the associated message.
+ */
+declare function buildNoteMessageMap(elements: SequenceElement[]): Map<number, number>;
+/**
+ * Collect all note line numbers from a sequence diagram's elements.
+ * Used by the app to compute the "expand all" set.
+ */
+declare function collectNoteLineNumbers(elements: SequenceElement[]): number[];
+
+export { buildNoteMessageMap, collectNoteLineNumbers, computeCardArchive, computeCardMove, groupMessagesBySection, isArchiveColumn, parseDataRowValues };

package/dist/internal.d.ts

@@ -0,0 +1,179 @@
+type DgmoSeverity = 'error' | 'warning';
+interface DgmoError {
+    line: number;
+    column?: number;
+    message: string;
+    severity: DgmoSeverity;
+    /**
+     * Optional stable diagnostic code (e.g. 'E_ARROW_SUBSTRING_IN_LABEL').
+     * Additive; pre-existing diagnostics omit this field and existing
+     * substring-on-`.message` assertions keep working unchanged.
+     */
+    code?: string;
+}
+
+/**
+ * Parse a data row line: everything before the last numeric token(s) is the label,
+ * numeric tokens at the end are the values. Supports comma-separated multi-values,
+ * space-separated multi-values, and comma-grouped numbers (e.g., "1,087").
+ *
+ * Examples:
+ *   "Jan 120"             → { label: "Jan", values: [120] }
+ *   "North America 250"   → { label: "North America", values: [250] }
+ *   "Q1 10, 20, 30"       → { label: "Q1", values: [10, 20, 30] }
+ *   "Q1 10 20 30"         → { label: "Q1", values: [10, 20, 30] }
+ *   "Revenue 1,200"       → { label: "Revenue", values: [1200] }
+ *   "Revenue 3,984,078.65"→ { label: "Revenue", values: [3984078.65] }
+ *
+ * Returns null if the line has no numeric value at the end.
+ */
+declare function parseDataRowValues(line: string, options?: {
+    multiValue?: boolean;
+    expectedValues?: number;
+}): {
+    label: string;
+    values: number[];
+} | null;
+
+/** A single entry inside a tag group: `Value(color)` */
+interface TagEntry {
+    value: string;
+    color: string;
+    lineNumber: number;
+}
+/** A tag group block: heading + entries */
+interface TagGroup {
+    name: string;
+    alias?: string;
+    entries: TagEntry[];
+    /** Default value for nodes without explicit metadata. First entry unless another is marked `default`. */
+    defaultValue?: string;
+    lineNumber: number;
+}
+
+/** @deprecated Use `TagGroup` from `utils/tag-groups` */
+type KanbanTagGroup = TagGroup;
+interface KanbanCard {
+    id: string;
+    title: string;
+    tags: Record<string, string>;
+    details: string[];
+    lineNumber: number;
+    endLineNumber: number;
+    color?: string;
+}
+interface KanbanColumn {
+    id: string;
+    name: string;
+    wipLimit?: number;
+    color?: string;
+    metadata?: Record<string, string>;
+    cards: KanbanCard[];
+    lineNumber: number;
+}
+interface ParsedKanban {
+    type: 'kanban';
+    title?: string;
+    titleLineNumber?: number;
+    columns: KanbanColumn[];
+    tagGroups: KanbanTagGroup[];
+    options: Record<string, string>;
+    diagnostics: DgmoError[];
+    error: string | null;
+}
+
+/**
+ * Compute new file content after moving a card to a different position.
+ *
+ * @param content     - original file content string
+ * @param parsed      - parsed kanban board
+ * @param cardId      - id of the card to move
+ * @param targetColumnId - id of the destination column
+ * @param targetIndex - position within target column (0 = first card)
+ * @returns new content string, or null if move is invalid
+ */
+declare function computeCardMove(content: string, parsed: ParsedKanban, cardId: string, targetColumnId: string, targetIndex: number): string | null;
+/**
+ * Move a card to the Archive section at the end of the file.
+ * Creates `== Archive ==` if it doesn't exist.
+ *
+ * @returns new content string, or null if the card is not found
+ */
+declare function computeCardArchive(content: string, parsed: ParsedKanban, cardId: string): string | null;
+/** Check if a column name is the archive column (case-insensitive). */
+declare function isArchiveColumn(name: string): boolean;
+
+/**
+ * A message between two participants.
+ */
+interface SequenceMessage {
+    from: string;
+    to: string;
+    label: string;
+    lineNumber: number;
+    async?: boolean;
+    /** Pipe-delimited tag metadata (e.g. `| c: Caching`) */
+    metadata?: Record<string, string>;
+}
+/**
+ * A conditional or loop block in the sequence diagram.
+ */
+interface ElseIfBranch {
+    label: string;
+    children: SequenceElement[];
+    lineNumber: number;
+}
+interface SequenceBlock {
+    kind: 'block';
+    type: 'if' | 'loop' | 'parallel';
+    label: string;
+    children: SequenceElement[];
+    elseChildren: SequenceElement[];
+    elseIfBranches?: ElseIfBranch[];
+    elseLineNumber?: number;
+    lineNumber: number;
+}
+/**
+ * A labeled horizontal divider between message phases.
+ */
+interface SequenceSection {
+    kind: 'section';
+    label: string;
+    lineNumber: number;
+}
+/**
+ * An annotation attached to a message, rendered as a folded-corner box.
+ */
+interface SequenceNote {
+    kind: 'note';
+    text: string;
+    position: 'right' | 'left';
+    participantId: string;
+    lineNumber: number;
+    endLineNumber: number;
+}
+type SequenceElement = SequenceMessage | SequenceBlock | SequenceSection | SequenceNote;
+
+interface SectionMessageGroup {
+    section: SequenceSection;
+    messageIndices: number[];
+}
+/**
+ * Group messages by the top-level section that precedes them.
+ * Messages before the first section are ungrouped (always visible).
+ * Only top-level sections are collapsible — sections inside blocks are excluded.
+ */
+declare function groupMessagesBySection(elements: SequenceElement[], messages: SequenceMessage[]): SectionMessageGroup[];
+/**
+ * Build a mapping from each note's lineNumber to the lineNumber of its
+ * associated message (the last message before the note in document order).
+ * Used by the app to expand notes when cursor is on the associated message.
+ */
+declare function buildNoteMessageMap(elements: SequenceElement[]): Map<number, number>;
+/**
+ * Collect all note line numbers from a sequence diagram's elements.
+ * Used by the app to compute the "expand all" set.
+ */
+declare function collectNoteLineNumbers(elements: SequenceElement[]): number[];
+
+export { buildNoteMessageMap, collectNoteLineNumbers, computeCardArchive, computeCardMove, groupMessagesBySection, isArchiveColumn, parseDataRowValues };

package/dist/internal.js

@@ -0,0 +1,337 @@
+// 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
+import * as d3Selection from "d3-selection";
+
+// 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;
+}
+export {
+  buildNoteMessageMap,
+  collectNoteLineNumbers,
+  computeCardArchive,
+  computeCardMove,
+  groupMessagesBySection,
+  isArchiveColumn,
+  parseDataRowValues
+};
+//# sourceMappingURL=internal.js.map