@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-AN2MOO5T.js

@@ -0,0 +1,522 @@
+import {
+  tryStripDescriptionKeyword
+} from "./chunk-IYULMRBE.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  isTagBlockHeading,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  ALL_CHART_TYPES,
+  OPTION_NOCOLON_RE,
+  SITEMAP_REGISTRY,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  tryParseSharedOption,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/sitemap/parser.ts
+var CONTAINER_RE = /^\[([^\]]+)\]\s*(.*)$/;
+var METADATA_RE = /^([^:]+):\s*(.+)$/;
+var ARROW_RE = /^-([^>][^>]*?)?\s*->\s*(.+)$/;
+var BARE_ARROW_RE = /^->\s*(.+)$/;
+function parseArrowLine(trimmed, _palette, _lineNumber, _diagnostics) {
+  const bareMatch = trimmed.match(BARE_ARROW_RE);
+  if (bareMatch) {
+    const rawTarget = bareMatch[1].trim();
+    const groupMatch = rawTarget.match(/^\[(.+)\]$/);
+    return {
+      target: groupMatch ? groupMatch[1].trim() : rawTarget,
+      targetIsGroup: !!groupMatch
+    };
+  }
+  const arrowMatch = trimmed.match(ARROW_RE);
+  if (arrowMatch) {
+    const label = arrowMatch[1]?.trim() || void 0;
+    const rawTarget = arrowMatch[2].trim();
+    const groupMatch = rawTarget.match(/^\[(.+)\]$/);
+    return {
+      ...label !== void 0 && { label },
+      target: groupMatch ? groupMatch[1].trim() : rawTarget,
+      targetIsGroup: !!groupMatch
+    };
+  }
+  return null;
+}
+function looksLikeSitemap(content) {
+  const lines = content.split("\n");
+  let hasArrow = false;
+  let hasContainer = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (parseFirstLine(trimmed)) continue;
+    if (isTagBlockHeading(trimmed)) continue;
+    if (/^-.*->\s*.+/.test(trimmed) || /^->\s*.+/.test(trimmed)) {
+      hasArrow = true;
+    }
+    if (CONTAINER_RE.test(trimmed)) {
+      hasContainer = true;
+    }
+  }
+  if (!hasArrow || !hasContainer) return false;
+  const hasFlowchartShapes = /[\])][ \t]*-.*->/.test(content) || /->[ \t]*[[(</]/.test(content);
+  return !hasFlowchartShapes;
+}
+function parseSitemap(content, palette) {
+  const options = {};
+  const result = {
+    title: null,
+    titleLineNumber: null,
+    direction: "LR",
+    roots: [],
+    edges: [],
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const pushError = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const pushWarning = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let nodeCounter = 0;
+  let containerCounter = 0;
+  let firstLineParsed = false;
+  let currentTagGroup = null;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  const indentStack = [];
+  const labelToNode = /* @__PURE__ */ new Map();
+  const labelToContainer = /* @__PURE__ */ new Map();
+  const deferredArrows = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (currentTagGroup) {
+        currentTagGroup = null;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!firstLineParsed && !contentStarted) {
+      const firstLineResult = parseFirstLine(trimmed);
+      if (firstLineResult) {
+        firstLineParsed = true;
+        if (firstLineResult.chartType !== "sitemap") {
+          const allTypes = Array.from(ALL_CHART_TYPES);
+          let msg = `Expected chart type "sitemap", got "${firstLineResult.chartType}"`;
+          const hint = suggest(firstLineResult.chartType, allTypes);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        if (firstLineResult.title) {
+          result.title = firstLineResult.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      if (contentStarted) {
+        pushError(lineNumber, "Tag groups must appear before sitemap content");
+        continue;
+      }
+      const newTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      currentTagGroup = newTagGroup;
+      if (tagBlockMatch.alias) {
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.alias),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      metaAliasMap.set(
+        normalizeName(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      result.tagGroups.push(newTagGroup);
+      continue;
+    }
+    if (!contentStarted && !currentTagGroup && measureIndent(line) === 0 && !trimmed.includes("|") && !trimmed.includes("->") && !trimmed.includes(":")) {
+      if (/^direction-tb$/i.test(trimmed)) {
+        result.direction = "TB";
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) {
+        continue;
+      }
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].trim().toLowerCase();
+        options[key] = optMatch[2].trim();
+        continue;
+      }
+    }
+    if (currentTagGroup && !contentStarted) {
+      const indent2 = measureIndent(line);
+      if (indent2 > 0) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 1) {
+          currentTagGroup.defaultValue = label;
+        }
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    const indent = measureIndent(line);
+    const arrowInfo = parseArrowLine(
+      trimmed,
+      palette,
+      lineNumber,
+      result.diagnostics
+    );
+    if (arrowInfo) {
+      const source = findParentNode(indent, indentStack);
+      if (!source) {
+        pushError(
+          lineNumber,
+          "Arrow '-> target' must be indented under its source page \u2014 no page precedes it."
+        );
+      } else {
+        deferredArrows.push({
+          sourceNode: source,
+          targetLabel: arrowInfo.target,
+          targetIsGroup: arrowInfo.targetIsGroup,
+          ...arrowInfo.label !== void 0 && { label: arrowInfo.label },
+          lineNumber
+        });
+      }
+      continue;
+    }
+    const containerMatch = trimmed.match(CONTAINER_RE);
+    const metadataMatch = (() => {
+      if (trimmed.includes("|")) return null;
+      const m = trimmed.match(METADATA_RE);
+      if (!m) return null;
+      const keyRegion = m[1].trim();
+      if (/\s/.test(keyRegion)) return null;
+      return m;
+    })();
+    if (containerMatch) {
+      const rawLabel = containerMatch[1].trim();
+      const asMatch = rawLabel.match(
+        /^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/
+      );
+      const label = asMatch ? asMatch[1].trim() : rawLabel;
+      const tail = (containerMatch[2] ?? "").trim();
+      const containerMetadata = {};
+      if (tail.length > 0) {
+        Object.assign(
+          containerMetadata,
+          parseSitemapMetaTail(tail, metaAliasMap)
+        );
+      }
+      containerCounter++;
+      const containerId = `container-${containerCounter}`;
+      if (asMatch) nameAliasMap.set(asMatch[2], containerId);
+      const node = {
+        id: containerId,
+        label,
+        metadata: containerMetadata,
+        children: [],
+        parentId: null,
+        isContainer: true,
+        lineNumber
+      };
+      attachNode(node, indent, indentStack, result);
+      const key = normalizeName(label);
+      labelToContainer.set(key, node);
+    } else if (metadataMatch && indentStack.length > 0) {
+      const rawKey = metadataMatch[1].trim().toLowerCase();
+      const key = metaAliasMap.get(rawKey) ?? rawKey;
+      const value = metadataMatch[2].trim();
+      const parent = findParentNode(indent, indentStack);
+      if (!parent) {
+        pushError(
+          lineNumber,
+          "Metadata 'key: value' must be indented under a page \u2014 no page precedes it."
+        );
+      } else {
+        parent.metadata = { ...parent.metadata, [key]: value };
+      }
+    } else if (metadataMatch && indentStack.length === 0) {
+      if (indent === 0) {
+        const node = parseNodeLabel(
+          trimmed,
+          lineNumber,
+          palette,
+          ++nodeCounter,
+          metaAliasMap,
+          pushWarning,
+          result.diagnostics,
+          nameAliasMap
+        );
+        attachNode(node, indent, indentStack, result);
+        const key = normalizeName(node.label);
+        labelToNode.set(key, node);
+      } else {
+        pushError(
+          lineNumber,
+          "Metadata 'key: value' must be indented under a page \u2014 no page precedes it."
+        );
+      }
+    } else {
+      const descResult = tryStripDescriptionKeyword(trimmed);
+      if (descResult.isKeyword && !descResult.needsColon && indentStack.length > 0) {
+        const parent = findParentNode(indent, indentStack);
+        if (parent) {
+          parent.description = [
+            ...parent.description ?? [],
+            descResult.text.trim()
+          ];
+          continue;
+        }
+      }
+      const enclosingContainer = nestedPageInsideContainer(indent, indentStack);
+      if (enclosingContainer) {
+        pushError(
+          lineNumber,
+          `Pages inside container '[${enclosingContainer}]' cannot have indented sub-pages. Containers hold a flat list of pages.`
+        );
+        continue;
+      }
+      const node = parseNodeLabel(
+        trimmed,
+        lineNumber,
+        palette,
+        ++nodeCounter,
+        metaAliasMap,
+        pushWarning,
+        result.diagnostics,
+        nameAliasMap
+      );
+      attachNode(node, indent, indentStack, result);
+      const key = normalizeName(node.label);
+      labelToNode.set(key, node);
+    }
+  }
+  for (const arrow of deferredArrows) {
+    const aliasHit = nameAliasMap.get(arrow.targetLabel.trim());
+    if (aliasHit !== void 0) {
+      result.edges.push({
+        sourceId: arrow.sourceNode.id,
+        targetId: aliasHit,
+        ...arrow.label !== void 0 && { label: arrow.label },
+        lineNumber: arrow.lineNumber
+      });
+      continue;
+    }
+    const targetKey = normalizeName(arrow.targetLabel);
+    if (arrow.targetIsGroup) {
+      const targetContainer = labelToContainer.get(targetKey);
+      if (!targetContainer) {
+        const allLabels = Array.from(labelToContainer.keys());
+        let msg = `Group '[${arrow.targetLabel}]' not found`;
+        const hint = suggest(targetKey, allLabels);
+        if (hint) msg += `. ${hint}`;
+        pushError(arrow.lineNumber, msg);
+        continue;
+      }
+      result.edges.push({
+        sourceId: arrow.sourceNode.id,
+        targetId: targetContainer.id,
+        ...arrow.label !== void 0 && { label: arrow.label },
+        lineNumber: arrow.lineNumber
+      });
+    } else {
+      const targetNode = labelToNode.get(targetKey);
+      if (!targetNode) {
+        const allLabels = Array.from(labelToNode.keys());
+        let msg = `Arrow target "${arrow.targetLabel}" not found`;
+        const hint = suggest(targetKey, allLabels);
+        if (hint) msg += `. ${hint}`;
+        pushError(arrow.lineNumber, msg);
+        continue;
+      }
+      result.edges.push({
+        sourceId: arrow.sourceNode.id,
+        targetId: targetNode.id,
+        ...arrow.label !== void 0 && { label: arrow.label },
+        lineNumber: arrow.lineNumber
+      });
+    }
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  if (result.tagGroups.length > 0) {
+    const allNodes = [];
+    const collectAll = (nodes) => {
+      for (const node of nodes) {
+        allNodes.push(node);
+        collectAll(node.children);
+      }
+    };
+    collectAll(result.roots);
+    validateTagValues(allNodes, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning, pushError);
+  }
+  if (result.roots.length === 0 && result.tagGroups.length === 0 && !result.error) {
+    const diag = makeDgmoError(1, "No pages found in sitemap");
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+function parseNodeLabel(trimmed, lineNumber, _palette, counter, metaAliasMap = /* @__PURE__ */ new Map(), warnFn, _diagnostics, nameAliasMap) {
+  const registry = withTagAliases(
+    SITEMAP_REGISTRY,
+    new Set(metaAliasMap.keys())
+  );
+  const id = `node-${counter}`;
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    metaAliasMap,
+    void 0,
+    _diagnostics,
+    lineNumber
+  );
+  if (warnFn) {
+    warnUnknownMetaKeys(
+      split.meta,
+      registry,
+      (msg) => warnFn(lineNumber, msg),
+      split.name
+    );
+  }
+  const label = split.name;
+  if (split.alias) nameAliasMap?.set(normalizeName(split.alias), id);
+  const metadata = { ...split.meta };
+  if (split.color !== void 0) metadata["color"] = split.color;
+  let description;
+  if ("description" in metadata) {
+    const descVal = metadata["description"].trim();
+    if (descVal) {
+      description = [descVal];
+    }
+    delete metadata["description"];
+  }
+  return {
+    id,
+    label,
+    metadata,
+    ...description !== void 0 && { description },
+    children: [],
+    parentId: null,
+    isContainer: false,
+    lineNumber
+  };
+}
+function parseSitemapMetaTail(tail, metaAliasMap) {
+  const trimmed = tail.trim();
+  if (!trimmed?.includes(":")) return {};
+  const registry = withTagAliases(
+    SITEMAP_REGISTRY,
+    new Set(metaAliasMap.keys())
+  );
+  const split = splitNameAndMeta(
+    `color: __smph, ${trimmed}`,
+    registry,
+    metaAliasMap
+  );
+  const meta = split.meta;
+  if (meta["color"] === "__smph") delete meta["color"];
+  return meta;
+}
+function attachNode(node, indent, indentStack, result) {
+  while (indentStack.length > 0) {
+    const top = indentStack[indentStack.length - 1];
+    if (top.indent < indent) break;
+    indentStack.pop();
+  }
+  if (indentStack.length > 0) {
+    const parent = indentStack[indentStack.length - 1].node;
+    node.parentId = parent.id;
+    if (parent.isContainer && Object.keys(parent.metadata).length > 0 && !node.isContainer) {
+      node.metadata = { ...parent.metadata, ...node.metadata };
+    }
+    parent.children.push(node);
+  } else {
+    result.roots.push(node);
+  }
+  indentStack.push({ node, indent });
+}
+function nestedPageInsideContainer(indent, indentStack) {
+  let idx = indentStack.length - 1;
+  while (idx >= 0 && indentStack[idx].indent >= indent) idx--;
+  if (idx < 0) return null;
+  if (indentStack[idx].node.isContainer) return null;
+  for (let k = idx - 1; k >= 0; k--) {
+    if (indentStack[k].node.isContainer) return indentStack[k].node.label;
+  }
+  return null;
+}
+function findParentNode(indent, indentStack) {
+  for (let i = indentStack.length - 1; i >= 0; i--) {
+    if (indentStack[i].indent < indent) {
+      return indentStack[i].node;
+    }
+  }
+  if (indentStack.length > 0) {
+    return indentStack[indentStack.length - 1].node;
+  }
+  return null;
+}
+
+export {
+  looksLikeSitemap,
+  parseSitemap
+};
+//# sourceMappingURL=chunk-AN2MOO5T.js.map

package/dist/chunk-BMR4CIEO.js

@@ -0,0 +1,41 @@
+// src/utils/wrapped-desc.ts
+var BULLET_PREFIX = "\u2022 ";
+var BULLET_INDENT_CHARS = 2;
+function wrapDescriptionLines(lines, charsPerLine, lengthFn = (s) => s.length) {
+  const result = [];
+  for (const line of lines) {
+    if (!line.startsWith(BULLET_PREFIX)) {
+      const wrapped2 = wrapPlainLine(line, charsPerLine, lengthFn);
+      for (const w of wrapped2) result.push({ text: w, kind: "plain" });
+      continue;
+    }
+    const body = line.slice(BULLET_PREFIX.length);
+    const bodyLimit = Math.max(8, charsPerLine - BULLET_INDENT_CHARS);
+    const wrapped = wrapPlainLine(body, bodyLimit, lengthFn);
+    wrapped.forEach((w, i) => {
+      result.push({ text: w, kind: i === 0 ? "bullet-first" : "bullet-cont" });
+    });
+  }
+  return result;
+}
+function wrapPlainLine(line, charsPerLine, lengthFn) {
+  const words = line.split(/\s+/);
+  const result = [];
+  let current = "";
+  for (const word of words) {
+    const test = current ? `${current} ${word}` : word;
+    if (lengthFn(test) > charsPerLine && current) {
+      result.push(current);
+      current = word;
+    } else {
+      current = test;
+    }
+  }
+  if (current) result.push(current);
+  return result;
+}
+
+export {
+  wrapDescriptionLines
+};
+//# sourceMappingURL=chunk-BMR4CIEO.js.map

package/dist/chunk-BS7SV7C3.js

@@ -0,0 +1,51 @@
+// src/utils/collapse-engine/tree.ts
+function countDescendants(node, shape) {
+  let count = 0;
+  for (const child of shape.getChildren(node)) {
+    count += (shape.countsAsHidden(child) ? 1 : 0) + countDescendants(child, shape);
+  }
+  return count;
+}
+function computeHiddenCounts(nodes, collapsedIds, hiddenCounts, shape) {
+  for (const node of nodes) {
+    const children = shape.getChildren(node);
+    if (collapsedIds.has(shape.getId(node)) && children.length > 0) {
+      hiddenCounts.set(shape.getId(node), countDescendants(node, shape));
+    }
+    computeHiddenCounts(children, collapsedIds, hiddenCounts, shape);
+  }
+}
+function pruneCollapsed(node, collapsedIds, shape) {
+  for (const child of shape.getChildren(node)) {
+    pruneCollapsed(child, collapsedIds, shape);
+  }
+  if (collapsedIds.has(shape.getId(node)) && shape.getChildren(node).length > 0) {
+    shape.setChildren(node, []);
+  }
+}
+function collapseTree(roots, collapsedIds, shape) {
+  const hiddenCounts = /* @__PURE__ */ new Map();
+  computeHiddenCounts(roots, collapsedIds, hiddenCounts, shape);
+  const clonedRoots = roots.map((root) => shape.clone(root));
+  for (const root of clonedRoots) {
+    pruneCollapsed(root, collapsedIds, shape);
+  }
+  return { roots: clonedRoots, hiddenCounts };
+}
+function collectTreeIds(roots, shape) {
+  const ids = /* @__PURE__ */ new Set();
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      ids.add(shape.getId(node));
+      walk(shape.getChildren(node));
+    }
+  };
+  walk(roots);
+  return ids;
+}
+
+export {
+  collapseTree,
+  collectTreeIds
+};
+//# sourceMappingURL=chunk-BS7SV7C3.js.map