@diagrammo/dgmo 0.48.1 → 0.49.0

package/dist/chunk-4YNP6O47.js

@@ -0,0 +1,607 @@
+import {
+  SKETCH_DIAGNOSTIC_CODES
+} from "./chunk-XHVV4NVW.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  injectDefaultTagMetadata,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-HBVD67XG.js";
+import {
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  SKETCH_REGISTRY,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  stripQuotes,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-ZNQX6QWH.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/sketch/types.ts
+var SKETCH_SHAPE_KINDS = [
+  "rectangle",
+  "database",
+  "queue",
+  "person",
+  "document",
+  "note"
+];
+function isSketchShapeKind(value) {
+  return SKETCH_SHAPE_KINDS.includes(value);
+}
+
+// src/sketch/parser.ts
+var EDGE_FORMS = [
+  { re: /^<-(.+?)->\s*(.+)$/, heads: "both", dashed: false, labeled: true },
+  { re: /^<~(.+?)~>\s*(.+)$/, heads: "both", dashed: true, labeled: true },
+  { re: /^<->\s*(.+)$/, heads: "both", dashed: false, labeled: false },
+  { re: /^<~>\s*(.+)$/, heads: "both", dashed: true, labeled: false },
+  { re: /^-(.+?)->\s*(.+)$/, heads: "one", dashed: false, labeled: true },
+  { re: /^~(.+?)~>\s*(.+)$/, heads: "one", dashed: true, labeled: true },
+  { re: /^->\s*(.+)$/, heads: "one", dashed: false, labeled: false },
+  { re: /^~>\s*(.+)$/, heads: "one", dashed: true, labeled: false },
+  { re: /^--\s+(.+)$/, heads: "none", dashed: false, labeled: false },
+  { re: /^~~\s+(.+)$/, heads: "none", dashed: true, labeled: false },
+  { re: /^-(.+?)-\s+(.+)$/, heads: "none", dashed: false, labeled: true },
+  { re: /^~(.+?)~\s+(.+)$/, heads: "none", dashed: true, labeled: true }
+];
+var EDGE_START_RE = /^[<\-~]/;
+var LEFT_ARROW_RE = /^<[-~](?![-~]?>)/;
+var BOX_RE = /^\[([^\]]*)\]\s*(.*)$/;
+var BOX_TAIL_ALIAS_RE = /^as\s+([A-Za-z][A-Za-z0-9_]{0,11})(?=\s|,|$)\s*,?\s*/;
+var AT_VALUE_RE = /^(-?\d+)\s+(-?\d+)$/;
+function parseSketch(content, palette) {
+  const options = {
+    noLegend: false,
+    solidFill: false,
+    noDescriptions: false
+  };
+  const result = {
+    type: "sketch",
+    title: null,
+    titleLineNumber: null,
+    nodes: [],
+    edges: [],
+    boxes: [],
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const pushError = (line, message, code) => {
+    result.diagnostics.push(makeDgmoError(line, message, "error", code));
+  };
+  const warn = (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");
+  const nodes = [];
+  const boxes = [];
+  const nodeById = /* @__PURE__ */ new Map();
+  const aliasIndex = /* @__PURE__ */ new Map();
+  const labelIndex = /* @__PURE__ */ new Map();
+  const boxByNorm = /* @__PURE__ */ new Map();
+  const pendingEdges = [];
+  const tagAliasMap = /* @__PURE__ */ new Map();
+  let idCounter = 0;
+  const registryFor = () => withTagAliases(SKETCH_REGISTRY, new Set(tagAliasMap.keys()));
+  const parseAt = (raw, lineNumber) => {
+    if (raw === void 0) return null;
+    const m = raw.trim().match(AT_VALUE_RE);
+    if (!m) {
+      warn(
+        lineNumber,
+        `Invalid at: value "${raw}" \u2014 expected two integers (at: C R); shape will flow-place`
+      );
+      return null;
+    }
+    return { c: parseInt(m[1], 10), r: parseInt(m[2], 10) };
+  };
+  const liftReserved = (meta, lineNumber) => {
+    let shape = "rectangle";
+    const shapeRaw = meta["shape"];
+    if (shapeRaw !== void 0) {
+      const kind = shapeRaw.trim().toLowerCase();
+      if (kind === "rectangle" || isSketchShapeKind(kind)) {
+        shape = kind;
+      } else {
+        warn(
+          lineNumber,
+          `Unknown shape "${shapeRaw}" \u2014 rendered as a rectangle (valid: database, queue, person, document, note)`,
+          SKETCH_DIAGNOSTIC_CODES.UNKNOWN_SHAPE
+        );
+      }
+      delete meta["shape"];
+    }
+    const at = parseAt(meta["at"], lineNumber);
+    delete meta["at"];
+    delete meta["collapsed"];
+    return { shape, at };
+  };
+  const addShape = (trimmed, lineNumber, box) => {
+    const snm = splitNameAndMeta(
+      trimmed,
+      registryFor(),
+      tagAliasMap,
+      palette,
+      result.diagnostics,
+      lineNumber
+    );
+    let label = stripQuotes(snm.name.trim()).trim();
+    if (snm.color) label = `${label} ${snm.color}`.trim();
+    if (!label) {
+      warn(lineNumber, `Shape line has no name \u2014 ignored`);
+      return null;
+    }
+    const meta = { ...snm.meta };
+    warnUnknownMetaKeys(
+      meta,
+      registryFor(),
+      (m) => warn(lineNumber, m),
+      snm.name
+    );
+    const { shape, at } = liftReserved(meta, lineNumber);
+    const norm = normalizeName(label);
+    if (snm.alias !== void 0 && aliasIndex.has(snm.alias)) {
+      warn(
+        lineNumber,
+        `Duplicate alias "${snm.alias}" \u2014 the first declaration keeps it`
+      );
+    }
+    const alias = snm.alias !== void 0 && !aliasIndex.has(snm.alias) ? snm.alias : void 0;
+    if (alias === void 0 && snm.alias === void 0) {
+      const existing = labelIndex.get(norm);
+      if (existing && existing.length > 0) {
+        const first = nodeById.get(existing[0]);
+        for (const [k, v] of Object.entries(meta)) {
+          if (!(k in first.metadata)) first.metadata[k] = v;
+        }
+        if (first.at === null && at !== null) first.at = at;
+        if (first.shape === "rectangle" && shape !== "rectangle") {
+          first.shape = shape;
+        }
+        warn(
+          lineNumber,
+          nameMergedMessage({
+            incomingDisplay: label,
+            incomingLine: lineNumber,
+            existingDisplay: first.label,
+            existingLine: first.lineNumber
+          }),
+          NAME_DIAGNOSTIC_CODES.NAME_MERGED
+        );
+        return first;
+      }
+    }
+    const id = `sketch-node-${++idCounter}`;
+    const node = {
+      id,
+      label,
+      ...alias !== void 0 && { alias },
+      shape,
+      at,
+      metadata: meta,
+      ...box !== null && { boxLabel: box.label },
+      lineNumber
+    };
+    nodes.push(node);
+    nodeById.set(id, node);
+    if (alias !== void 0) aliasIndex.set(alias, id);
+    const list = labelIndex.get(norm);
+    if (list) list.push(id);
+    else labelIndex.set(norm, [id]);
+    if (box !== null) box.children.push(id);
+    return node;
+  };
+  const parseBoxTail = (tail, lineNumber) => {
+    let rest = tail.trim();
+    let alias;
+    const aliasMatch = rest.match(BOX_TAIL_ALIAS_RE);
+    if (aliasMatch) {
+      alias = aliasMatch[1];
+      rest = rest.slice(aliasMatch[0].length);
+    }
+    let collapsed = false;
+    rest = rest.replace(/(^|,|\s)collapsed(?=\s|,|$)/i, (_m, pre) => {
+      collapsed = true;
+      return pre === "," ? "," : pre;
+    });
+    const meta = {};
+    let at = null;
+    for (const seg of rest.split(",")) {
+      const t = seg.trim();
+      if (!t) continue;
+      const colonIdx = t.indexOf(":");
+      if (colonIdx < 0) {
+        warn(lineNumber, `Unrecognized box metadata "${t}" \u2014 ignored`);
+        continue;
+      }
+      const rawKey = t.slice(0, colonIdx).trim().toLowerCase();
+      const value = t.slice(colonIdx + 1).trim();
+      if (rawKey === "at") {
+        at = parseAt(value, lineNumber);
+      } else if (value) {
+        meta[tagAliasMap.get(rawKey) ?? rawKey] = value;
+      }
+    }
+    return { ...alias !== void 0 && { alias }, at, collapsed, meta };
+  };
+  const openBox = (label, tail, lineNumber) => {
+    const norm = normalizeName(label);
+    const existing = boxByNorm.get(norm);
+    const { alias, at, collapsed, meta } = parseBoxTail(tail, lineNumber);
+    if (existing) {
+      warn(
+        lineNumber,
+        `Box "${label}" already declared on line ${existing.lineNumber} \u2014 shapes are added to it`
+      );
+      return existing;
+    }
+    const box = {
+      id: `[${norm}]`,
+      label: label.trim(),
+      ...alias !== void 0 && { alias },
+      at,
+      metadata: meta,
+      collapsed,
+      children: [],
+      lineNumber
+    };
+    boxes.push(box);
+    boxByNorm.set(norm, box);
+    if (alias !== void 0) {
+      if (aliasIndex.has(alias)) {
+        warn(
+          lineNumber,
+          `Duplicate alias "${alias}" \u2014 the first declaration keeps it`
+        );
+      } else {
+        aliasIndex.set(alias, box.id);
+      }
+    }
+    return box;
+  };
+  const addEdge = (trimmed, lineNumber, sourceId) => {
+    for (const form of EDGE_FORMS) {
+      const m = trimmed.match(form.re);
+      if (!m) continue;
+      let label;
+      let targetRegion;
+      if (form.labeled) {
+        const labelResult = parseInArrowLabel(m[1], lineNumber);
+        result.diagnostics.push(...labelResult.diagnostics);
+        label = labelResult.label;
+        targetRegion = m[2];
+      } else {
+        targetRegion = m[1];
+      }
+      const snm = splitNameAndMeta(
+        targetRegion.trim(),
+        registryFor(),
+        tagAliasMap,
+        palette,
+        result.diagnostics,
+        lineNumber,
+        { peelAlias: false }
+      );
+      let targetRaw = snm.name.trim();
+      if (snm.color) targetRaw = `${targetRaw} ${snm.color}`.trim();
+      const meta = { ...snm.meta };
+      delete meta["at"];
+      delete meta["shape"];
+      warnUnknownMetaKeys(meta, registryFor(), (msg) => warn(lineNumber, msg));
+      if (!targetRaw) {
+        warn(lineNumber, `Edge has no target \u2014 ignored`);
+        return;
+      }
+      pendingEdges.push({
+        sourceId,
+        targetRaw,
+        ...label !== void 0 && { label },
+        heads: form.heads,
+        dashed: form.dashed,
+        metadata: meta,
+        lineNumber
+      });
+      return;
+    }
+    if (LEFT_ARROW_RE.test(trimmed)) {
+      pushError(
+        lineNumber,
+        `Left-pointing arrows are not supported \u2014 write the edge from the other side (B -> A instead of A <- B)`
+      );
+      return;
+    }
+    warn(lineNumber, `Malformed edge "${trimmed}" \u2014 ignored`);
+  };
+  let firstLineConsumed = false;
+  let contentStarted = false;
+  let currentTagGroup = null;
+  let currentBox = null;
+  let currentShape = null;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    const indent = measureIndent(raw);
+    if (!firstLineConsumed) {
+      firstLineConsumed = true;
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine?.chartType !== "sketch") {
+        let msg = `Expected chart type "sketch", got "${firstLine?.chartType ?? trimmed.split(/\s+/)[0]}"`;
+        const hint = suggest(firstLine?.chartType ?? "", ["sketch"]);
+        if (hint) msg += `. ${hint}`;
+        return fail(lineNumber, msg);
+      }
+      result.title = firstLine.title ?? null;
+      result.titleLineNumber = lineNumber;
+      continue;
+    }
+    if (indent === 0) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        if (contentStarted) {
+          pushError(
+            lineNumber,
+            "Tag groups must appear before sketch content",
+            "E_TAG_DECLARED_AFTER_CONTENT"
+          );
+          continue;
+        }
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        if (tagBlockMatch.alias) {
+          tagAliasMap.set(
+            tagBlockMatch.alias.toLowerCase(),
+            tagAttrKey(tagBlockMatch.name)
+          );
+        }
+        tagAliasMap.set(
+          tagAttrKey(tagBlockMatch.name),
+          tagAttrKey(tagBlockMatch.name)
+        );
+        if (tagBlockMatch.inlineValues) {
+          for (const entry of tagBlockMatch.inlineValues) {
+            const { text: cleanEntry, isDefault } = stripDefaultModifier(entry);
+            const { label, color } = extractColor(
+              cleanEntry,
+              palette,
+              result.diagnostics,
+              lineNumber
+            );
+            if (isDefault) currentTagGroup.defaultValue = label;
+            currentTagGroup.entries.push({
+              value: label,
+              color: color ?? AUTO_TAG_COLOR_SENTINEL,
+              lineNumber
+            });
+          }
+        }
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+    }
+    if (currentTagGroup && indent > 0) {
+      const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        cleanEntry,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      if (isDefault) currentTagGroup.defaultValue = label;
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber
+      });
+      continue;
+    }
+    currentTagGroup = null;
+    if (indent === 0 && /^no-legend\s*$/i.test(trimmed)) {
+      options.noLegend = true;
+      continue;
+    }
+    if (indent === 0 && /^solid-fill\s*$/i.test(trimmed)) {
+      options.solidFill = true;
+      continue;
+    }
+    if (indent === 0 && /^no-descriptions\s*$/i.test(trimmed)) {
+      options.noDescriptions = true;
+      continue;
+    }
+    contentStarted = true;
+    if (trimmed.startsWith(">")) {
+      const descLine = trimmed.slice(1).replace(/^ /, "");
+      if (indent > 0 && currentShape && indent > currentShape.indent) {
+        const node2 = nodeById.get(currentShape.id);
+        if (node2) {
+          node2.description = node2.description === void 0 ? descLine : `${node2.description}
+${descLine}`;
+        }
+      } else {
+        warn(
+          lineNumber,
+          `Description "${trimmed}" has no shape \u2014 indent it under the shape it describes`
+        );
+      }
+      continue;
+    }
+    if (EDGE_START_RE.test(trimmed)) {
+      if (indent > 0 && currentShape && indent > currentShape.indent) {
+        addEdge(trimmed, lineNumber, currentShape.id);
+      } else if (indent > 0 && currentBox && indent > currentBox.indent) {
+        addEdge(trimmed, lineNumber, currentBox.box.id);
+      } else {
+        warn(
+          lineNumber,
+          `Edge "${trimmed}" has no source shape \u2014 indent it under the shape it leaves from`
+        );
+      }
+      continue;
+    }
+    const boxMatch = trimmed.match(BOX_RE);
+    if (boxMatch) {
+      const label = boxMatch[1].trim();
+      if (!label) {
+        warn(lineNumber, "Box has no label \u2014 ignored");
+        continue;
+      }
+      if (indent > 0 && currentBox && indent > currentBox.indent) {
+        pushError(
+          lineNumber,
+          `Box "${label}" is nested inside "${currentBox.box.label}" \u2014 sketch boxes are one level only; its shapes join the outer box`,
+          SKETCH_DIAGNOSTIC_CODES.NESTED_BOX
+        );
+        continue;
+      }
+      currentBox = {
+        box: openBox(label, boxMatch[2] ?? "", lineNumber),
+        indent
+      };
+      currentShape = null;
+      continue;
+    }
+    if (indent === 0) {
+      currentBox = null;
+      const node2 = addShape(trimmed, lineNumber, null);
+      currentShape = node2 ? { id: node2.id, indent } : null;
+      continue;
+    }
+    if (currentBox && indent > currentBox.indent) {
+      const node2 = addShape(trimmed, lineNumber, currentBox.box);
+      currentShape = node2 ? { id: node2.id, indent } : currentShape;
+      continue;
+    }
+    warn(
+      lineNumber,
+      `Indented line "${trimmed}" has no parent box \u2014 treated as a top-level shape`
+    );
+    const node = addShape(trimmed, lineNumber, null);
+    currentShape = node ? { id: node.id, indent } : currentShape;
+  }
+  const allTargets = [
+    ...aliasIndex.keys(),
+    ...nodes.map((n) => n.label),
+    ...boxes.map((b) => b.label)
+  ];
+  for (const pe of pendingEdges) {
+    let targetId;
+    const bracketMatch = pe.targetRaw.match(/^\[([^\]]*)\]$/);
+    if (bracketMatch) {
+      targetId = boxByNorm.get(normalizeName(bracketMatch[1]))?.id ?? null;
+    } else if (aliasIndex.has(pe.targetRaw)) {
+      targetId = aliasIndex.get(pe.targetRaw);
+    } else {
+      const norm = normalizeName(stripQuotes(pe.targetRaw).trim());
+      const labelHits = labelIndex.get(norm) ?? [];
+      if (labelHits.length > 1) {
+        pushError(
+          pe.lineNumber,
+          `Edge target "${pe.targetRaw}" matches more than one shape \u2014 give each duplicate an alias (as x) and target the alias`,
+          SKETCH_DIAGNOSTIC_CODES.AMBIGUOUS_TARGET
+        );
+        continue;
+      }
+      targetId = labelHits[0] ?? boxByNorm.get(norm)?.id ?? null;
+    }
+    if (targetId === null) {
+      let msg = `Unknown edge target "${pe.targetRaw}"`;
+      const hint = suggest(pe.targetRaw, allTargets);
+      if (hint) msg += `. ${hint}`;
+      warn(pe.lineNumber, msg);
+      continue;
+    }
+    if (targetId === pe.sourceId) {
+      warn(pe.lineNumber, `Edge from "${pe.targetRaw}" to itself \u2014 ignored`);
+      continue;
+    }
+    result.edges.push({
+      sourceId: pe.sourceId,
+      targetId,
+      ...pe.label !== void 0 && { label: pe.label },
+      heads: pe.heads,
+      dashed: pe.dashed,
+      metadata: pe.metadata,
+      lineNumber: pe.lineNumber
+    });
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  if (result.tagGroups.length > 0) {
+    const tagKeys = result.tagGroups.map((g) => tagAttrKey(g.name));
+    for (const box of boxes) {
+      for (const childId of box.children) {
+        const child = nodeById.get(childId);
+        if (!child) continue;
+        for (const k of tagKeys) {
+          if (!(k in child.metadata) && box.metadata[k] !== void 0) {
+            child.metadata[k] = box.metadata[k];
+          }
+        }
+      }
+    }
+    injectDefaultTagMetadata(
+      [...nodes, ...boxes],
+      result.tagGroups
+    );
+    validateTagValues(
+      [...nodes, ...boxes, ...result.edges],
+      result.tagGroups,
+      (line, message) => warn(line, message),
+      suggest
+    );
+    validateTagGroupNames(
+      result.tagGroups,
+      (line, message) => warn(line, message)
+    );
+  }
+  result.nodes = nodes;
+  result.boxes = boxes;
+  if (nodes.length === 0 && boxes.length === 0 && !result.error) {
+    const diag = makeDgmoError(1, "No shapes found in sketch");
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+
+export {
+  SKETCH_SHAPE_KINDS,
+  isSketchShapeKind,
+  parseSketch
+};
+//# sourceMappingURL=chunk-4YNP6O47.js.map

package/dist/{chunk-3MQQNXPD.js → chunk-5FGDJIJX.js}

@@ -1,6 +1,6 @@
 import {
   tryCollectNote
-} from "./chunk-5MLYVTYM.js";
+} from "./chunk-K6HNAY5V.js";
 import {
   resolveNotes
 } from "./chunk-FMDSF3OV.js";
@@ -17,7 +17,7 @@ import {
   measureIndent,
   parseFirstLine,
   tryParseSharedOption
-} from "./chunk-Y3J7VR52.js";
+} from "./chunk-ZNQX6QWH.js";
 import {
   resolveColorWithDiagnostic
 } from "./chunk-TLVIHFRO.js";
@@ -412,4 +412,4 @@ export {
   parseState,
   looksLikeState
 };
-//# sourceMappingURL=chunk-3MQQNXPD.js.map
+//# sourceMappingURL=chunk-5FGDJIJX.js.map

package/dist/{chunk-WCT3NYCV.js → chunk-5LWQH6QV.js}

@@ -157,4 +157,4 @@ export {
   truncateText,
   wrapTextToWidth
 };
-//# sourceMappingURL=chunk-WCT3NYCV.js.map
+//# sourceMappingURL=chunk-5LWQH6QV.js.map