@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-NNAAJVBU.js

@@ -0,0 +1,9 @@
+// src/block/types.ts
+function isBlockNode(cell) {
+  return cell.empty !== true;
+}
+
+export {
+  isBlockNode
+};
+//# sourceMappingURL=chunk-NNAAJVBU.js.map

package/dist/chunk-NOTA6TEI.js

@@ -0,0 +1,47 @@
+// src/utils/name-normalize.ts
+var WHITESPACE_RUN_RE = /\s+/gu;
+function normalizeName(input) {
+  return input.normalize("NFC").replace(WHITESPACE_RUN_RE, " ").trim().toLocaleLowerCase("en-US");
+}
+function displayName(input) {
+  return input.normalize("NFC").trim();
+}
+function getOrCreateName(input, store, lineNumber, aliasStore) {
+  if (aliasStore !== void 0) {
+    const aliased = aliasStore.get(input.trim());
+    if (aliased !== void 0) {
+      return { entry: aliased, created: false };
+    }
+  }
+  const key = normalizeName(input);
+  const incomingDisplay = displayName(input);
+  const existing = store.get(key);
+  if (existing) {
+    if (existing.displayLabel !== incomingDisplay) {
+      return {
+        entry: existing,
+        created: false,
+        merged: {
+          existingLine: existing.declaredLine,
+          existingDisplay: existing.displayLabel,
+          incomingDisplay
+        }
+      };
+    }
+    return { entry: existing, created: false };
+  }
+  const entry = {
+    normalizedKey: key,
+    displayLabel: incomingDisplay,
+    declaredLine: lineNumber
+  };
+  store.set(key, entry);
+  return { entry, created: true };
+}
+
+export {
+  normalizeName,
+  displayName,
+  getOrCreateName
+};
+//# sourceMappingURL=chunk-NOTA6TEI.js.map

package/dist/chunk-NURGB5Z4.js

@@ -0,0 +1,335 @@
+import {
+  OPTION_NOCOLON_RE,
+  TECH_RADAR_REGISTRY,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  warnUnknownMetaKeys
+} from "./chunk-Y3J7VR52.js";
+import {
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/tech-radar/parser.ts
+var VALID_POSITIONS = [
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right"
+];
+var VALID_TRENDS = ["new", "up", "down", "stable"];
+var POSITION_ORDER = [
+  "top-left",
+  "top-right",
+  "bottom-right",
+  "bottom-left"
+];
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set([]);
+var KNOWN_BOOLEANS = /* @__PURE__ */ new Set([
+  "show-blip-legend",
+  "solid-fill",
+  "no-title"
+]);
+function parseTechRadar(content) {
+  const result = {
+    type: "tech-radar",
+    title: "",
+    titleLineNumber: 0,
+    rings: [],
+    quadrants: [],
+    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");
+  }
+  function isRingName(name) {
+    const lower = name.toLowerCase();
+    return result.rings.some(
+      (r) => r.name.toLowerCase() === lower || r.alias !== null && r.alias.toLowerCase() === lower
+    );
+  }
+  function canonicalRingName(name) {
+    const lower = name.toLowerCase();
+    const ring = result.rings.find(
+      (r) => r.name.toLowerCase() === lower || r.alias !== null && r.alias.toLowerCase() === lower
+    );
+    return ring?.name ?? name;
+  }
+  const lines = content.split("\n");
+  let headerParsed = false;
+  let inRingsBlock = false;
+  let currentQuadrant = null;
+  let currentBlip = null;
+  let blipBaseIndent = 0;
+  let currentRing = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    const indent = measureIndent(line);
+    if (!trimmed) {
+      if (inRingsBlock && result.rings.length > 0) {
+        inRingsBlock = false;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!headerParsed) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine?.chartType === "tech-radar") {
+        result.title = firstLine.title ?? "";
+        result.titleLineNumber = lineNumber;
+        headerParsed = true;
+        continue;
+      }
+      return fail(lineNumber, 'Expected "tech-radar" chart type declaration');
+    }
+    if (indent === 0 && trimmed.toLowerCase() === "rings") {
+      if (result.rings.length > 0) {
+        warn(
+          lineNumber,
+          'Duplicate "rings" block \u2014 only the last is kept; merge all ring names into one "rings" block.'
+        );
+        result.rings = [];
+      }
+      inRingsBlock = true;
+      currentBlip = null;
+      currentQuadrant = null;
+      currentRing = null;
+      continue;
+    }
+    if (inRingsBlock) {
+      if (indent > 0) {
+        const aliasMatch = trimmed.match(/^(.+?)\s+(?:alias|aka)\s+(\S+)\s*$/i);
+        if (aliasMatch) {
+          result.rings.push({
+            // Capture groups [1] and [2] guaranteed by regex match.
+            name: aliasMatch[1].trim(),
+            alias: aliasMatch[2].trim(),
+            lineNumber
+          });
+        } else {
+          result.rings.push({ name: trimmed, alias: null, lineNumber });
+        }
+        continue;
+      }
+      inRingsBlock = false;
+    }
+    if (indent === 0 && !trimmed.includes("|")) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].toLowerCase();
+        if (KNOWN_OPTIONS.has(key)) {
+          result.options[key] = optMatch[2].trim();
+          currentBlip = null;
+          continue;
+        }
+      }
+      if (KNOWN_BOOLEANS.has(trimmed.toLowerCase())) {
+        result.options[trimmed.toLowerCase()] = "on";
+        currentBlip = null;
+        continue;
+      }
+    }
+    if (indent === 0 && /\bquadrant\s*:/.test(trimmed)) {
+      const split = splitNameAndMeta(
+        trimmed,
+        TECH_RADAR_REGISTRY,
+        void 0,
+        void 0,
+        void 0,
+        void 0,
+        { peelAlias: false }
+      );
+      warnUnknownMetaKeys(
+        split.meta,
+        TECH_RADAR_REGISTRY,
+        (msg) => warn(lineNumber, msg),
+        split.name
+      );
+      const segments = [split.name];
+      const meta = split.meta;
+      const quadrantPos = meta["quadrant"];
+      if (quadrantPos) {
+        const position = quadrantPos.toLowerCase();
+        if (!VALID_POSITIONS.includes(position)) {
+          const hint = suggest(position, [...VALID_POSITIONS]);
+          let msg = `Invalid quadrant position "${quadrantPos}". Must be one of: ${VALID_POSITIONS.join(", ")}`;
+          if (hint) msg += `. ${hint}`;
+          result.diagnostics.push(makeDgmoError(lineNumber, msg));
+          continue;
+        }
+        const existing = result.quadrants.find((q) => q.position === position);
+        if (existing) {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNumber,
+              `Duplicate quadrant position "${position}" \u2014 already used by "${existing.name}"`
+            )
+          );
+          continue;
+        }
+        const name = segments[0].trim();
+        const color = meta["color"] ?? null;
+        currentQuadrant = {
+          name,
+          position,
+          color,
+          lineNumber,
+          blips: []
+        };
+        result.quadrants.push(currentQuadrant);
+        currentBlip = null;
+        currentRing = null;
+        continue;
+      }
+    }
+    if (currentQuadrant && indent > 0) {
+      if (!trimmed.includes("|") && result.rings.length > 0 && isRingName(trimmed)) {
+        currentRing = canonicalRingName(trimmed);
+        currentBlip = null;
+        continue;
+      }
+      if (currentBlip && indent > blipBaseIndent) {
+        currentBlip.description.push(trimmed);
+        continue;
+      }
+      if (/\b(?:ring|trend|color|description)\s*:/.test(trimmed)) {
+        const split = splitNameAndMeta(
+          trimmed,
+          TECH_RADAR_REGISTRY,
+          void 0,
+          void 0,
+          void 0,
+          void 0,
+          { peelAlias: false }
+        );
+        warnUnknownMetaKeys(
+          split.meta,
+          TECH_RADAR_REGISTRY,
+          (msg) => warn(lineNumber, msg),
+          split.name
+        );
+        const segments = [split.name];
+        const meta = split.meta;
+        const explicitRing = meta["ring"];
+        const effectiveRing = explicitRing ? canonicalRingName(explicitRing) : currentRing;
+        if (!effectiveRing) {
+          result.diagnostics.push(
+            makeDgmoError(
+              lineNumber,
+              `Blip "${segments[0].trim()}" has no ring assignment. Use a ring section header or add "ring: RingName" metadata.`
+            )
+          );
+          continue;
+        }
+        if (explicitRing && result.rings.length > 0 && !isRingName(explicitRing)) {
+          const hint = suggest(
+            explicitRing,
+            result.rings.map((r) => r.name)
+          );
+          let msg = `Unknown ring "${explicitRing}" on blip "${segments[0].trim()}"`;
+          if (hint) msg += `. ${hint}`;
+          result.diagnostics.push(makeDgmoError(lineNumber, msg));
+          continue;
+        }
+        let trend = null;
+        if (meta["trend"]) {
+          const trendVal = meta["trend"].toLowerCase();
+          if (!VALID_TRENDS.includes(trendVal)) {
+            const hint = suggest(meta["trend"], [...VALID_TRENDS]);
+            let msg = `Unknown trend "${meta["trend"]}" on blip "${segments[0].trim()}". Must be one of: ${VALID_TRENDS.join(", ")}`;
+            if (hint) msg += `. ${hint}`;
+            result.diagnostics.push(makeDgmoError(lineNumber, msg, "warning"));
+          } else {
+            trend = trendVal;
+          }
+        }
+        currentBlip = {
+          // In-bounds: split() always returns at least one element.
+          name: segments[0].trim(),
+          ring: effectiveRing,
+          trend,
+          description: [],
+          lineNumber,
+          globalNumber: 0
+        };
+        blipBaseIndent = indent;
+        currentQuadrant.blips.push(currentBlip);
+        continue;
+      }
+      if (currentRing) {
+        currentBlip = {
+          name: trimmed,
+          ring: currentRing,
+          trend: null,
+          description: [],
+          lineNumber,
+          globalNumber: 0
+        };
+        blipBaseIndent = indent;
+        currentQuadrant.blips.push(currentBlip);
+        continue;
+      }
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Blip "${trimmed}" has no ring. Put it under a ring section header, or add a colon-keyed ring \u2014 '${trimmed} ring: RingName' (per \xA720).`
+        )
+      );
+      continue;
+    }
+    if (indent === 0) {
+      if (!trimmed.includes("|") && headerParsed && result.rings.length > 0) {
+        warn(
+          lineNumber,
+          `Unrecognized line "${trimmed}". A quadrant header is 'Name quadrant: <top-left|top-right|bottom-left|bottom-right>' (per \xA720).`
+        );
+      }
+    }
+  }
+  if (result.rings.length === 0) {
+    result.diagnostics.push(
+      makeDgmoError(
+        0,
+        'Missing "rings" block \u2014 declare ring names before quadrant sections'
+      )
+    );
+  }
+  if (result.quadrants.length !== 4) {
+    const msg = result.quadrants.length === 0 ? "No quadrants declared. Exactly 4 quadrants are required." : `Expected exactly 4 quadrants, found ${result.quadrants.length}. Each quadrant needs a unique position (top-left, top-right, bottom-left, bottom-right).`;
+    result.diagnostics.push(makeDgmoError(0, msg));
+  }
+  assignGlobalNumbers(result);
+  return result;
+}
+function assignGlobalNumbers(result) {
+  const ringOrder = result.rings.map((r) => r.name);
+  let counter = 1;
+  for (const position of POSITION_ORDER) {
+    const quadrant = result.quadrants.find((q) => q.position === position);
+    if (!quadrant) continue;
+    const sortedBlips = [...quadrant.blips].sort((a, b) => {
+      const aRing = ringOrder.indexOf(a.ring);
+      const bRing = ringOrder.indexOf(b.ring);
+      if (aRing !== bRing) return aRing - bRing;
+      return a.lineNumber - b.lineNumber;
+    });
+    for (const blip of sortedBlips) {
+      blip.globalNumber = counter++;
+    }
+  }
+}
+
+export {
+  parseTechRadar
+};
+//# sourceMappingURL=chunk-NURGB5Z4.js.map