@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-RVMRZAPB.js

@@ -0,0 +1,354 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  isTagBlockHeading,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  OPTION_NOCOLON_RE,
+  ORG_REGISTRY,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/org/parser.ts
+var CONTAINER_RE = /^\[([^\]]+)\]$/;
+var METADATA_RE = /^([^:]+):\s*(.+)$/;
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set([
+  "sub-node-label",
+  "hide",
+  "show-sub-node-count",
+  "active-tag"
+]);
+var KNOWN_BOOLEANS = /* @__PURE__ */ new Set([
+  "show-sub-node-count",
+  "direction-tb",
+  "solid-fill",
+  "no-title"
+]);
+function looksLikeOrg(content) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (isTagBlockHeading(trimmed)) return true;
+  }
+  return false;
+}
+function parseOrg(content, palette) {
+  const options = {};
+  const result = {
+    title: null,
+    titleLineNumber: null,
+    roots: [],
+    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 currentTagGroup = null;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  const indentStack = [];
+  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 (!contentStarted) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine) {
+        if (firstLine.chartType !== "org") {
+          const allTypes = [
+            "org",
+            "class",
+            "flowchart",
+            "sequence",
+            "er",
+            "bar",
+            "line",
+            "pie",
+            "scatter",
+            "sankey",
+            "venn",
+            "timeline",
+            "arc",
+            "slope"
+          ];
+          let msg = `Expected chart type "org", got "${firstLine.chartType}"`;
+          const hint = suggest(firstLine.chartType, allTypes);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        if (firstLine.title) {
+          result.title = firstLine.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      if (contentStarted) {
+        pushError(lineNumber, "Tag groups must appear before org content");
+        continue;
+      }
+      currentTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      if (tagBlockMatch.alias) {
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.alias),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      metaAliasMap.set(
+        normalizeName(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      result.tagGroups.push(currentTagGroup);
+      continue;
+    }
+    if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].trim().toLowerCase();
+        if (KNOWN_OPTIONS.has(key)) {
+          options[key] = optMatch[2].trim();
+          continue;
+        }
+      }
+      if (KNOWN_BOOLEANS.has(trimmed.toLowerCase())) {
+        options[trimmed.toLowerCase()] = "on";
+        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
+        );
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    const indent = measureIndent(line);
+    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;
+      containerCounter++;
+      const containerId = `container-${containerCounter}`;
+      if (asMatch) nameAliasMap.set(asMatch[2], containerId);
+      const node = {
+        id: containerId,
+        label,
+        metadata: {},
+        children: [],
+        parentId: null,
+        isContainer: true,
+        lineNumber
+      };
+      attachNode(node, indent, indentStack, result);
+    } 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 = findMetadataParent(indent, indentStack);
+      if (!parent) {
+        pushError(
+          lineNumber,
+          "Metadata 'key: value' must be indented under a node \u2014 no node precedes it."
+        );
+      } else {
+        parent.metadata = { ...parent.metadata, [key]: value };
+      }
+    } else if (metadataMatch && indentStack.length === 0) {
+      if (indent === 0) {
+        const node = parseNodeLabel(
+          trimmed,
+          indent,
+          lineNumber,
+          palette,
+          ++nodeCounter,
+          metaAliasMap,
+          result.diagnostics,
+          nameAliasMap
+        );
+        attachNode(node, indent, indentStack, result);
+      } else {
+        pushError(
+          lineNumber,
+          "Metadata 'key: value' must be indented under a node \u2014 no node precedes it."
+        );
+      }
+    } else {
+      const node = parseNodeLabel(
+        trimmed,
+        indent,
+        lineNumber,
+        palette,
+        ++nodeCounter,
+        metaAliasMap,
+        result.diagnostics,
+        nameAliasMap
+      );
+      attachNode(node, indent, indentStack, result);
+    }
+  }
+  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 nodes found in org chart");
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+function parseNodeLabel(trimmed, _indent, lineNumber, _palette, counter, metaAliasMap = /* @__PURE__ */ new Map(), diagnostics, nameAliasMap) {
+  const registry = withTagAliases(ORG_REGISTRY, new Set(metaAliasMap.keys()));
+  const id = `node-${counter}`;
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    metaAliasMap,
+    void 0,
+    diagnostics,
+    lineNumber
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => diagnostics?.push(makeDgmoError(lineNumber, msg, "warning")),
+    split.name
+  );
+  const label = split.color !== void 0 ? `${split.name} ${split.color}` : split.name;
+  if (split.alias) {
+    nameAliasMap?.set(normalizeName(split.alias), id);
+  }
+  const metadata = { ...split.meta };
+  return {
+    id,
+    label,
+    metadata,
+    children: [],
+    parentId: null,
+    isContainer: false,
+    lineNumber
+  };
+}
+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;
+    parent.children.push(node);
+  } else {
+    result.roots.push(node);
+  }
+  indentStack.push({ node, indent });
+}
+function findMetadataParent(indent, indentStack) {
+  for (let i = indentStack.length - 1; i >= 0; i--) {
+    const entry = indentStack[i];
+    if (entry.indent < indent) {
+      return entry.node;
+    }
+  }
+  if (indentStack.length > 0) {
+    return indentStack[indentStack.length - 1].node;
+  }
+  return null;
+}
+
+export {
+  looksLikeOrg,
+  parseOrg
+};
+//# sourceMappingURL=chunk-RVMRZAPB.js.map