@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-7JEGTRLD.js

@@ -0,0 +1,338 @@
+import {
+  isBlockNode
+} from "./chunk-NNAAJVBU.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/block/parser.ts
+function parseBlock(content, palette) {
+  const options = { noLegend: false, solidFill: false };
+  const result = {
+    type: "block",
+    title: null,
+    titleLineNumber: null,
+    top: { cols: null, rows: [] },
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const pushError = (line, message, code) => {
+    const diag = makeDgmoError(line, message, "error", code);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const pushWarning = (line, message, code) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning", code));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let topCols = null;
+  let currentTagGroup = null;
+  const aliasMap = /* @__PURE__ */ new Map();
+  const contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!contentStarted) {
+      if (result.titleLineNumber === null && i === 0) {
+        const firstLine = parseFirstLine(trimmed);
+        if (firstLine) {
+          if (firstLine.chartType !== "block") {
+            let msg = `Expected chart type "block", got "${firstLine.chartType}"`;
+            const hint = suggest(firstLine.chartType, ["block"]);
+            if (hint) msg += `. ${hint}`;
+            return fail(lineNumber, msg);
+          }
+          result.title = firstLine.title ?? null;
+          result.titleLineNumber = lineNumber;
+          continue;
+        }
+      }
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        if (tagBlockMatch.alias) {
+          aliasMap.set(
+            tagBlockMatch.alias.toLowerCase(),
+            tagAttrKey(tagBlockMatch.name)
+          );
+        }
+        aliasMap.set(
+          tagAttrKey(tagBlockMatch.name),
+          tagAttrKey(tagBlockMatch.name)
+        );
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+      if (currentTagGroup) {
+        const indent = measureIndent(line);
+        if (indent > 0) {
+          const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+          const { label, color } = extractColor(
+            cleanEntry,
+            palette,
+            result.diagnostics,
+            lineNumber
+          );
+          if (isDefault || currentTagGroup.entries.length === 0) {
+            currentTagGroup.defaultValue = label;
+          }
+          currentTagGroup.entries.push({
+            value: label,
+            color: color ?? AUTO_TAG_COLOR_SENTINEL,
+            lineNumber
+          });
+          continue;
+        }
+        currentTagGroup = null;
+      }
+      if (measureIndent(line) === 0) {
+        const headerCols = trimmed.match(/^columns\s+(\d+)\s*$/i);
+        if (headerCols) {
+          topCols = parseInt(headerCols[1], 10);
+          continue;
+        }
+        if (/^no-legend\s*$/i.test(trimmed)) {
+          options.noLegend = true;
+          continue;
+        }
+        if (/^solid-fill\s*$/i.test(trimmed)) {
+          options.solidFill = true;
+          continue;
+        }
+      }
+    }
+    if (contentStarted && matchTagBlockHeading(trimmed)) {
+      pushError(
+        lineNumber,
+        "Tag groups must appear before block content",
+        "E_TAG_DECLARED_AFTER_CONTENT"
+      );
+      continue;
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    contentLines.push({ indent: measureIndent(line), trimmed, lineNumber });
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  let idx = 0;
+  let nodeCounter = 0;
+  const baseIndent = contentLines.length > 0 ? contentLines[0].indent : 0;
+  const parseGrid = (base) => {
+    const grid = { cols: null, rows: [] };
+    while (idx < contentLines.length) {
+      const ln = contentLines[idx];
+      if (ln.indent < base) break;
+      if (ln.indent > base) {
+        pushWarning(
+          ln.lineNumber,
+          `Over-indented line "${ln.trimmed}" has no parent block \u2014 ignored`
+        );
+        idx++;
+        continue;
+      }
+      const colsMatch = ln.trimmed.match(/^columns\s+(\d+)\s*$/i);
+      if (colsMatch) {
+        grid.cols = parseInt(colsMatch[1], 10);
+        idx++;
+        continue;
+      }
+      if (/^\[|^_(?=\s|$)|^space(?=\s|$)/.test(ln.trimmed)) {
+        const cells = parseRow(
+          ln.trimmed,
+          ln.lineNumber,
+          aliasMap,
+          () => ++nodeCounter,
+          pushWarning
+        );
+        idx++;
+        const only = cells.length === 1 ? cells[0] : null;
+        if (only && isBlockNode(only) && idx < contentLines.length && contentLines[idx].indent > base) {
+          only.grid = parseGrid(contentLines[idx].indent);
+        }
+        if (cells.length > 0) grid.rows.push(cells);
+        continue;
+      }
+      pushWarning(
+        ln.lineNumber,
+        `Unrecognized line "${ln.trimmed}" \u2014 block rows are bracketed (e.g. [A] [B]) or a "columns N" directive`
+      );
+      idx++;
+    }
+    return grid;
+  };
+  result.top = parseGrid(baseIndent);
+  if (topCols !== null && result.top.cols === null) result.top.cols = topCols;
+  const inferGrid = (grid) => {
+    const cols = grid.cols ?? Math.max(
+      1,
+      ...grid.rows.map((r) => r.reduce((s, c) => s + (c.span || 1), 0))
+    );
+    grid.cols = cols;
+    for (const row of grid.rows) {
+      for (const c of row) if (c.span > cols) c.span = cols;
+      const cnt = row.length;
+      const allOne = row.every((c) => (c.span || 1) === 1);
+      if (allOne && cnt > 0 && cnt < cols && cols % cnt === 0) {
+        const sp = cols / cnt;
+        for (const c of row) c.span = sp;
+      }
+      for (const c of row) if (isBlockNode(c) && c.grid) inferGrid(c.grid);
+    }
+  };
+  inferGrid(result.top);
+  const allNodes = [];
+  const collect = (grid) => {
+    for (const row of grid.rows)
+      for (const c of row)
+        if (isBlockNode(c)) {
+          allNodes.push(c);
+          if (c.grid) collect(c.grid);
+        }
+  };
+  collect(result.top);
+  if (result.tagGroups.length > 0) {
+    const tagKeys = result.tagGroups.map((g) => tagAttrKey(g.name));
+    const cascade = (grid, inherited) => {
+      for (const row of grid.rows)
+        for (const c of row) {
+          if (!isBlockNode(c)) continue;
+          for (const k of tagKeys) {
+            if (!(k in c.metadata) && inherited[k] !== void 0) {
+              c.metadata[k] = inherited[k];
+            }
+          }
+          if (c.grid) cascade(c.grid, c.metadata);
+        }
+    };
+    cascade(result.top, {});
+    validateTagValues(allNodes, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning);
+  }
+  if (allNodes.length === 0 && !result.error) {
+    const diag = makeDgmoError(1, "No blocks found in block diagram");
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+function parseRow(line, lineNumber, aliasMap, nextId, pushWarning) {
+  const cells = [];
+  let i = 0;
+  const n = line.length;
+  while (i < n) {
+    while (i < n && line[i] === " ") i++;
+    if (i >= n) break;
+    const gap = line.slice(i).match(/^(_|space)(?=\s|$)/);
+    if (gap) {
+      cells.push({ empty: true, span: 1 });
+      i += gap[1].length;
+      continue;
+    }
+    if (line[i] === "[") {
+      const end = line.indexOf("]", i);
+      if (end < 0) {
+        pushWarning(lineNumber, `Unclosed "[" in block row "${line.trim()}"`);
+        break;
+      }
+      const label = line.slice(i + 1, end).trim();
+      i = end + 1;
+      let tail = "";
+      while (i < n) {
+        let k = i;
+        while (k < n && line[k] === " ") k++;
+        if (k >= n || line[k] === "[") {
+          i = k;
+          break;
+        }
+        let e = k;
+        while (e < n && line[e] !== " " && line[e] !== "[") e++;
+        const tok = line.slice(k, e);
+        if (tok === "_" || tok === "space") {
+          i = k;
+          break;
+        }
+        tail += (tail ? " " : "") + tok;
+        i = e;
+      }
+      const { meta, span, collapsed } = parseBlockTail(tail, aliasMap);
+      const node = {
+        id: `block-node-${nextId()}`,
+        label,
+        span: span ?? 1,
+        collapsed,
+        metadata: meta,
+        lineNumber
+      };
+      cells.push(node);
+      continue;
+    }
+    i++;
+  }
+  return cells;
+}
+function parseBlockTail(tail, aliasMap) {
+  let collapsed = false;
+  const stripped = tail.replace(/(^|\s)collapsed(?=\s|$)/i, (_m, a) => {
+    collapsed = true;
+    return a;
+  });
+  const meta = {};
+  let span;
+  for (const seg of stripped.split(",")) {
+    const t = seg.trim();
+    if (!t) continue;
+    const colonIdx = t.indexOf(":");
+    if (colonIdx < 0) continue;
+    const rawKey = t.slice(0, colonIdx).trim().toLowerCase();
+    const value = t.slice(colonIdx + 1).trim();
+    if (rawKey === "span") {
+      const num = parseInt(value, 10);
+      if (Number.isFinite(num) && num >= 1) span = num;
+    } else if (value) {
+      meta[aliasMap.get(rawKey) ?? rawKey] = value;
+    }
+  }
+  return { meta, ...span !== void 0 && { span }, collapsed };
+}
+
+export {
+  parseBlock
+};
+//# sourceMappingURL=chunk-7JEGTRLD.js.map