@diagrammo/dgmo 0.49.0 → 0.50.1

package/dist/chunk-Q4V4XQWV.js

@@ -0,0 +1,158 @@
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  tryParseSharedOption
+} from "./chunk-OTAL43EH.js";
+import {
+  makeDgmoError,
+  makeFail
+} from "./chunk-CXK4DZH3.js";
+
+// src/goal/parser.ts
+function parseGoalNumber(token) {
+  if (token.includes(",")) return null;
+  const n = parseFloat(token.replace(/_/g, ""));
+  return Number.isFinite(n) ? n : null;
+}
+function parseGoal(content, palette) {
+  const options = {
+    noPercent: false,
+    noValue: false,
+    solidFill: false,
+    noTitle: false,
+    noAutoColor: false,
+    noNote: false
+  };
+  const result = {
+    type: "goal",
+    title: null,
+    titleLineNumber: null,
+    description: null,
+    mode: "bar",
+    now: 0,
+    target: 0,
+    hasTarget: false,
+    options,
+    diagnostics: [],
+    error: null
+  };
+  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 lines = content.split("\n");
+  let headerParsed = false;
+  let sawNow = false;
+  const sharedOpts = {};
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (!headerParsed) {
+      const first = parseFirstLine(trimmed);
+      if (first?.chartType !== "goal") {
+        return fail(lineNum, 'Expected "goal [Title]" as the first line.');
+      }
+      if (first.title) {
+        const { label, color } = extractColor(
+          first.title,
+          palette,
+          result.diagnostics,
+          lineNum
+        );
+        result.title = label || null;
+        if (color !== void 0) result.color = color;
+      }
+      result.titleLineNumber = lineNum;
+      headerParsed = true;
+      continue;
+    }
+    const noteHeader = trimmed.match(/^note(?:\s+(.+))?$/i);
+    if (noteHeader && measureIndent(raw) === 0) {
+      const body = [];
+      if (noteHeader[1]) body.push(noteHeader[1].trim());
+      while (i + 1 < lines.length && measureIndent(lines[i + 1]) > 0) {
+        body.push(lines[i + 1].trim());
+        i++;
+      }
+      result.description = body.length ? body.join("\n") : null;
+      continue;
+    }
+    if (measureIndent(raw) > 0) {
+      warn(
+        lineNum,
+        `Indented content "${trimmed}" ignored \u2014 goal is a single value.`
+      );
+      continue;
+    }
+    const lower = trimmed.toLowerCase();
+    if (lower === "thermometer" || lower === "gauge") {
+      result.mode = lower;
+      continue;
+    }
+    if (lower === "no-percent") {
+      options.noPercent = true;
+      continue;
+    }
+    if (lower === "no-value") {
+      options.noValue = true;
+      continue;
+    }
+    if (lower === "no-auto-color") {
+      options.noAutoColor = true;
+      continue;
+    }
+    if (lower === "no-note") {
+      options.noNote = true;
+      continue;
+    }
+    if (tryParseSharedOption(trimmed, sharedOpts)) {
+      if (sharedOpts["solid-fill"] === "on") options.solidFill = true;
+      if (sharedOpts["no-title"] === "on") options.noTitle = true;
+      continue;
+    }
+    const kv = trimmed.match(/^(now|target)\s+(.+)$/i);
+    if (kv) {
+      const key = kv[1].toLowerCase();
+      const value = parseGoalNumber(kv[2].trim());
+      if (value === null) {
+        softError(lineNum, `"${key}" needs a number (got "${kv[2].trim()}").`);
+        continue;
+      }
+      if (key === "now") {
+        result.now = value;
+        sawNow = true;
+      } else {
+        if (value <= 0) {
+          softError(lineNum, '"target" must be greater than 0.');
+        } else {
+          result.target = value;
+          result.hasTarget = true;
+        }
+      }
+      continue;
+    }
+    warn(lineNum, `Unrecognized line "${trimmed}".`);
+  }
+  if (!sawNow) {
+    warn(result.titleLineNumber ?? 1, 'Missing "now" value \u2014 treating as 0.');
+  }
+  if (!result.hasTarget) {
+    softError(
+      result.titleLineNumber ?? 1,
+      'Missing or invalid "target" \u2014 a goal needs a target > 0.'
+    );
+  }
+  return result;
+}
+
+export {
+  parseGoal
+};
+//# sourceMappingURL=chunk-Q4V4XQWV.js.map

package/dist/{chunk-IHLSHCPZ.js → chunk-QJP6PG7F.js}

@@ -25,13 +25,13 @@ import {
 } from "./chunk-3CIOJ5YJ.js";
 import {
   layoutOrg
-} from "./chunk-IBC35BTK.js";
+} from "./chunk-IUMPEA64.js";
 import {
   ScaleContext
 } from "./chunk-YYVTBZZC.js";
 import {
   renderIntegratedLegend
-} from "./chunk-4UDKKGHH.js";
+} from "./chunk-HEVYAHLW.js";
 import {
   getMaxLegendReservedHeight
 } from "./chunk-7UEMZREK.js";
@@ -55,7 +55,7 @@ import {
 } from "./chunk-5LWQH6QV.js";
 import {
   parseOrg
-} from "./chunk-F743CM2N.js";
+} from "./chunk-OTQKUHRS.js";
 import {
   contrastText,
   mix,
@@ -65,7 +65,7 @@ import {
 import {
   resolveTagColor,
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-FJUNPCYI.js";
 
 // src/org/renderer.ts
 import * as d3Selection from "d3-selection";
@@ -484,4 +484,4 @@ export {
   renderOrg,
   renderOrgForExport
 };
-//# sourceMappingURL=chunk-IHLSHCPZ.js.map
+//# sourceMappingURL=chunk-QJP6PG7F.js.map

package/dist/{chunk-EYN7VFKL.js → chunk-QROYX7TT.js}

@@ -11,7 +11,7 @@ import {
   stripDefaultModifier,
   tagAttrKey,
   validateTagGroupNames
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-FJUNPCYI.js";
 import {
   parseInArrowLabel
 } from "./chunk-FFUN5D66.js";
@@ -27,7 +27,7 @@ import {
   splitNameAndMeta,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-ZNQX6QWH.js";
+} from "./chunk-OTAL43EH.js";
 import {
   formatDgmoError,
   makeDgmoError,
@@ -804,4 +804,4 @@ function validateDeploymentRefs(result, knownNames, pushWarning) {
 export {
   parseC4
 };
-//# sourceMappingURL=chunk-EYN7VFKL.js.map
+//# sourceMappingURL=chunk-QROYX7TT.js.map

package/dist/chunk-QXKWYZNR.js

@@ -0,0 +1,379 @@
+import {
+  preprocessDescriptionLine
+} from "./chunk-IYULMRBE.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  resolveActiveTagGroup,
+  stripDefaultModifier,
+  tagAttrKey
+} from "./chunk-FJUNPCYI.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-QXKWYZNR.js.map

package/dist/{chunk-VC3TR4NL.js → chunk-RZ6YKEUJ.js}

@@ -1,6 +1,6 @@
 import {
   renderIntegratedLegend
-} from "./chunk-4UDKKGHH.js";
+} from "./chunk-HEVYAHLW.js";
 import {
   getMaxLegendReservedHeight
 } from "./chunk-7UEMZREK.js";
@@ -27,7 +27,7 @@ import {
 import {
   resolveTagColor,
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-FJUNPCYI.js";
 
 // src/block/renderer.ts
 import * as d3Selection from "d3-selection";
@@ -359,4 +359,4 @@ export {
   renderBlock,
   authoredCollapsedIds
 };
-//# sourceMappingURL=chunk-VC3TR4NL.js.map
+//# sourceMappingURL=chunk-RZ6YKEUJ.js.map

package/dist/{chunk-K6HNAY5V.js → chunk-SCHXJTZL.js}

@@ -1,7 +1,7 @@
 import {
   extractColor,
   measureIndent
-} from "./chunk-ZNQX6QWH.js";
+} from "./chunk-OTAL43EH.js";
 import {
   makeDgmoError
 } from "./chunk-CXK4DZH3.js";
@@ -73,4 +73,4 @@ function tryCollectNote(lines, index, indent, palette, diagnostics) {
 export {
   tryCollectNote
 };
-//# sourceMappingURL=chunk-K6HNAY5V.js.map
+//# sourceMappingURL=chunk-SCHXJTZL.js.map

package/dist/{chunk-7OVSJI2V.js → chunk-SQLNBA64.js}

@@ -10,7 +10,7 @@ import {
   tagAttrKey,
   validateTagGroupNames,
   validateTagValues
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-FJUNPCYI.js";
 import {
   normalizeName
 } from "./chunk-NOTA6TEI.js";
@@ -25,7 +25,7 @@ import {
   tryParseSharedOption,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-ZNQX6QWH.js";
+} from "./chunk-OTAL43EH.js";
 import {
   formatDgmoError,
   makeDgmoError,
@@ -519,4 +519,4 @@ export {
   looksLikeSitemap,
   parseSitemap
 };
-//# sourceMappingURL=chunk-7OVSJI2V.js.map
+//# sourceMappingURL=chunk-SQLNBA64.js.map

package/dist/{chunk-65RTDUZH.js → chunk-SXRTRMEE.js}

@@ -10,7 +10,7 @@ import {
   tagAttrKey,
   validateTagGroupNames,
   validateTagValues
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-FJUNPCYI.js";
 import {
   MINDMAP_REGISTRY,
   OPTION_NOCOLON_RE,
@@ -21,7 +21,7 @@ import {
   tryParseSharedOption,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-ZNQX6QWH.js";
+} from "./chunk-OTAL43EH.js";
 import {
   formatDgmoError,
   makeDgmoError,
@@ -313,4 +313,4 @@ function findMetadataParent(indent, indentStack) {
 export {
   parseMindmap
 };
-//# sourceMappingURL=chunk-65RTDUZH.js.map
+//# sourceMappingURL=chunk-SXRTRMEE.js.map

package/dist/{chunk-3BIAFYD2.js → chunk-T4VOVZT5.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-YYVTBZZC.js";
 import {
   renderIntegratedLegend
-} from "./chunk-4UDKKGHH.js";
+} from "./chunk-HEVYAHLW.js";
 import {
   getMaxLegendReservedHeight
 } from "./chunk-7UEMZREK.js";
@@ -1601,4 +1601,4 @@ export {
   renderTechRadar,
   renderTechRadarForExport
 };
-//# sourceMappingURL=chunk-3BIAFYD2.js.map
+//# sourceMappingURL=chunk-T4VOVZT5.js.map