@diagrammo/dgmo 0.92.1 → 0.93.0

package/dist/chunk-NJJCTEBM.js

@@ -0,0 +1,416 @@
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  NOTE_GAP,
+  noteBoxSize,
+  noteConnectorPoints
+} from "./chunk-D6PVMUCX.js";
+import {
+  extractColor,
+  measureIndent
+} from "./chunk-TIIZIAGS.js";
+import {
+  makeDgmoError,
+  suggest
+} from "./chunk-BYU54C3S.js";
+
+// src/utils/notes/parse.ts
+function parseNoteHeader(rest) {
+  const t = rest.trim();
+  const quoted = t.match(/^"([^"]+)"\s*(.*)$/);
+  if (quoted) {
+    return { ref: quoted[1].trim(), inlineBody: quoted[2].trim() };
+  }
+  const m = t.match(/^(\S+)\s*(.*)$/);
+  if (m) {
+    return { ref: m[1], inlineBody: m[2].trim() };
+  }
+  return { ref: t, inlineBody: "" };
+}
+function collectNoteBody(lines, noteIndex, noteIndent, inlineBody) {
+  const parts = [];
+  if (inlineBody) parts.push(inlineBody);
+  let lastIndex = noteIndex;
+  let endLineNumber = noteIndex + 1;
+  for (let j = noteIndex + 1; j < lines.length; j++) {
+    const raw = lines[j];
+    const trimmed = raw.trim();
+    if (!trimmed) break;
+    if (measureIndent(raw) <= noteIndent) break;
+    parts.push(trimmed);
+    lastIndex = j;
+    endLineNumber = j + 1;
+  }
+  return { body: parts.join("\n"), endLineNumber, lastIndex };
+}
+function tryCollectNote(lines, index, indent, palette, diagnostics) {
+  const trimmed = lines[index].trim();
+  const m = trimmed.match(/^note\s+(.+)$/i);
+  if (!m || /^note\s+->/i.test(trimmed)) return null;
+  const lineNumber = index + 1;
+  const { label: headerNoColor, color } = extractColor(
+    m[1],
+    palette,
+    diagnostics,
+    lineNumber
+  );
+  const { ref, inlineBody } = parseNoteHeader(headerNoColor);
+  const collected = collectNoteBody(lines, index, indent, inlineBody);
+  if (!collected.body.trim()) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Note on "${ref}" has no text \u2014 ignored.`,
+        "warning"
+      )
+    );
+    return { lastIndex: collected.lastIndex };
+  }
+  return {
+    note: {
+      ref,
+      body: collected.body,
+      ...color && { color },
+      lineNumber,
+      endLineNumber: collected.endLineNumber
+    },
+    lastIndex: collected.lastIndex
+  };
+}
+
+// src/utils/notes/resolve.ts
+function resolveNotes(notes, targets, diagnostics) {
+  const byNodeId = /* @__PURE__ */ new Map();
+  if (notes.length === 0) return byNodeId;
+  const byNormLabel = /* @__PURE__ */ new Map();
+  for (const t of targets) {
+    const key = normalizeName(t.label);
+    const arr = byNormLabel.get(key);
+    if (arr) arr.push(t);
+    else byNormLabel.set(key, [t]);
+  }
+  for (const note of notes) {
+    const matches = byNormLabel.get(normalizeName(note.ref));
+    if (!matches || matches.length === 0) {
+      if (diagnostics) {
+        const hint = suggest(
+          note.ref,
+          targets.map((t) => t.label)
+        );
+        diagnostics.push(
+          makeDgmoError(
+            note.lineNumber,
+            `Note references unknown node id "${note.ref}".${hint ? " " + hint : ""}`,
+            "error"
+          )
+        );
+      }
+      continue;
+    }
+    const target = matches[0];
+    if (matches.length > 1 && diagnostics) {
+      diagnostics.push(
+        makeDgmoError(
+          note.lineNumber,
+          `Note ref "${note.ref}" matches ${matches.length} nodes; attaching to the first.`,
+          "warning"
+        )
+      );
+    }
+    if (byNodeId.has(target.id)) {
+      if (diagnostics) {
+        diagnostics.push(
+          makeDgmoError(
+            note.lineNumber,
+            `Multiple notes on node "${target.label}"; keeping the first.`,
+            "warning"
+          )
+        );
+      }
+      continue;
+    }
+    byNodeId.set(target.id, note);
+  }
+  return byNodeId;
+}
+
+// src/utils/notes/place.ts
+var NOTE_CLEAR = 14;
+var intersects = (a, b, pad) => !(a.right + pad <= b.left || b.right + pad <= a.left || a.bottom + pad <= b.top || b.bottom + pad <= a.top);
+var CONNECTOR_CLEAR = 4;
+var EDGE_CLEAR = 6;
+var SLIDE_STEP = 10;
+var SEARCH_REACH = 480;
+var segmentCrosses = (x1, y1, x2, y2, r) => {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const p = [-dx, dx, -dy, dy];
+  const q = [x1 - r.left, r.right - x1, y1 - r.top, r.bottom - y1];
+  let t0 = 0;
+  let t1 = 1;
+  for (let i = 0; i < 4; i++) {
+    const pi = p[i];
+    const qi = q[i];
+    if (pi === 0) {
+      if (qi <= 0) return false;
+      continue;
+    }
+    const t = qi / pi;
+    if (pi < 0) t0 = Math.max(t0, t);
+    else t1 = Math.min(t1, t);
+  }
+  return t0 < t1;
+};
+function placeNotes(obstacles, requests, direction, edges = []) {
+  const placements = /* @__PURE__ */ new Map();
+  const occupied = obstacles.map((p) => ({
+    left: p.x - p.width / 2,
+    top: p.y - p.height / 2,
+    right: p.x + p.width / 2,
+    bottom: p.y + p.height / 2
+  }));
+  for (const req of requests) {
+    if (req.collapsed) {
+      placements.set(req.key, {
+        collapsed: true,
+        side: "right",
+        x: 0,
+        y: 0
+      });
+      continue;
+    }
+    const p = req.node;
+    const cx = p.x;
+    const cy = p.y;
+    const nodeLeft = cx - p.width / 2;
+    const nodeRight = cx + p.width / 2;
+    const nodeTop = cy - p.height / 2;
+    const nodeBottom = cy + p.height / 2;
+    const { noteW, noteH } = req;
+    const rectFor = (side) => {
+      switch (side) {
+        case "right": {
+          const left = nodeRight + NOTE_GAP;
+          const top = cy - noteH / 2;
+          return { left, top, right: left + noteW, bottom: top + noteH };
+        }
+        case "left": {
+          const right = nodeLeft - NOTE_GAP;
+          const top = cy - noteH / 2;
+          return { left: right - noteW, top, right, bottom: top + noteH };
+        }
+        case "below": {
+          const left = cx - noteW / 2;
+          const top = nodeBottom + NOTE_GAP;
+          return { left, top, right: left + noteW, bottom: top + noteH };
+        }
+        case "above":
+        default: {
+          const left = cx - noteW / 2;
+          const bottom = nodeTop - NOTE_GAP;
+          return { left, top: bottom - noteH, right: left + noteW, bottom };
+        }
+      }
+    };
+    const order = direction === "LR" ? ["below", "above", "right", "left"] : ["right", "left", "below", "above"];
+    const anchor = {
+      left: nodeLeft,
+      top: nodeTop,
+      right: nodeRight,
+      bottom: nodeBottom
+    };
+    const isAnchor = (o) => o.left === anchor.left && o.top === anchor.top && o.right === anchor.right && o.bottom === anchor.bottom;
+    const connector = (rect, side) => {
+      const [x1, y1, x2, y2] = noteConnectorPoints(p, {
+        x: rect.left - cx,
+        y: rect.top - cy,
+        width: noteW,
+        height: noteH,
+        side
+      });
+      return [cx + x1, cy + y1, cx + x2, cy + y2];
+    };
+    const onEdge = (rect) => {
+      const padded = {
+        left: rect.left - EDGE_CLEAR,
+        top: rect.top - EDGE_CLEAR,
+        right: rect.right + EDGE_CLEAR,
+        bottom: rect.bottom + EDGE_CLEAR
+      };
+      return edges.some(
+        (path) => path.some(
+          (pt, i) => i > 0 && segmentCrosses(path[i - 1].x, path[i - 1].y, pt.x, pt.y, padded)
+        )
+      );
+    };
+    const isClear = (rect, side, avoidEdges) => {
+      if (occupied.some((o) => intersects(rect, o, NOTE_CLEAR))) return false;
+      if (avoidEdges && onEdge(rect)) return false;
+      const [x1, y1, x2, y2] = connector(rect, side);
+      return !occupied.some(
+        (o) => !isAnchor(o) && segmentCrosses(x1, y1, x2, y2, {
+          left: o.left - CONNECTOR_CLEAR,
+          top: o.top - CONNECTOR_CLEAR,
+          right: o.right + CONNECTOR_CLEAR,
+          bottom: o.bottom + CONNECTOR_CLEAR
+        })
+      );
+    };
+    const search = (avoidEdges) => {
+      let chosen2 = null;
+      for (const side of order.slice(0, 2)) {
+        const rect = rectFor(side);
+        if (isClear(rect, side, avoidEdges)) {
+          chosen2 = { rect, side };
+          break;
+        }
+      }
+      if (chosen2) return chosen2;
+      let bestLen = Infinity;
+      for (const side of order) {
+        const axisIsY = side === "above" || side === "below";
+        const outward = side === "below" || side === "right" ? 1 : -1;
+        const reach = axisIsY ? noteW / 2 : SEARCH_REACH;
+        const slides = [0];
+        for (let s = SLIDE_STEP; s <= reach; s += SLIDE_STEP) {
+          slides.push(s, -s);
+        }
+        const base = rectFor(side);
+        for (let out = 0; out <= SEARCH_REACH; out += NOTE_CLEAR) {
+          for (const slide of slides) {
+            const dx = axisIsY ? slide : out * outward;
+            const dy = axisIsY ? out * outward : slide;
+            const rect = {
+              left: base.left + dx,
+              top: base.top + dy,
+              right: base.right + dx,
+              bottom: base.bottom + dy
+            };
+            if (!isClear(rect, side, avoidEdges)) continue;
+            const [x1, y1, x2, y2] = connector(rect, side);
+            const len = Math.hypot(x2 - x1, y2 - y1);
+            if (len < bestLen) {
+              bestLen = len;
+              chosen2 = { rect, side };
+            }
+          }
+        }
+      }
+      return chosen2;
+    };
+    let chosen = search(true) ?? search(false);
+    if (!chosen) {
+      const side = order[0];
+      let rect = rectFor(side);
+      const axisIsY = side === "above" || side === "below";
+      const outward = side === "below" || side === "right" ? 1 : -1;
+      for (let guard = 0; guard < 50; guard++) {
+        const blockers = occupied.filter(
+          (o) => intersects(rect, o, NOTE_CLEAR)
+        );
+        if (blockers.length === 0) break;
+        if (axisIsY && outward > 0) {
+          const top = Math.max(...blockers.map((b) => b.bottom)) + NOTE_CLEAR;
+          rect = { ...rect, top, bottom: top + noteH };
+        } else if (axisIsY) {
+          const bottom = Math.min(...blockers.map((b) => b.top)) - NOTE_CLEAR;
+          rect = { ...rect, bottom, top: bottom - noteH };
+        } else if (outward > 0) {
+          const left = Math.max(...blockers.map((b) => b.right)) + NOTE_CLEAR;
+          rect = { ...rect, left, right: left + noteW };
+        } else {
+          const right = Math.min(...blockers.map((b) => b.left)) - NOTE_CLEAR;
+          rect = { ...rect, right, left: right - noteW };
+        }
+      }
+      chosen = { rect, side };
+    }
+    occupied.push(chosen.rect);
+    placements.set(req.key, {
+      collapsed: false,
+      side: chosen.side,
+      x: chosen.rect.left - p.x,
+      y: chosen.rect.top - p.y
+    });
+  }
+  return placements;
+}
+
+// src/utils/notes/build.ts
+function buildPlacedNotes(anchors, noteByNode, direction, collapsedNotes) {
+  const placed = /* @__PURE__ */ new Map();
+  if (noteByNode.size === 0) return placed;
+  const geoms = /* @__PURE__ */ new Map();
+  const requests = [];
+  for (const a of anchors) {
+    const note = noteByNode.get(a.id);
+    if (!note) continue;
+    const size = noteBoxSize(note.body);
+    geoms.set(a.id, {
+      noteW: size.width,
+      noteH: size.height,
+      ...note.color && { color: note.color },
+      lines: size.lines,
+      lineNumber: note.lineNumber,
+      endLineNumber: note.endLineNumber
+    });
+    requests.push({
+      key: a.id,
+      node: { x: a.x, y: a.y, width: a.width, height: a.height },
+      noteW: size.width,
+      noteH: size.height,
+      collapsed: collapsedNotes?.has(note.lineNumber) ?? false
+    });
+  }
+  const placements = placeNotes(
+    anchors.map((a) => ({ x: a.x, y: a.y, width: a.width, height: a.height })),
+    requests,
+    direction
+  );
+  for (const [id, g] of geoms) {
+    const p = placements.get(id);
+    placed.set(
+      id,
+      p.collapsed ? {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        side: "right",
+        ...g.color && { color: g.color },
+        lines: [],
+        lineNumber: g.lineNumber,
+        endLineNumber: g.endLineNumber,
+        collapsed: true
+      } : {
+        x: p.x,
+        y: p.y,
+        width: g.noteW,
+        height: g.noteH,
+        side: p.side,
+        ...g.color && { color: g.color },
+        lines: g.lines,
+        lineNumber: g.lineNumber,
+        endLineNumber: g.endLineNumber
+      }
+    );
+  }
+  return placed;
+}
+
+// src/utils/notes/bounds.ts
+function noteCanvasShift(minX, minY, margin = 20) {
+  return {
+    shiftX: minX < 0 ? margin - minX : 0,
+    shiftY: minY < 0 ? margin - minY : 0
+  };
+}
+
+export {
+  tryCollectNote,
+  resolveNotes,
+  placeNotes,
+  buildPlacedNotes,
+  noteCanvasShift
+};

package/dist/{chunk-OQW4ETJX.js → chunk-NM5V5EKY.js}

@@ -1,3 +1,6 @@
+import {
+  extractPaletteDirective
+} from "./chunk-CYTFO2LF.js";
 import {
   RING_REGISTRY,
   measureIndent,
@@ -30,7 +33,9 @@ function parseRing(content) {
     diagnostics: [],
     error: null
   };
-  const lines = content.split("\n");
+  const directive = extractPaletteDirective(content);
+  result.diagnostics.push(...directive.diagnostics);
+  const lines = directive.content.split("\n");
   let headerParsed = false;
   let currentLayer = null;
   const fail = makeFail(result);

package/dist/{chunk-ONYO5WJW.js → chunk-NMK7KJZZ.js}

@@ -1,44 +1,44 @@
 import {
   layoutERDiagram
-} from "./chunk-MXAP37W6.js";
+} from "./chunk-TNV4F5WA.js";
 import {
-  NOTE_BADGE_RADIUS,
-  noteConnectorPoints,
-  renderNoteBadge,
-  renderNoteBox,
-  renderNoteConnector
-} from "./chunk-JRWUHLRP.js";
+  serializeSvg
+} from "./chunk-CYRB2JTN.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
 import {
-  renderIntegratedLegend
-} from "./chunk-NMS5XSLX.js";
+  layoutInlineHeader
+} from "./chunk-42UJ23H3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-VLC6WNRD.js";
 import {
   EDGE_LABEL_KNOCKOUT_OPACITY,
   EDGE_STROKE_WIDTH,
   NODE_STROKE_WIDTH
 } from "./chunk-XCKNFFKM.js";
 import {
-  layoutInlineHeader
-} from "./chunk-42UJ23H3.js";
-import {
-  serializeSvg
-} from "./chunk-CYRB2JTN.js";
+  renderIntegratedLegend
+} from "./chunk-NMS5XSLX.js";
 import {
   getLegendExtent
 } from "./chunk-JILEYZ2V.js";
 import {
-  TITLE_FONT_SIZE,
-  TITLE_FONT_WEIGHT,
-  TITLE_Y
-} from "./chunk-VLC6WNRD.js";
+  parseERDiagram
+} from "./chunk-Q7Y6JQ3R.js";
+import {
+  NOTE_BADGE_RADIUS,
+  noteConnectorPoints,
+  renderNoteBadge,
+  renderNoteBox,
+  renderNoteConnector
+} from "./chunk-D6PVMUCX.js";
 import {
   FONT_FAMILY
 } from "./chunk-ICLB27PZ.js";
-import {
-  parseERDiagram
-} from "./chunk-DRFGIOZ6.js";
 import {
   resolveTagColor,
   tagAttrKey

package/dist/{chunk-6BNNLVAR.js → chunk-NPDVWFAQ.js}

@@ -1,3 +1,6 @@
+import {
+  extractPaletteDirective
+} from "./chunk-CYTFO2LF.js";
 import {
   CYCLE_REGISTRY,
   measureIndent,
@@ -27,7 +30,9 @@ function parseCycle(content) {
     diagnostics: [],
     error: null
   };
-  const lines = content.split("\n");
+  const directive = extractPaletteDirective(content);
+  result.diagnostics.push(...directive.diagnostics);
+  const lines = directive.content.split("\n");
   let headerParsed = false;
   let state = "top";
   let currentNode = null;