@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/chunk-FL4IOQ37.js

@@ -0,0 +1,379 @@
+import {
+  preprocessDescriptionLine
+} from "./chunk-IYULMRBE.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  resolveActiveTagGroup,
+  stripDefaultModifier,
+  tagAttrKey
+} from "./chunk-WCUHAQKB.js";
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta
+} from "./chunk-OTAL43EH.js";
+import {
+  makeDgmoError,
+  makeFail
+} from "./chunk-CXK4DZH3.js";
+
+// src/bracket/parser.ts
+var BEATS_RE = /^(.+?)\s+beats\s+(.+)$/i;
+var VS_RE = /^(.+?)\s+vs\s+(.+)$/i;
+var SCORE_RE = /\s+(\d+\s*[-–]\s*\d+)$/;
+var HOME_RE = /\s+@\s+(.+)$/;
+var SEED_RE = /^seed\s+(\d+)\s+(.+)$/i;
+var MODE_FLAGS = /* @__PURE__ */ new Set(["single-elim", "double-elim", "seeded"]);
+function splitMatch(body) {
+  let rest = body;
+  let home = null;
+  const hm = rest.match(HOME_RE);
+  if (hm) {
+    home = hm[1].trim();
+    rest = rest.slice(0, hm.index).trimEnd();
+  }
+  let score = null;
+  const sm = rest.match(SCORE_RE);
+  if (sm) {
+    score = sm[1].replace(/\s+/g, "");
+    rest = rest.slice(0, sm.index).trimEnd();
+  }
+  const m = rest.match(BEATS_RE);
+  if (m) return { left: m[1].trim(), right: m[2].trim(), score, home };
+  return null;
+}
+function parseBracket(content, palette) {
+  const result = {
+    type: "bracket",
+    title: null,
+    titleLineNumber: null,
+    mode: "single-elim",
+    seeded: false,
+    roundNames: [],
+    sides: [],
+    matches: [],
+    seeds: [],
+    tagGroups: [],
+    competitorMeta: /* @__PURE__ */ new Map(),
+    activeTag: null,
+    noLegend: false,
+    noRounds: false,
+    diagnostics: [],
+    error: null
+  };
+  const matches = [];
+  const seeds = [];
+  const sides = [];
+  const sideSeen = /* @__PURE__ */ new Set();
+  const tagGroups = [];
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const competitorMeta = /* @__PURE__ */ new Map();
+  const fail = makeFail(result);
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  const softError = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "error"));
+  };
+  if (!content?.trim()) return fail(0, "No content provided");
+  const registry = () => ({
+    keys: /* @__PURE__ */ new Set(),
+    tagAliases: new Set(metaAliasMap.keys())
+  });
+  const takeMeta = (rest, lineNum) => {
+    const split = splitNameAndMeta(
+      rest,
+      registry(),
+      metaAliasMap,
+      palette,
+      result.diagnostics,
+      lineNum
+    );
+    if (Object.keys(split.meta).length > 0) {
+      const prev = competitorMeta.get(split.name) ?? {};
+      competitorMeta.set(split.name, { ...prev, ...split.meta });
+    }
+    return split.name;
+  };
+  const lines = content.split("\n");
+  let headerParsed = false;
+  let currentSide = null;
+  let currentTagGroup = null;
+  let commentaryTarget = null;
+  let commentaryIndent = 0;
+  let inRoundsBlock = false;
+  const roundDefs = [];
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("#")) {
+      currentTagGroup = null;
+      commentaryTarget = null;
+      inRoundsBlock = false;
+      continue;
+    }
+    if (!headerParsed) {
+      const first = parseFirstLine(trimmed);
+      if (first?.chartType !== "bracket") {
+        return fail(lineNum, 'Expected "bracket [Title]" as the first line.');
+      }
+      if (first.title) {
+        const { label } = extractColor(
+          first.title,
+          palette,
+          result.diagnostics,
+          lineNum
+        );
+        result.title = label || null;
+      }
+      result.titleLineNumber = lineNum;
+      headerParsed = true;
+      continue;
+    }
+    const indent = measureIndent(raw);
+    if (commentaryTarget && indent > commentaryIndent) {
+      commentaryTarget.commentary.push(preprocessDescriptionLine(trimmed));
+      continue;
+    }
+    commentaryTarget = null;
+    if (inRoundsBlock) {
+      if (indent > 0) {
+        const { label, color } = extractColor(
+          trimmed,
+          palette,
+          result.diagnostics,
+          lineNum
+        );
+        if (label)
+          roundDefs.push(
+            color !== void 0 ? { name: label, color } : { name: label }
+          );
+        continue;
+      }
+      inRoundsBlock = false;
+    }
+    const tagHead = matchTagBlockHeading(trimmed);
+    if (tagHead) {
+      currentTagGroup = {
+        name: tagHead.name,
+        ...tagHead.alias !== void 0 && { alias: tagHead.alias },
+        entries: [],
+        lineNumber: lineNum
+      };
+      if (tagHead.alias) {
+        metaAliasMap.set(tagHead.alias.toLowerCase(), tagAttrKey(tagHead.name));
+      }
+      metaAliasMap.set(tagAttrKey(tagHead.name), tagAttrKey(tagHead.name));
+      tagGroups.push(currentTagGroup);
+      continue;
+    }
+    if (currentTagGroup && indent > 0) {
+      const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        cleanEntry,
+        palette,
+        result.diagnostics,
+        lineNum
+      );
+      if (isDefault || currentTagGroup.entries.length === 0) {
+        currentTagGroup.defaultValue = label;
+      }
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber: lineNum
+      });
+      continue;
+    }
+    currentTagGroup = null;
+    if (indent === 0) currentSide = null;
+    const lower = trimmed.toLowerCase();
+    const roundsM = trimmed.match(/^rounds\b(.*)$/i);
+    if (roundsM) {
+      const rest = roundsM[1].trim();
+      if (rest) {
+        for (const name of rest.split(",").map((s) => s.trim()).filter(Boolean))
+          roundDefs.push({ name });
+      } else {
+        inRoundsBlock = true;
+      }
+      continue;
+    }
+    if (MODE_FLAGS.has(lower)) {
+      if (lower === "seeded") result.seeded = true;
+      else result.mode = lower;
+      continue;
+    }
+    if (lower === "no-legend") {
+      result.noLegend = true;
+      continue;
+    }
+    if (lower === "no-round" || lower === "no-rounds") {
+      result.noRounds = true;
+      continue;
+    }
+    const accentM = trimmed.match(/^accent\s+(.+)$/i);
+    if (accentM) {
+      const { color } = extractColor(
+        `x ${accentM[1].trim()}`,
+        palette,
+        result.diagnostics,
+        lineNum
+      );
+      if (color !== void 0) result.accentColor = color;
+      continue;
+    }
+    const sideM = trimmed.match(/^\[(.+?)\](.*)$/);
+    if (sideM) {
+      const label = sideM[1].trim();
+      if (MODE_FLAGS.has(label.toLowerCase())) {
+        const lk = label.toLowerCase();
+        if (lk === "seeded") result.seeded = true;
+        else result.mode = lk;
+        continue;
+      }
+      const { label: cleanLabel, color } = extractColor(
+        sideM[2].trim() ? `${label} ${sideM[2].trim()}` : label,
+        palette,
+        result.diagnostics,
+        lineNum
+      );
+      currentSide = cleanLabel;
+      if (!sideSeen.has(cleanLabel)) {
+        sideSeen.add(cleanLabel);
+        sides.push(
+          color !== void 0 ? { label: cleanLabel, color } : { label: cleanLabel }
+        );
+      }
+      continue;
+    }
+    const side = indent > 0 ? currentSide : null;
+    const seedM = trimmed.match(SEED_RE);
+    if (seedM) {
+      const n = parseInt(seedM[1], 10);
+      const name = takeMeta(seedM[2].trim(), lineNum);
+      result.seeded = true;
+      seeds.push({ seed: n, name, side, lineNumber: lineNum });
+      continue;
+    }
+    const decided = splitMatch(trimmed);
+    if (decided) {
+      if (decided.left === decided.right) {
+        softError(
+          lineNum,
+          `A match can't be "${decided.left}" against itself.`
+        );
+        continue;
+      }
+      if (decided.score) {
+        const parts = decided.score.split(/[-–]/).map((x) => parseInt(x, 10));
+        if (parts.length === 2 && parts[0] < parts[1]) {
+          warn(
+            lineNum,
+            `Score ${decided.score} shows "${decided.left}" losing, but they're on the winning side \u2014 keeping "${decided.left}" as the winner.`
+          );
+        }
+      }
+      const match = {
+        p1: decided.left,
+        p2: decided.right,
+        decided: true,
+        score: decided.score,
+        side,
+        home: decided.home,
+        commentary: [],
+        lineNumber: lineNum
+      };
+      matches.push(match);
+      commentaryTarget = match;
+      commentaryIndent = indent;
+      continue;
+    }
+    let vsBody = trimmed;
+    let vsHome = null;
+    const vhm = vsBody.match(HOME_RE);
+    if (vhm && VS_RE.test(vsBody.slice(0, vhm.index))) {
+      vsHome = vhm[1].trim();
+      vsBody = vsBody.slice(0, vhm.index).trimEnd();
+    }
+    const pending = vsBody.match(VS_RE);
+    if (pending) {
+      const a = pending[1].trim();
+      const b = pending[2].trim();
+      if (a === b) {
+        softError(lineNum, `A match can't be "${a}" against itself.`);
+        continue;
+      }
+      const match = {
+        p1: a,
+        p2: b,
+        decided: false,
+        score: null,
+        side,
+        home: vsHome,
+        commentary: [],
+        lineNumber: lineNum
+      };
+      matches.push(match);
+      commentaryTarget = match;
+      commentaryIndent = indent;
+      continue;
+    }
+    const rosterSplit = splitNameAndMeta(
+      trimmed,
+      registry(),
+      metaAliasMap,
+      palette,
+      result.diagnostics,
+      lineNum
+    );
+    if (Object.keys(rosterSplit.meta).length > 0) {
+      const prev = competitorMeta.get(rosterSplit.name) ?? {};
+      competitorMeta.set(rosterSplit.name, { ...prev, ...rosterSplit.meta });
+      continue;
+    }
+    warn(lineNum, `Unrecognized line "${trimmed}".`);
+  }
+  if (result.mode === "double-elim") {
+    warn(
+      result.titleLineNumber ?? 1,
+      "Double-elimination brackets are not yet supported \u2014 rendering the winners\u2019 side only."
+    );
+  }
+  const seedNames = /* @__PURE__ */ new Map();
+  for (const s of seeds) {
+    const prev = seedNames.get(s.name);
+    if (prev !== void 0) {
+      softError(
+        s.lineNumber,
+        `Duplicate competitor "${s.name}" (already seeded on line ${prev}). Rename one \u2014 names are identifiers.`
+      );
+    } else {
+      seedNames.set(s.name, s.lineNumber);
+    }
+  }
+  finalizeAutoTagColors(tagGroups, palette);
+  result.sides = sides;
+  result.matches = matches;
+  result.seeds = seeds;
+  result.roundNames = roundDefs;
+  result.tagGroups = tagGroups;
+  result.competitorMeta = competitorMeta;
+  result.activeTag = resolveActiveTagGroup(tagGroups, void 0);
+  if (!result.seeded && matches.length === 0) {
+    warn(
+      result.titleLineNumber ?? 1,
+      'No matches \u2014 add "A beats B" or "A vs B" lines.'
+    );
+  }
+  return result;
+}
+
+export {
+  parseBracket
+};
+//# sourceMappingURL=chunk-FL4IOQ37.js.map

package/dist/{chunk-LIOHW36Z.js → chunk-GBE54KY6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-I46X5VUA.js";
 import {
   tryCollectNote
-} from "./chunk-5MLYVTYM.js";
+} from "./chunk-SCHXJTZL.js";
 import {
   resolveNotes
 } from "./chunk-FMDSF3OV.js";
@@ -20,7 +20,7 @@ import {
   measureIndent,
   parseFirstLine,
   tryParseSharedOption
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   NAME_DIAGNOSTIC_CODES,
   emit,
@@ -367,8 +367,9 @@ function parseFlowchart(content, palette) {
       continue;
     }
     if (!contentStarted) {
-      if (/^direction-lr$/i.test(trimmed)) {
-        result.direction = "LR";
+      const dirMatch = trimmed.match(/^direction[-\s]+(lr|tb)$/i);
+      if (dirMatch) {
+        result.direction = dirMatch[1].toUpperCase();
         continue;
       }
       if (/^solid-fill$/i.test(trimmed)) {
@@ -466,4 +467,4 @@ export {
   looksLikeFlowchart,
   extractSymbols
 };
-//# sourceMappingURL=chunk-LIOHW36Z.js.map
+//# sourceMappingURL=chunk-GBE54KY6.js.map

package/dist/{chunk-RUNNI6VE.js → chunk-GL5UZ6NY.js}

@@ -1,6 +1,6 @@
 import {
   tryCollectNote
-} from "./chunk-5MLYVTYM.js";
+} from "./chunk-SCHXJTZL.js";
 import {
   resolveNotes
 } from "./chunk-FMDSF3OV.js";
@@ -16,7 +16,7 @@ import {
   measureIndent,
   parseFirstLine,
   tryParseSharedOption
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-OTAL43EH.js";
 import {
   resolveColorWithDiagnostic
 } from "./chunk-TLVIHFRO.js";
@@ -445,4 +445,4 @@ export {
   looksLikeClassDiagram,
   extractSymbols
 };
-//# sourceMappingURL=chunk-RUNNI6VE.js.map
+//# sourceMappingURL=chunk-GL5UZ6NY.js.map

package/dist/{chunk-4GRI7MEB.js → chunk-GPWHQ5FJ.js}

@@ -2,15 +2,15 @@ import {
   parseInlineMarkdown,
   safeHref
 } from "./chunk-3HDBAXF5.js";
-import {
-  renderIntegratedLegend
-} from "./chunk-PWIHZ6NJ.js";
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-QUJGFNFN.js";
 import {
   getMaxLegendReservedHeight
-} from "./chunk-YAA6IID3.js";
+} from "./chunk-7UEMZREK.js";
 import {
   FONT_FAMILY
 } from "./chunk-6KFWC4CO.js";
@@ -18,7 +18,7 @@ import {
   measureText,
   truncateText,
   wrapTextToWidth
-} from "./chunk-WCT3NYCV.js";
+} from "./chunk-5LWQH6QV.js";
 import {
   contrastText,
   mix,
@@ -1601,4 +1601,4 @@ export {
   renderTechRadar,
   renderTechRadarForExport
 };
-//# sourceMappingURL=chunk-4GRI7MEB.js.map
+//# sourceMappingURL=chunk-GPWHQ5FJ.js.map