@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-Y3J7VR52.js

@@ -0,0 +1,646 @@
+import {
+  RECOGNIZED_COLOR_NAMES,
+  invalidColorDiagnostic,
+  resolveColor,
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  METADATA_DIAGNOSTIC_CODES,
+  emptyMetadataValueMessage,
+  makeDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/utils/reserved-key-registry.ts
+function staticRegistry(keys) {
+  return { keys: new Set(keys), tagAliases: /* @__PURE__ */ new Set() };
+}
+function withTagAliases(base, aliases) {
+  return { keys: base.keys, tagAliases: aliases };
+}
+function isReservedKey(registry, key) {
+  return registry.keys.has(key) || registry.tagAliases.has(key);
+}
+var SEQUENCE_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "role",
+  "collapsed",
+  // Participant layout-order override (§2.2). Colon-keyed `position: N`.
+  "position"
+]);
+var INFRA_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "collapsed",
+  "icon"
+]);
+var MAP_REGISTRY = staticRegistry([
+  "heat",
+  "size",
+  "width",
+  "label",
+  "style"
+  // `surface:` was removed in the 2026-06-02 defaults-on review — it is no longer
+  // a recognized metadata key (the route/edge surface feature was cut; §24B.7).
+  // A stray `surface: water` is no longer captured as a reserved key.
+]);
+var ORG_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "role",
+  "location",
+  "email",
+  "phone"
+]);
+var C4_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "tech",
+  "type",
+  "collapsed"
+]);
+var ER_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "domain"
+]);
+var EVENT_LINE_REGISTRY = staticRegistry([
+  "color"
+]);
+var KANBAN_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "wip",
+  "assignee",
+  "due",
+  "collapsed"
+  // `[Column] collapsed: true` view-state marker
+]);
+var SITEMAP_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "status"
+]);
+var GANTT_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "duration",
+  "offset",
+  "progress",
+  "start",
+  "collapsed"
+  // `[Group] collapsed: true` view-state marker
+]);
+var PERT_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "confidence",
+  "collapsed"
+]);
+var BOXES_AND_LINES_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "heat"
+]);
+var TIMELINE_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "duration"
+]);
+var MINDMAP_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "collapsed"
+]);
+var TECH_RADAR_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "quadrant",
+  "ring",
+  "trend"
+]);
+var CYCLE_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "width",
+  "span"
+]);
+var JOURNEY_MAP_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "score",
+  "emotion",
+  "pain",
+  "opportunity",
+  "thought"
+]);
+var PYRAMID_REGISTRY = staticRegistry([
+  "color",
+  "description"
+]);
+var RING_REGISTRY = staticRegistry([
+  "color",
+  "description"
+]);
+var TREEMAP_REGISTRY = staticRegistry(["heat"]);
+var RACI_REGISTRY = staticRegistry([
+  "color",
+  "description"
+]);
+
+// src/utils/parsing.ts
+var RECOGNIZED_COLOR_SET = new Set(
+  RECOGNIZED_COLOR_NAMES
+);
+var ALL_CHART_TYPES = /* @__PURE__ */ new Set([
+  // data charts
+  "bar",
+  "line",
+  "pie",
+  "polar-area",
+  "radar",
+  "scatter",
+  "sankey",
+  "function",
+  "heatmap",
+  "funnel",
+  // visualizations
+  "slope",
+  "wordcloud",
+  "arc",
+  "timeline",
+  "event-line",
+  "venn",
+  "quadrant",
+  // diagrams
+  "sequence",
+  "flowchart",
+  "class",
+  "er",
+  "org",
+  "kanban",
+  "c4",
+  "state",
+  "sitemap",
+  "infra",
+  "gantt",
+  "pert",
+  "boxes-and-lines",
+  "swimlane",
+  "version-control",
+  "mindmap",
+  "wireframe",
+  "tech-radar",
+  "cycle",
+  "journey-map",
+  "pyramid",
+  "ring",
+  "treemap",
+  "block",
+  "raci",
+  "map"
+]);
+function measureIndent(line) {
+  let indent = 0;
+  for (const ch of line) {
+    if (ch === " ") indent++;
+    else if (ch === "	") indent += 4;
+    else break;
+  }
+  return indent;
+}
+function extractColor(label, palette, diagnostics, line) {
+  const lastSpaceIdx = Math.max(
+    label.lastIndexOf(" "),
+    label.lastIndexOf("	")
+  );
+  if (lastSpaceIdx < 0) return { label };
+  const trailing = label.substring(lastSpaceIdx + 1);
+  if (!RECOGNIZED_COLOR_SET.has(trailing)) {
+    if (diagnostics && line !== void 0) {
+      const diag = invalidColorDiagnostic(trailing, line);
+      if (diag) diagnostics.push(diag);
+    }
+    return { label };
+  }
+  let color;
+  if (diagnostics && line !== void 0) {
+    color = resolveColorWithDiagnostic(trailing, line, diagnostics, palette);
+  } else {
+    color = resolveColor(trailing, palette) ?? void 0;
+  }
+  return {
+    label: label.substring(0, lastSpaceIdx).trimEnd(),
+    ...color !== void 0 && { color }
+  };
+}
+var OPTION_NOCOLON_RE = /^([a-z][a-z0-9-]*)\s+(.+)$/i;
+var GLOBAL_BOOLEANS = /* @__PURE__ */ new Set([
+  "solid-fill",
+  "no-title",
+  "no-notes"
+]);
+function recognizeGlobalBoolean(token) {
+  const t = token.trim().toLowerCase();
+  return GLOBAL_BOOLEANS.has(t) ? t : null;
+}
+function tryParseSharedOption(line, options) {
+  const key = recognizeGlobalBoolean(line);
+  if (key) {
+    options[key] = "on";
+    return true;
+  }
+  return false;
+}
+function parseFirstLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("//")) return null;
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx === -1) {
+    const ct = trimmed.toLowerCase();
+    return ALL_CHART_TYPES.has(ct) ? { chartType: ct, title: void 0 } : null;
+  }
+  const firstToken = trimmed.substring(0, spaceIdx).toLowerCase();
+  if (!ALL_CHART_TYPES.has(firstToken)) return null;
+  return {
+    chartType: firstToken,
+    title: trimmed.substring(spaceIdx + 1).trim() || void 0
+  };
+}
+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;
+}
+function stripQuotes(token) {
+  if (token.length >= 2) {
+    if (token[0] === '"' && token[token.length - 1] === '"' || token[0] === "'" && token[token.length - 1] === "'") {
+      return token.substring(1, token.length - 1);
+    }
+  }
+  return token;
+}
+function tokenizeQuoteAware(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] === " " || input[i] === "	") {
+      i++;
+      continue;
+    }
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i];
+      const start2 = i;
+      i++;
+      while (i < input.length && input[i] !== quote) i++;
+      if (i < input.length) i++;
+      tokens.push(input.substring(start2, i));
+      continue;
+    }
+    const start = i;
+    while (i < input.length && input[i] !== " " && input[i] !== "	") i++;
+    tokens.push(input.substring(start, i));
+  }
+  return tokens;
+}
+function collectIndentedValues(lines, startIndex) {
+  const values = [];
+  const lineNumbers = [];
+  let j = startIndex + 1;
+  for (; j < lines.length; j++) {
+    const raw = lines[j];
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("//")) continue;
+    if (raw[0] !== " " && raw[0] !== "	") break;
+    values.push(trimmed.replace(/,\s*$/, ""));
+    lineNumbers.push(j + 1);
+  }
+  return { values, lineNumbers, newIndex: j - 1 };
+}
+function parseSeriesNames(value, lines, lineIndex, palette, diagnostics) {
+  let rawNames;
+  let series;
+  let newIndex = lineIndex;
+  let nameLineNumbers = [];
+  if (value) {
+    series = value;
+    rawNames = value.split(",").map((s) => s.trim()).filter(Boolean);
+    nameLineNumbers = rawNames.map(() => lineIndex + 1);
+  } else {
+    const collected = collectIndentedValues(lines, lineIndex);
+    newIndex = collected.newIndex;
+    rawNames = collected.values;
+    nameLineNumbers = collected.lineNumbers;
+    series = rawNames.join(", ");
+  }
+  const isHeader = (s) => {
+    const tok = s.split(/\s+/, 1)[0];
+    if (tok === "y-label") return "left";
+    if (tok === "y-right-label") return "right";
+    return null;
+  };
+  if (rawNames.some((r) => isHeader(r) !== null)) {
+    const names2 = [];
+    const nameColors2 = [];
+    const axes = [];
+    const memberLineNumbers = [];
+    let leftLabel;
+    let rightLabel;
+    let currentAxis = "left";
+    for (let i = 0; i < rawNames.length; i++) {
+      const raw = rawNames[i];
+      const side = isHeader(raw);
+      if (side !== null) {
+        const label = raw.slice(raw.indexOf(" ") + 1).trim();
+        currentAxis = side;
+        if (side === "left") leftLabel = label || leftLabel;
+        else rightLabel = label || rightLabel;
+        continue;
+      }
+      const extracted = extractColor(
+        raw,
+        palette,
+        diagnostics,
+        nameLineNumbers[i]
+      );
+      names2.push(extracted.label);
+      nameColors2.push(extracted.color);
+      axes.push(currentAxis);
+      memberLineNumbers.push(nameLineNumbers[i]);
+    }
+    return {
+      series: names2.join(", "),
+      names: names2,
+      nameColors: nameColors2,
+      nameLineNumbers: memberLineNumbers,
+      newIndex,
+      axes,
+      ...leftLabel !== void 0 && { leftLabel },
+      ...rightLabel !== void 0 && { rightLabel }
+    };
+  }
+  const names = [];
+  const nameColors = [];
+  for (let i = 0; i < rawNames.length; i++) {
+    const raw = rawNames[i];
+    const extracted = extractColor(
+      raw,
+      palette,
+      diagnostics,
+      nameLineNumbers[i]
+    );
+    nameColors.push(extracted.color);
+    names.push(extracted.label);
+  }
+  if (names.length === 1) {
+    series = names[0];
+  }
+  return { series, names, nameColors, nameLineNumbers, newIndex };
+}
+function peelTrailingColorName(label) {
+  const lastSpaceIdx = Math.max(
+    label.lastIndexOf(" "),
+    label.lastIndexOf("	")
+  );
+  if (lastSpaceIdx < 0) return { label };
+  const trailing = label.substring(lastSpaceIdx + 1);
+  if (!RECOGNIZED_COLOR_SET.has(trailing)) return { label };
+  return {
+    label: label.substring(0, lastSpaceIdx).trimEnd(),
+    colorName: trailing
+  };
+}
+function peelRampColors(label) {
+  const peelOne = (s) => {
+    const idx = Math.max(s.lastIndexOf(" "), s.lastIndexOf("	"));
+    if (idx < 0) return { rest: s };
+    const trailing = s.substring(idx + 1);
+    if (!RECOGNIZED_COLOR_SET.has(trailing)) return { rest: s };
+    return { rest: s.substring(0, idx).trimEnd(), color: trailing };
+  };
+  const first = peelOne(label);
+  if (first.color === void 0) return { label };
+  const second = peelOne(first.rest);
+  if (second.color === void 0) {
+    return { label: first.rest, high: first.color };
+  }
+  return { label: second.rest, low: second.color, high: first.color };
+}
+var RESERVED_KEY_RE = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var AS_ALIAS_RE = /\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})$/;
+function scanTokens(line) {
+  const tokens = [];
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === " " || line[i] === "	") {
+      i++;
+      continue;
+    }
+    if (line[i] === '"' || line[i] === "'") {
+      const quote = line[i];
+      const start2 = i;
+      i++;
+      while (i < line.length && line[i] !== quote) i++;
+      if (i < line.length) i++;
+      tokens.push({
+        text: line.substring(start2, i),
+        start: start2,
+        end: i,
+        quoted: true
+      });
+      continue;
+    }
+    const start = i;
+    while (i < line.length && line[i] !== " " && line[i] !== "	") i++;
+    tokens.push({
+      text: line.substring(start, i),
+      start,
+      end: i,
+      quoted: false
+    });
+  }
+  return tokens;
+}
+function findMetadataCutOffset(line, tokens, registry) {
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok.quoted) continue;
+    const inlineColon = tok.text.indexOf(":");
+    if (inlineColon > 0) {
+      const keyPart = tok.text.substring(0, inlineColon);
+      if (RESERVED_KEY_RE.test(keyPart) && isReservedKey(registry, keyPart.toLowerCase())) {
+        return tok.start;
+      }
+    } else if (inlineColon < 0) {
+      if (RESERVED_KEY_RE.test(tok.text) && isReservedKey(registry, tok.text.toLowerCase())) {
+        const tail = line.substring(tok.end).replace(/^[ \t]+/, "");
+        if (tail.startsWith(":")) {
+          return tok.start;
+        }
+      }
+    }
+  }
+  return -1;
+}
+function parseMetadataRegion(region, aliasMap, diagnostics, line) {
+  const meta = {};
+  let i = 0;
+  while (i < region.length) {
+    while (i < region.length && (region[i] === " " || region[i] === "	" || region[i] === ","))
+      i++;
+    if (i >= region.length) break;
+    const keyStart = i;
+    while (i < region.length && region[i] !== ":" && region[i] !== ",") i++;
+    if (i >= region.length || region[i] !== ":") break;
+    const rawKey = region.substring(keyStart, i).trim().toLowerCase();
+    if (!rawKey) break;
+    i++;
+    while (i < region.length && (region[i] === " " || region[i] === "	")) i++;
+    let value;
+    if (i < region.length && (region[i] === '"' || region[i] === "'")) {
+      const quote = region[i];
+      i++;
+      const vStart = i;
+      while (i < region.length && region[i] !== quote) i++;
+      value = region.substring(vStart, i);
+      if (i < region.length) i++;
+      while (i < region.length && (region[i] === " " || region[i] === "	"))
+        i++;
+    } else {
+      const vStart = i;
+      while (i < region.length && region[i] !== ",") i++;
+      value = region.substring(vStart, i).trim();
+    }
+    const key = aliasMap.get(rawKey) ?? rawKey;
+    if (!value) {
+      if (diagnostics && line !== void 0) {
+        diagnostics.push(
+          makeDgmoError(
+            line,
+            emptyMetadataValueMessage(rawKey),
+            "warning",
+            METADATA_DIAGNOSTIC_CODES.EMPTY_METADATA_VALUE
+          )
+        );
+      }
+      continue;
+    }
+    meta[key] = value;
+  }
+  return meta;
+}
+function splitNameAndMeta(line, registry, aliasMap = /* @__PURE__ */ new Map(), palette, diagnostics, lineNumber, options = {}) {
+  const tokens = scanTokens(line);
+  const cutOffset = findMetadataCutOffset(line, tokens, registry);
+  let nameRegion;
+  let metaRegion;
+  if (cutOffset === -1) {
+    nameRegion = line.trim();
+    metaRegion = "";
+  } else {
+    nameRegion = line.substring(0, cutOffset).trimEnd();
+    metaRegion = line.substring(cutOffset);
+  }
+  const colorResult = peelTrailingColorName(nameRegion);
+  let postColorName = colorResult.label;
+  let alias;
+  if (options.peelAlias !== false) {
+    const aliasMatch = postColorName.match(AS_ALIAS_RE);
+    if (aliasMatch) {
+      alias = aliasMatch[1];
+      postColorName = postColorName.substring(0, aliasMatch.index).trimEnd();
+    }
+  }
+  const meta = metaRegion.length > 0 ? parseMetadataRegion(metaRegion, aliasMap, diagnostics, lineNumber) : {};
+  void palette;
+  return {
+    name: postColorName,
+    meta,
+    ...colorResult.colorName !== void 0 && {
+      color: colorResult.colorName
+    },
+    ...alias !== void 0 && { alias }
+  };
+}
+var POTENTIAL_META_RE = /\b([\w-]+)\s*:/;
+function warnUnknownMetaKeys(meta, registry, warn, nameToScan) {
+  const candidates = Array.from(registry.keys);
+  for (const key of Object.keys(meta)) {
+    if (isReservedKey(registry, key)) continue;
+    const hint = suggest(key, candidates);
+    warn(`Unknown metadata key "${key}".${hint ? " " + hint : ""}`);
+  }
+  if (nameToScan) {
+    const m = nameToScan.match(POTENTIAL_META_RE);
+    if (m) {
+      const key = m[1].toLowerCase();
+      if (!isReservedKey(registry, key)) {
+        const hint = suggest(key, candidates);
+        if (hint) {
+          warn(`Unknown metadata key "${key}". ${hint}`);
+        }
+      }
+    }
+  }
+}
+
+export {
+  withTagAliases,
+  isReservedKey,
+  SEQUENCE_REGISTRY,
+  INFRA_REGISTRY,
+  MAP_REGISTRY,
+  ORG_REGISTRY,
+  C4_REGISTRY,
+  ER_REGISTRY,
+  EVENT_LINE_REGISTRY,
+  KANBAN_REGISTRY,
+  SITEMAP_REGISTRY,
+  GANTT_REGISTRY,
+  PERT_REGISTRY,
+  BOXES_AND_LINES_REGISTRY,
+  TIMELINE_REGISTRY,
+  MINDMAP_REGISTRY,
+  TECH_RADAR_REGISTRY,
+  CYCLE_REGISTRY,
+  JOURNEY_MAP_REGISTRY,
+  PYRAMID_REGISTRY,
+  RING_REGISTRY,
+  TREEMAP_REGISTRY,
+  RACI_REGISTRY,
+  ALL_CHART_TYPES,
+  measureIndent,
+  extractColor,
+  OPTION_NOCOLON_RE,
+  tryParseSharedOption,
+  parseFirstLine,
+  normalizeNumericToken,
+  stripQuotes,
+  tokenizeQuoteAware,
+  collectIndentedValues,
+  parseSeriesNames,
+  peelTrailingColorName,
+  peelRampColors,
+  splitNameAndMeta,
+  warnUnknownMetaKeys
+};
+//# sourceMappingURL=chunk-Y3J7VR52.js.map

package/dist/chunk-Y5QGVTVC.js

@@ -0,0 +1,33 @@
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+
+// src/utils/export-container.ts
+function runInExportContainer(width, height, fn) {
+  const container = document.createElement("div");
+  container.style.width = `${width}px`;
+  container.style.height = `${height}px`;
+  container.style.position = "absolute";
+  container.style.left = "-9999px";
+  document.body.appendChild(container);
+  try {
+    return fn(container);
+  } finally {
+    document.body.removeChild(container);
+  }
+}
+function extractExportSvg(container, theme) {
+  const svgEl = container.querySelector("svg");
+  if (!svgEl) return "";
+  if (theme === "transparent") svgEl.style.background = "none";
+  svgEl.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  svgEl.style.fontFamily = FONT_FAMILY;
+  svgEl.querySelectorAll("[data-export-ignore]").forEach((el) => el.remove());
+  return svgEl.outerHTML;
+}
+
+export {
+  runInExportContainer,
+  extractExportSvg
+};
+//# sourceMappingURL=chunk-Y5QGVTVC.js.map