@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-A4GOY3PE.js

@@ -0,0 +1,25 @@
+// src/utils/title-constants.ts
+var TITLE_FONT_SIZE = 20;
+var TITLE_FONT_WEIGHT = "700";
+var TITLE_Y = 30;
+var TITLE_OFFSET = 40;
+var CAPTION_FONT_SIZE = 13;
+var CAPTION_FONT_WEIGHT = "400";
+var CAPTION_LINE_HEIGHT = 18;
+var CAPTION_TOP_GAP = 12;
+var CAPTION_BOX_PADDING_X = 16;
+var CAPTION_BOX_PADDING_Y = 12;
+
+export {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y,
+  TITLE_OFFSET,
+  CAPTION_FONT_SIZE,
+  CAPTION_FONT_WEIGHT,
+  CAPTION_LINE_HEIGHT,
+  CAPTION_TOP_GAP,
+  CAPTION_BOX_PADDING_X,
+  CAPTION_BOX_PADDING_Y
+};
+//# sourceMappingURL=chunk-A4GOY3PE.js.map

package/dist/chunk-A4VFQH5G.js

@@ -0,0 +1,251 @@
+import {
+  renderInlineText
+} from "./chunk-3HDBAXF5.js";
+import {
+  wrapDescriptionLines
+} from "./chunk-BMR4CIEO.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  CHAR_WIDTH_RATIO
+} from "./chunk-WCT3NYCV.js";
+import {
+  contrastText,
+  getSeriesColors,
+  shapeFill
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+
+// src/ring/renderer.ts
+import * as d3Selection from "d3-selection";
+var TITLE_AREA_HEIGHT = 50;
+var H_MARGIN_FRAC = 0.03;
+var V_MARGIN = 16;
+var RING_AREA_FRAC_NO_DESC = 0.78;
+var RING_AREA_FRAC_WITH_DESC = 0.58;
+var DESC_GAP = 28;
+var DESC_ACCENT_WIDTH = 3;
+var DESC_ACCENT_GAP = 12;
+var BULLET_BODY_INDENT = 10;
+var RING_STROKE_WIDTH = 1;
+var RING_STROKE_OPACITY = 0.4;
+var DESC_LINE_CAP = 4;
+var LABEL_FONT_MIN = 12;
+var LABEL_FONT_MAX = 22;
+var DESC_FONT_MIN = 11;
+var DESC_FONT_MAX = 15;
+function renderRing(container, parsed, palette, isDark, onClickItem, exportDims) {
+  if (parsed.layers.length === 0) return;
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const idealWidth = width;
+  const sctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
+  const sTitleFontSize = sctx.text(TITLE_FONT_SIZE);
+  const sTitleY = sctx.structural(TITLE_Y);
+  const sTitleAreaHeight = sctx.structural(TITLE_AREA_HEIGHT);
+  const sVMargin = sctx.aesthetic(V_MARGIN);
+  const N = parsed.layers.length;
+  const hasAnyDescription = parsed.layers.some((l) => l.description.length > 0);
+  const showTitle = !!parsed.title && parsed.options["no-title"] !== "on";
+  const titleH = showTitle ? sTitleAreaHeight : 0;
+  const bodyTop = titleH + sVMargin;
+  const bodyBottom = height - sVMargin;
+  const bodyHeight = Math.max(60, bodyBottom - bodyTop);
+  const sideMargin = width * H_MARGIN_FRAC;
+  const usableWidth = width - sideMargin * 2;
+  const ringAreaFrac = hasAnyDescription ? RING_AREA_FRAC_WITH_DESC : RING_AREA_FRAC_NO_DESC;
+  const ringDiameterByWidth = usableWidth * ringAreaFrac;
+  const ringDiameterByHeight = bodyHeight;
+  const ringDiameter = Math.min(ringDiameterByWidth, ringDiameterByHeight);
+  const outerRadius = ringDiameter / 2;
+  const thickness = outerRadius / N;
+  const cy = bodyTop + bodyHeight / 2;
+  const cx = hasAnyDescription ? sideMargin + usableWidth * ringAreaFrac / 2 : width / 2;
+  const descAccentX = cx + outerRadius + DESC_GAP;
+  const descTextX = descAccentX + DESC_ACCENT_WIDTH + DESC_ACCENT_GAP;
+  const descTextWidth = Math.max(80, width - sideMargin - descTextX);
+  const naturalLabelFont = Math.round(thickness * 0.45);
+  const inBandLabelsVisible = naturalLabelFont >= LABEL_FONT_MIN;
+  const labelFont = clamp(naturalLabelFont, LABEL_FONT_MIN, LABEL_FONT_MAX);
+  const descFont = hasAnyDescription ? clamp(Math.round(descTextWidth / 30), DESC_FONT_MIN, DESC_FONT_MAX) : DESC_FONT_MIN;
+  const descLineHeight = Math.round(descFont * 1.35);
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMid meet").attr("xmlns", "http://www.w3.org/2000/svg").style("font-family", FONT_FAMILY);
+  if (sctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  svg.append("rect").attr("width", width).attr("height", height).attr("fill", palette.bg);
+  if (showTitle) {
+    const titleText = svg.append("text").attr("class", "chart-title").attr("x", width / 2).attr("y", sTitleY).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", sTitleFontSize).attr("font-weight", TITLE_FONT_WEIGHT).attr("data-line-number", parsed.titleLineNumber).text(parsed.title).style("cursor", onClickItem ? "pointer" : "default");
+    if (onClickItem) {
+      titleText.on("click", () => onClickItem(parsed.titleLineNumber));
+    }
+  }
+  const seriesColors = getSeriesColors(palette);
+  const resolveLayerColor = (layer, i) => {
+    if (layer.color) {
+      const named = resolveColor(layer.color, palette);
+      if (named) return named;
+    }
+    return seriesColors[i % seriesColors.length];
+  };
+  const solid = parsed.options["solid-fill"] === "on";
+  const layerColors = parsed.layers.map((l, i) => resolveLayerColor(l, i));
+  const layerFills = layerColors.map(
+    (c) => shapeFill(palette, c, isDark, { solid })
+  );
+  const diagramG = svg.append("g").attr("class", "ring-body");
+  const strokeColor = palette.text;
+  for (let i = 0; i < N; i++) {
+    const layer = parsed.layers[i];
+    const rOuter = (i + 1) * thickness;
+    const rInner = i * thickness;
+    const fill = layerFills[i];
+    const layerG = diagramG.append("g").attr("class", "ring-layer").attr("data-line-number", layer.lineNumber);
+    if (onClickItem) {
+      const ln = layer.lineNumber;
+      layerG.style("cursor", "pointer").on("click", () => onClickItem(ln));
+    }
+    if (i === 0) {
+      layerG.append("circle").attr("cx", cx).attr("cy", cy).attr("r", rOuter).attr("fill", fill).attr("stroke", strokeColor).attr("stroke-width", RING_STROKE_WIDTH).attr("stroke-opacity", RING_STROKE_OPACITY);
+    } else {
+      const d = `M ${cx - rOuter} ${cy} A ${rOuter} ${rOuter} 0 1 0 ${cx + rOuter} ${cy} A ${rOuter} ${rOuter} 0 1 0 ${cx - rOuter} ${cy} M ${cx - rInner} ${cy} A ${rInner} ${rInner} 0 1 0 ${cx + rInner} ${cy} A ${rInner} ${rInner} 0 1 0 ${cx - rInner} ${cy} Z`;
+      layerG.append("path").attr("d", d).attr("fill-rule", "evenodd").attr("fill", fill).attr("stroke", strokeColor).attr("stroke-width", RING_STROKE_WIDTH).attr("stroke-opacity", RING_STROKE_OPACITY);
+    }
+  }
+  if (inBandLabelsVisible) {
+    const labelsG = svg.append("g").attr("class", "ring-labels");
+    for (let i = 0; i < N; i++) {
+      const layer = parsed.layers[i];
+      const fill = layerFills[i];
+      const isInnermost = i === 0;
+      const labelY = isInnermost ? cy : cy - (i + 0.5) * thickness;
+      const fittedFont = labelFont;
+      const textColor = contrastText(
+        fill,
+        palette.textOnFillLight,
+        palette.textOnFillDark
+      );
+      const labelG = labelsG.append("g").attr("class", "ring-label-group").attr("data-line-number", layer.lineNumber);
+      const label = labelG.append("text").attr("class", "ring-label").attr("x", cx).attr("y", labelY).attr("dy", "0.35em").attr("text-anchor", "middle").attr("fill", textColor).attr("font-family", FONT_FAMILY).attr("font-size", fittedFont).attr("font-weight", 600).style("pointer-events", "none");
+      renderInlineText(label, layer.label, palette, fittedFont);
+    }
+  }
+  if (hasAnyDescription || !inBandLabelsVisible) {
+    renderSideDescriptions({
+      parentG: svg.append("g").attr("class", "ring-descriptions"),
+      layers: parsed.layers,
+      colors: layerColors,
+      accentX: descAccentX,
+      textX: descTextX,
+      textWidth: descTextWidth,
+      topY: bodyTop,
+      bottomY: bodyBottom,
+      descFont,
+      descLineHeight,
+      palette,
+      ...onClickItem !== void 0 && { onClickItem }
+    });
+  }
+}
+function renderRingForExport(container, parsed, palette, isDark, exportDims) {
+  renderRing(container, parsed, palette, isDark, void 0, exportDims);
+}
+function renderSideDescriptions(args) {
+  const {
+    parentG,
+    layers,
+    colors,
+    accentX,
+    textX,
+    textWidth,
+    topY,
+    bottomY,
+    descFont,
+    descLineHeight,
+    palette,
+    onClickItem
+  } = args;
+  const charsPerLine = Math.max(
+    8,
+    Math.floor(textWidth / (descFont * CHAR_WIDTH_RATIO))
+  );
+  const labelRowH = Math.round(descFont * 1.3);
+  const gutter = Math.max(8, Math.round(descFont * 0.6));
+  const availableH = bottomY - topY;
+  const computeStack = (cap) => {
+    const wraps2 = layers.map(
+      (l) => truncateWithEllipsis(
+        wrapDescriptionLines(l.description.slice(), charsPerLine),
+        cap
+      )
+    );
+    const blockHeights2 = wraps2.map(
+      (lines) => labelRowH + lines.length * descLineHeight
+    );
+    const totalH2 = blockHeights2.reduce((s, h) => s + h, 0) + gutter * Math.max(0, layers.length - 1);
+    return { wraps: wraps2, blockHeights: blockHeights2, totalH: totalH2 };
+  };
+  let stack = computeStack(DESC_LINE_CAP);
+  for (let cap = DESC_LINE_CAP - 1; cap >= 0 && stack.totalH > availableH; cap--) {
+    stack = computeStack(cap);
+  }
+  const { wraps, blockHeights, totalH } = stack;
+  let cursorY = topY + Math.max(0, (availableH - totalH) / 2);
+  for (let i = 0; i < layers.length; i++) {
+    const layer = layers[i];
+    const lines = wraps[i];
+    const blockH = blockHeights[i];
+    const blockG = parentG.append("g").attr("class", "ring-desc").attr("data-line-number", layer.lineNumber);
+    if (onClickItem) {
+      const ln = layer.lineNumber;
+      blockG.style("cursor", "pointer").on("click", () => onClickItem(ln));
+    }
+    blockG.append("rect").attr("x", accentX).attr("y", cursorY).attr("width", DESC_ACCENT_WIDTH).attr("height", blockH).attr("rx", DESC_ACCENT_WIDTH / 2).attr("fill", colors[i]);
+    const labelEl = blockG.append("text").attr("x", textX).attr("y", cursorY + Math.round(labelRowH * 0.7)).attr("text-anchor", "start").attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", descFont).attr("font-weight", 600);
+    renderInlineText(labelEl, layer.label, palette, descFont);
+    let lineY = cursorY + labelRowH + Math.round(descLineHeight * 0.4);
+    for (const line of lines) {
+      const isBullet = line.kind === "bullet-first" || line.kind === "bullet-cont";
+      if (line.kind === "bullet-first") {
+        blockG.append("text").attr("x", textX).attr("y", lineY).attr("text-anchor", "start").attr("fill", palette.textMuted).attr("font-family", FONT_FAMILY).attr("font-size", descFont).text("\u2022");
+      }
+      const textEl = blockG.append("text").attr("x", isBullet ? textX + BULLET_BODY_INDENT : textX).attr("y", lineY).attr("text-anchor", "start").attr("fill", palette.textMuted).attr("font-family", FONT_FAMILY).attr("font-size", descFont);
+      renderInlineText(textEl, line.text, palette, descFont);
+      lineY += descLineHeight;
+    }
+    cursorY += blockH + gutter;
+  }
+}
+function truncateWithEllipsis(lines, cap) {
+  if (lines.length <= cap) return lines.slice();
+  const visible = lines.slice(0, cap);
+  if (visible.length === 0) return visible;
+  const last = visible[visible.length - 1];
+  visible[visible.length - 1] = {
+    ...last,
+    text: last.text.endsWith("\u2026") ? last.text : `${last.text} \u2026`
+  };
+  return visible;
+}
+function clamp(x, lo, hi) {
+  return Math.max(lo, Math.min(hi, x));
+}
+
+export {
+  renderRing,
+  renderRingForExport
+};
+//# sourceMappingURL=chunk-A4VFQH5G.js.map

package/dist/chunk-AELOBFW5.js

@@ -0,0 +1,375 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  KANBAN_REGISTRY,
+  OPTION_NOCOLON_RE,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/kanban/parser.ts
+var COLUMN_RE = /^\[(.+?)\]\s*(.*)$/;
+var PALETTE_COLOR_WORD_RE = /^(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\b/;
+var AS_ALIAS_TOKEN_RE = /^as\s+([A-Za-z][A-Za-z0-9_]{0,11})\b/;
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set(["hide", "active-tag", "lane-by"]);
+var KNOWN_BOOLEANS = /* @__PURE__ */ new Set(["solid-fill", "no-title"]);
+var REMOVED_BOOLEANS = {
+  "no-auto-color": '"no-auto-color" was removed \u2014 colors are always auto-assigned from the palette; delete this line.'
+};
+function parseKanban(content, palette) {
+  const options = {};
+  const result = {
+    type: "kanban",
+    columns: [],
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let currentTagGroup = null;
+  let currentColumn = null;
+  let currentCard = null;
+  let cardBaseIndent = 0;
+  let columnCounter = 0;
+  let cardCounter = 0;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  const tagValueSets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (currentTagGroup) currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!contentStarted && !currentTagGroup) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine) {
+        if (firstLine.chartType !== "kanban") {
+          const allTypes = [
+            "kanban",
+            "org",
+            "class",
+            "flowchart",
+            "sequence",
+            "er",
+            "bar",
+            "line",
+            "pie"
+          ];
+          let msg = `Expected chart type "kanban", got "${firstLine.chartType}"`;
+          const hint = suggest(firstLine.chartType, allTypes);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        if (firstLine.title) {
+          result.title = firstLine.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    if (!contentStarted) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        if (tagBlockMatch.alias) {
+          metaAliasMap.set(
+            normalizeName(tagBlockMatch.alias),
+            tagAttrKey(tagBlockMatch.name)
+          );
+        }
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.name),
+          tagAttrKey(tagBlockMatch.name)
+        );
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+    }
+    if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch && !COLUMN_RE.test(trimmed)) {
+        const key = optMatch[1].trim().toLowerCase();
+        if (KNOWN_OPTIONS.has(key)) {
+          options[key] = optMatch[2].trim();
+          continue;
+        }
+      }
+      const removedMsg = REMOVED_BOOLEANS[trimmed.toLowerCase()];
+      if (removedMsg && !COLUMN_RE.test(trimmed)) {
+        warn(lineNumber, removedMsg);
+        continue;
+      }
+      if (KNOWN_BOOLEANS.has(trimmed.toLowerCase()) && !COLUMN_RE.test(trimmed)) {
+        options[trimmed.toLowerCase()] = "on";
+        continue;
+      }
+    }
+    if (currentTagGroup && !contentStarted) {
+      const indent2 = measureIndent(line);
+      if (indent2 > 0) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    const indent = measureIndent(line);
+    const columnMatch = indent === 0 ? trimmed.match(COLUMN_RE) : null;
+    if (columnMatch) {
+      contentStarted = true;
+      currentTagGroup = null;
+      if (currentCard) {
+        currentCard.endLineNumber = lineNumber - 1;
+        while (currentCard.endLineNumber > currentCard.lineNumber && !lines[currentCard.endLineNumber - 1].trim()) {
+          currentCard.endLineNumber--;
+        }
+      }
+      currentCard = null;
+      columnCounter++;
+      const colName = columnMatch[1].trim();
+      let tail = (columnMatch[2] ?? "").trim();
+      let colColor;
+      const colorMatch = tail.match(PALETTE_COLOR_WORD_RE);
+      if (colorMatch) {
+        colColor = resolveColorWithDiagnostic(
+          colorMatch[1],
+          lineNumber,
+          result.diagnostics,
+          palette
+        );
+        tail = tail.substring(colorMatch[0].length).trim();
+      }
+      let colAlias;
+      const aliasMatch = tail.match(AS_ALIAS_TOKEN_RE);
+      if (aliasMatch) {
+        colAlias = aliasMatch[1];
+        tail = tail.substring(aliasMatch[0].length).trim();
+      }
+      const columnMetadata = {};
+      let wipLimit;
+      if (tail.length > 0) {
+        const registry = withTagAliases(
+          KANBAN_REGISTRY,
+          new Set(metaAliasMap.keys())
+        );
+        const split = splitNameAndMeta(
+          tail,
+          registry,
+          metaAliasMap,
+          void 0,
+          result.diagnostics,
+          lineNumber
+        );
+        warnUnknownMetaKeys(
+          split.meta,
+          registry,
+          (msg) => warn(lineNumber, msg),
+          split.name
+        );
+        Object.assign(columnMetadata, split.meta);
+      }
+      if (columnMetadata["wip"]) {
+        const wipVal = parseInt(columnMetadata["wip"], 10);
+        if (!isNaN(wipVal)) wipLimit = wipVal;
+      }
+      let colCollapsed = false;
+      if (columnMetadata["collapsed"]?.toLowerCase() === "true") {
+        colCollapsed = true;
+        delete columnMetadata["collapsed"];
+      }
+      const colId = `col-${columnCounter}`;
+      if (colAlias) nameAliasMap.set(colAlias, colId);
+      currentColumn = {
+        id: colId,
+        name: colName,
+        ...wipLimit !== void 0 && { wipLimit },
+        ...colColor !== void 0 && { color: colColor },
+        ...colCollapsed && { collapsed: true },
+        cards: [],
+        lineNumber,
+        metadata: columnMetadata
+      };
+      result.columns.push(currentColumn);
+      continue;
+    }
+    if (!contentStarted) {
+      continue;
+    }
+    if (!currentColumn) {
+      warn(
+        lineNumber,
+        "Card line found before any column. Declare a column first with '[Column Name]', then indent cards beneath it. (\xA711)"
+      );
+      continue;
+    }
+    if (currentCard && indent > cardBaseIndent) {
+      currentCard.details.push(trimmed);
+      currentCard.endLineNumber = lineNumber;
+      continue;
+    }
+    if (indent > 0) {
+      cardCounter++;
+      const card = parseCardLine(
+        trimmed,
+        lineNumber,
+        cardCounter,
+        metaAliasMap,
+        palette,
+        result.diagnostics
+      );
+      if (currentColumn.metadata) {
+        const cardTags = card.tags;
+        for (const [key, value] of Object.entries(currentColumn.metadata)) {
+          if (key === "wip") continue;
+          if (!(key in cardTags)) {
+            cardTags[key] = value;
+          }
+        }
+      }
+      cardBaseIndent = indent;
+      currentCard = card;
+      currentColumn.cards.push(card);
+      continue;
+    }
+    warn(
+      lineNumber,
+      currentColumn ? `Unexpected line: '${trimmed}'. Expected an indented card name or column header like '[Column Name]'.` : `Unexpected line: '${trimmed}'. Expected a column header like '[Column Name]'.`
+    );
+  }
+  if (currentCard) {
+  }
+  for (const group of result.tagGroups) {
+    const values = new Set(group.entries.map((e) => e.value.toLowerCase()));
+    tagValueSets.set(tagAttrKey(group.name), values);
+  }
+  for (const col of result.columns) {
+    if (col.wipLimit != null && col.cards.length > col.wipLimit) {
+      warn(
+        col.lineNumber,
+        `Column "${col.name}" has ${col.cards.length} cards but WIP limit is ${col.wipLimit}`
+      );
+    }
+  }
+  for (const col of result.columns) {
+    for (const card of col.cards) {
+      for (const [tagKey, tagValue] of Object.entries(card.tags)) {
+        const groupKey = metaAliasMap.get(tagKey.toLowerCase()) ?? tagKey.toLowerCase();
+        const validValues = tagValueSets.get(groupKey);
+        if (validValues && !validValues.has(tagValue.toLowerCase())) {
+          const entries = result.tagGroups.find((g) => g.name.toLowerCase() === groupKey)?.entries.map((e) => e.value);
+          let msg = `Unknown tag value "${tagValue}" for group "${groupKey}"`;
+          if (entries) {
+            const hint = suggest(tagValue, entries);
+            if (hint) msg += `. ${hint}`;
+          }
+          warn(card.lineNumber, msg);
+        }
+      }
+    }
+  }
+  if (result.columns.length === 0 && !result.error) {
+    return fail(1, "No columns found. Use [Column Name] to define columns");
+  }
+  finalizeAutoTagColors(
+    result.tagGroups,
+    palette
+  );
+  validateTagGroupNames(result.tagGroups, warn, (line, msg) => {
+    const diag = makeDgmoError(line, msg);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
+  return result;
+}
+function parseCardLine(trimmed, lineNumber, counter, metaAliasMap, _palette, diagnostics) {
+  const registry = withTagAliases(
+    KANBAN_REGISTRY,
+    new Set(metaAliasMap.keys())
+  );
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    metaAliasMap,
+    void 0,
+    diagnostics,
+    lineNumber
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => diagnostics?.push(makeDgmoError(lineNumber, msg, "warning")),
+    split.name
+  );
+  const title = split.color !== void 0 ? `${split.name} ${split.color}` : split.name;
+  const tags = { ...split.meta };
+  return {
+    id: `card-${counter}`,
+    title,
+    tags,
+    details: [],
+    lineNumber,
+    endLineNumber: lineNumber
+  };
+}
+
+export {
+  parseKanban
+};
+//# sourceMappingURL=chunk-AELOBFW5.js.map