@diagrammo/dgmo 0.2.20 → 0.2.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "type": "module",

package/src/d3.ts

@@ -5281,7 +5281,7 @@ export async function renderD3ForExport(
       palette ?? (isDark ? getPalette('nord').dark : getPalette('nord').light);
 
     const orgParsed = parseOrg(content, effectivePalette);
-    if (orgParsed.error || orgParsed.roots.length === 0) return '';
+    if (orgParsed.error) return '';
 
     // Apply interactive collapse state when provided
     const collapsedNodes = orgExportState?.collapsedNodes;
@@ -5349,6 +5349,49 @@ export async function renderD3ForExport(
     }
   }
 
+  if (detectedType === 'kanban') {
+    const { parseKanban } = await import('./kanban/parser');
+    const { renderKanban } = await import('./kanban/renderer');
+
+    const isDark = theme === 'dark';
+    const { getPalette } = await import('./palettes');
+    const effectivePalette =
+      palette ?? (isDark ? getPalette('nord').dark : getPalette('nord').light);
+
+    const kanbanParsed = parseKanban(content, effectivePalette);
+    if (kanbanParsed.error || kanbanParsed.columns.length === 0) return '';
+
+    const container = document.createElement('div');
+    container.style.position = 'absolute';
+    container.style.left = '-9999px';
+    document.body.appendChild(container);
+
+    try {
+      renderKanban(container, kanbanParsed, effectivePalette, isDark);
+
+      const svgEl = container.querySelector('svg');
+      if (!svgEl) return '';
+
+      if (theme === 'transparent') {
+        svgEl.style.background = 'none';
+      } else if (!svgEl.style.background) {
+        svgEl.style.background = effectivePalette.bg;
+      }
+
+      svgEl.setAttribute('xmlns', 'http://www.w3.org/2000/svg');
+      svgEl.style.fontFamily = FONT_FAMILY;
+
+      const svgHtml = svgEl.outerHTML;
+      if (options?.branding !== false) {
+        const brandColor = theme === 'transparent' ? '#888' : effectivePalette.textMuted;
+        return injectBranding(svgHtml, brandColor);
+      }
+      return svgHtml;
+    } finally {
+      document.body.removeChild(container);
+    }
+  }
+
   if (detectedType === 'class') {
     const { parseClassDiagram } = await import('./class/parser');
     const { layoutClassDiagram } = await import('./class/layout');

package/src/dgmo-router.ts

@@ -9,7 +9,8 @@ import { looksLikeERDiagram, parseERDiagram } from './er/parser';
 import { parseChart } from './chart';
 import { parseEChart } from './echarts';
 import { parseD3 } from './d3';
-import { parseOrg } from './org/parser';
+import { parseOrg, looksLikeOrg } from './org/parser';
+import { parseKanban } from './kanban/parser';
 import type { DgmoError } from './diagnostics';
 
 /**
@@ -56,6 +57,7 @@ export const DGMO_CHART_TYPE_MAP: Record<string, DgmoFramework> = {
   class: 'd3',
   er: 'd3',
   org: 'd3',
+  kanban: 'd3',
 };
 
 /**
@@ -87,6 +89,7 @@ export function parseDgmoChartType(content: string): string | null {
   if (looksLikeFlowchart(content)) return 'flowchart';
   if (looksLikeClassDiagram(content)) return 'class';
   if (looksLikeERDiagram(content)) return 'er';
+  if (looksLikeOrg(content)) return 'org';
 
   return null;
 }
@@ -135,6 +138,10 @@ export function parseDgmo(content: string): { diagnostics: DgmoError[] } {
     const parsed = parseOrg(content);
     return { diagnostics: parsed.diagnostics };
   }
+  if (chartType === 'kanban') {
+    const parsed = parseKanban(content);
+    return { diagnostics: parsed.diagnostics };
+  }
   if (STANDARD_CHART_TYPES.has(chartType)) {
     const parsed = parseChart(content);
     return { diagnostics: parsed.diagnostics };

package/src/echarts.ts

@@ -1198,16 +1198,15 @@ function buildFunnelOption(
         const val = p.value;
         const prev = prevValueMap.get(p.name) ?? val;
         const isFirst = p.dataIndex === 0;
-        let html = `<strong>${p.name}</strong>: ${val}`;
-        if (!isFirst) {
-          const stepDrop = ((1 - val / prev) * 100).toFixed(1);
-          html += `<br/>Step drop-off: ${stepDrop}%`;
-        }
-        if (!isFirst && topValue > 0) {
+        if (isFirst) return '';
+        const parts: string[] = [];
+        const stepDrop = ((1 - val / prev) * 100).toFixed(1);
+        parts.push(`Step drop-off: ${stepDrop}%`);
+        if (topValue > 0) {
           const totalDrop = ((1 - val / topValue) * 100).toFixed(1);
-          html += `<br/>Overall drop-off: ${totalDrop}%`;
+          parts.push(`Overall drop-off: ${totalDrop}%`);
         }
-        return html;
+        return parts.join('<br/>');
       },
     },
     series: [

package/src/index.ts

@@ -144,6 +144,17 @@ export type {
 
 export { renderOrg, renderOrgForExport } from './org/renderer';
 
+export { parseKanban } from './kanban/parser';
+export type {
+  ParsedKanban,
+  KanbanColumn,
+  KanbanCard,
+  KanbanTagGroup,
+  KanbanTagEntry,
+} from './kanban/types';
+export { computeCardMove, computeCardArchive, isArchiveColumn } from './kanban/mutations';
+export { renderKanban, renderKanbanForExport } from './kanban/renderer';
+
 export { collapseOrgTree } from './org/collapse';
 export type { CollapsedOrgResult } from './org/collapse';
 

package/src/kanban/mutations.ts

@@ -0,0 +1,183 @@
+import type { ParsedKanban, KanbanCard, KanbanColumn } from './types';
+
+const ARCHIVE_COLUMN_NAME = 'archive';
+
+// ============================================================
+// computeCardMove — pure function for source text mutation
+// ============================================================
+
+/**
+ * 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
+ */
+export function computeCardMove(
+  content: string,
+  parsed: ParsedKanban,
+  cardId: string,
+  targetColumnId: string,
+  targetIndex: number
+): string | null {
+  // Find source card and column
+  let sourceCard: KanbanCard | null = null;
+  let sourceColumn: KanbanColumn | null = 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');
+
+  // Extract the card's lines (0-based indices)
+  const startIdx = sourceCard.lineNumber - 1;
+  const endIdx = sourceCard.endLineNumber - 1;
+  const cardLines = lines.slice(startIdx, endIdx + 1);
+
+  // Remove the card lines from content
+  const withoutCard = [
+    ...lines.slice(0, startIdx),
+    ...lines.slice(endIdx + 1),
+  ];
+
+  // Compute insertion point (0-based index in withoutCard)
+  let insertIdx: number;
+
+  // Adjust target column and card line numbers after removal
+  // Lines after the removed range shift up by the number of removed lines
+  const removedCount = endIdx - startIdx + 1;
+  const adjustLine = (ln: number): number => {
+    // ln is 1-based
+    if (ln > endIdx + 1) return ln - removedCount;
+    return ln;
+  };
+
+  if (targetIndex === 0) {
+    // Insert right after column header line
+    const adjColLine = adjustLine(targetColumn.lineNumber);
+    insertIdx = adjColLine; // 0-based: insert after the column header line
+  } else {
+    // Insert after the preceding card's last line
+    // Get the cards in the target column, excluding the moved card
+    const targetCards = targetColumn.cards.filter((c) => c.id !== cardId);
+    const clampedIdx = Math.min(targetIndex, targetCards.length);
+    const precedingCard = targetCards[clampedIdx - 1];
+    if (!precedingCard) {
+      // Fallback: after column header
+      const adjColLine = adjustLine(targetColumn.lineNumber);
+      insertIdx = adjColLine;
+    } else {
+      const adjEndLine = adjustLine(precedingCard.endLineNumber);
+      insertIdx = adjEndLine; // 0-based: insert after this line
+    }
+  }
+
+  // Splice the card lines into the new position
+  const result = [
+    ...withoutCard.slice(0, insertIdx),
+    ...cardLines,
+    ...withoutCard.slice(insertIdx),
+  ];
+
+  return result.join('\n');
+}
+
+// ============================================================
+// computeCardArchive — move card to an Archive section
+// ============================================================
+
+/**
+ * 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
+ */
+export function computeCardArchive(
+  content: string,
+  parsed: ParsedKanban,
+  cardId: string
+): string | null {
+  let sourceCard: KanbanCard | null = 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');
+
+  // Extract card lines
+  const startIdx = sourceCard.lineNumber - 1;
+  const endIdx = sourceCard.endLineNumber - 1;
+  const cardLines = lines.slice(startIdx, endIdx + 1);
+
+  // Remove card from its current position
+  const withoutCard = [
+    ...lines.slice(0, startIdx),
+    ...lines.slice(endIdx + 1),
+  ];
+
+  // Check if an Archive column already exists
+  const archiveCol = parsed.columns.find(
+    (c) => c.name.toLowerCase() === ARCHIVE_COLUMN_NAME
+  );
+
+  if (archiveCol) {
+    // Append to existing archive column
+    // Find the last line of the archive column (after removal adjustment)
+    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;
+    }
+    // Adjust for removed lines
+    if (archiveEndLine > endIdx + 1) {
+      archiveEndLine -= removedCount;
+    }
+    // Insert after the archive end (0-based in withoutCard)
+    const insertIdx = archiveEndLine; // archiveEndLine is 1-based, so this is after that line
+    return [
+      ...withoutCard.slice(0, insertIdx),
+      ...cardLines,
+      ...withoutCard.slice(insertIdx),
+    ].join('\n');
+  } else {
+    // Create archive section at end of file
+    // Ensure trailing newline before the new section
+    const trimmedEnd = withoutCard.length > 0 && withoutCard[withoutCard.length - 1].trim() === ''
+      ? withoutCard
+      : [...withoutCard, ''];
+    return [
+      ...trimmedEnd,
+      '== Archive ==',
+      ...cardLines,
+    ].join('\n');
+  }
+}
+
+/** Check if a column name is the archive column (case-insensitive). */
+export function isArchiveColumn(name: string): boolean {
+  return name.toLowerCase() === ARCHIVE_COLUMN_NAME;
+}