@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-T3UBLACL.js

@@ -0,0 +1,299 @@
+import {
+  noteCanvasShift,
+  placeNotes
+} from "./chunk-6EK55ART.js";
+import {
+  noteBoxSize
+} from "./chunk-TYS6CSS5.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+
+// src/graph/layout.ts
+import dagre from "@dagrejs/dagre";
+var GROUP_PADDING = 20;
+function computeNodeWidth(label, shape) {
+  if (shape === "pseudostate") return 24;
+  const base = Math.max(120, label.length * 9 + 40);
+  if (shape === "subroutine") return base + 10;
+  return base;
+}
+function computeNodeHeight(shape) {
+  if (shape === "pseudostate") return 24;
+  return shape === "decision" ? 60 : 50;
+}
+function layoutGraph(graph, options) {
+  const collapsedChildCounts = options?.collapsedChildCounts;
+  const originalGroups = options?.originalGroups;
+  const collapsedNotes = options?.collapsedNotes;
+  const collapsedGroupNodes = [];
+  if (collapsedChildCounts && originalGroups) {
+    for (const group of originalGroups) {
+      if (collapsedChildCounts.has(group.id)) {
+        const count = collapsedChildCounts.get(group.id);
+        collapsedGroupNodes.push({
+          id: group.id,
+          label: `${group.label} (${count} state${count !== 1 ? "s" : ""})`,
+          shape: "state",
+          lineNumber: group.lineNumber,
+          ...group.color && { color: group.color }
+        });
+      }
+    }
+  }
+  const allNodes = [...graph.nodes, ...collapsedGroupNodes];
+  if (allNodes.length === 0) {
+    return { nodes: [], edges: [], groups: [], width: 0, height: 0 };
+  }
+  const g = new dagre.graphlib.Graph({ compound: true });
+  g.setGraph({
+    rankdir: graph.direction,
+    nodesep: 50,
+    ranksep: 60,
+    edgesep: 20
+  });
+  g.setDefaultEdgeLabel(() => ({}));
+  const nodeDataMap = /* @__PURE__ */ new Map();
+  for (const node of allNodes) {
+    nodeDataMap.set(node.id, node);
+  }
+  if (graph.groups) {
+    for (const group of graph.groups) {
+      g.setNode(group.id, {
+        label: group.label,
+        clusterLabelPos: "top"
+      });
+    }
+  }
+  const notesSuppressed = graph.options?.["no-notes"] === "on";
+  const noteByNode = notesSuppressed || !graph.notes ? /* @__PURE__ */ new Map() : resolveNotes(graph.notes, graph.nodes);
+  const noteGeoms = /* @__PURE__ */ new Map();
+  for (const node of allNodes) {
+    const width = computeNodeWidth(node.label, node.shape);
+    const height = computeNodeHeight(node.shape);
+    g.setNode(node.id, { label: node.label, width, height });
+    const note = noteByNode.get(node.id);
+    if (note) {
+      const size = noteBoxSize(note.body);
+      noteGeoms.set(node.id, {
+        noteW: size.width,
+        noteH: size.height,
+        ...note.color && { color: note.color },
+        lines: size.lines,
+        lineNumber: note.lineNumber,
+        endLineNumber: note.endLineNumber
+      });
+    }
+    if (node.group && graph.groups?.some((gr) => gr.id === node.group)) {
+      g.setParent(node.id, node.group);
+    }
+  }
+  const edgeDataMap = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const key = `${edge.source}->${edge.target}`;
+    edgeDataMap.set(key, edge);
+    g.setEdge(edge.source, edge.target, {
+      label: edge.label ?? ""
+    });
+  }
+  dagre.layout(g);
+  const collapsedGroupIds = collapsedChildCounts ? new Set(collapsedChildCounts.keys()) : /* @__PURE__ */ new Set();
+  const basePositioned = allNodes.map((node) => {
+    const pos = g.node(node.id);
+    return { node, x: pos.x, y: pos.y, width: pos.width, height: pos.height };
+  });
+  const noteRequests = basePositioned.filter((p) => noteGeoms.has(p.node.id)).map((p) => {
+    const ng = noteGeoms.get(p.node.id);
+    return {
+      key: p.node.id,
+      node: { x: p.x, y: p.y, width: p.width, height: p.height },
+      noteW: ng.noteW,
+      noteH: ng.noteH,
+      collapsed: collapsedNotes?.has(ng.lineNumber) ?? false
+    };
+  });
+  const placements = placeNotes(
+    basePositioned.map((p) => ({
+      x: p.x,
+      y: p.y,
+      width: p.width,
+      height: p.height
+    })),
+    noteRequests,
+    graph.direction === "LR" ? "LR" : "TB"
+  );
+  const layoutNodes = basePositioned.map((p) => {
+    const node = p.node;
+    const ng = noteGeoms.get(node.id);
+    const placed = placements.get(node.id);
+    return {
+      id: node.id,
+      label: node.label,
+      shape: node.shape,
+      ...node.color !== void 0 && { color: node.color },
+      ...node.group !== void 0 && { group: node.group },
+      lineNumber: node.lineNumber,
+      x: p.x,
+      y: p.y,
+      width: p.width,
+      height: p.height,
+      ...ng && placed && {
+        // Local coords relative to the node center (translate origin).
+        note: placed.collapsed ? {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0,
+          side: "right",
+          ...ng.color && { color: ng.color },
+          lines: [],
+          lineNumber: ng.lineNumber,
+          endLineNumber: ng.endLineNumber,
+          collapsed: true
+        } : {
+          x: placed.x,
+          y: placed.y,
+          width: ng.noteW,
+          height: ng.noteH,
+          side: placed.side,
+          ...ng.color && { color: ng.color },
+          lines: ng.lines,
+          lineNumber: ng.lineNumber,
+          endLineNumber: ng.endLineNumber
+        }
+      }
+    };
+  });
+  const layoutEdges = graph.edges.map((edge) => {
+    const edgeData = g.edge(edge.source, edge.target);
+    return {
+      source: edge.source,
+      target: edge.target,
+      points: edgeData?.points ?? [],
+      ...edge.label !== void 0 && { label: edge.label },
+      lineNumber: edge.lineNumber
+    };
+  });
+  const layoutGroups = [];
+  const allGroups = graph.groups ?? [];
+  if (originalGroups) {
+    for (const group of originalGroups) {
+      if (collapsedGroupIds.has(group.id)) {
+        const syntheticNode = layoutNodes.find((n) => n.id === group.id);
+        if (syntheticNode) {
+          layoutGroups.push({
+            id: group.id,
+            label: group.label,
+            ...group.color !== void 0 && { color: group.color },
+            lineNumber: group.lineNumber,
+            collapsed: true,
+            x: syntheticNode.x - syntheticNode.width / 2,
+            y: syntheticNode.y - syntheticNode.height / 2,
+            width: syntheticNode.width,
+            height: syntheticNode.height
+          });
+        }
+      }
+    }
+  }
+  if (allGroups.length > 0) {
+    const nodeMap = new Map(layoutNodes.map((n) => [n.id, n]));
+    for (const group of allGroups) {
+      const members = group.nodeIds.map((id) => nodeMap.get(id)).filter((n) => n !== void 0);
+      if (members.length === 0) {
+        layoutGroups.push({
+          id: group.id,
+          label: group.label,
+          ...group.color !== void 0 && { color: group.color },
+          lineNumber: group.lineNumber,
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        });
+        continue;
+      }
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const member of members) {
+        const left = member.x - member.width / 2;
+        const right = member.x + member.width / 2;
+        const top = member.y - member.height / 2;
+        const bottom = member.y + member.height / 2;
+        if (left < minX) minX = left;
+        if (right > maxX) maxX = right;
+        if (top < minY) minY = top;
+        if (bottom > maxY) maxY = bottom;
+      }
+      layoutGroups.push({
+        id: group.id,
+        label: group.label,
+        ...group.color !== void 0 && { color: group.color },
+        lineNumber: group.lineNumber,
+        x: minX - GROUP_PADDING,
+        y: minY - GROUP_PADDING,
+        width: maxX - minX + GROUP_PADDING * 2,
+        height: maxY - minY + GROUP_PADDING * 2
+      });
+    }
+  }
+  let bbMinX = Infinity;
+  let bbMinY = Infinity;
+  let bbMaxX = -Infinity;
+  let bbMaxY = -Infinity;
+  const extend = (l, t, r, b) => {
+    if (l < bbMinX) bbMinX = l;
+    if (t < bbMinY) bbMinY = t;
+    if (r > bbMaxX) bbMaxX = r;
+    if (b > bbMaxY) bbMaxY = b;
+  };
+  for (const node of layoutNodes) {
+    extend(
+      node.x - node.width / 2,
+      node.y - node.height / 2,
+      node.x + node.width / 2,
+      node.y + node.height / 2
+    );
+    if (node.note) {
+      extend(
+        node.x + node.note.x,
+        node.y + node.note.y,
+        node.x + node.note.x + node.note.width,
+        node.y + node.note.y + node.note.height
+      );
+    }
+  }
+  for (const group of layoutGroups) {
+    extend(group.x, group.y, group.x + group.width, group.y + group.height);
+  }
+  if (!Number.isFinite(bbMinX)) {
+    bbMinX = 0;
+    bbMinY = 0;
+    bbMaxX = 0;
+    bbMaxY = 0;
+  }
+  const { shiftX, shiftY } = noteCanvasShift(bbMinX, bbMinY);
+  const shifted = shiftX !== 0 || shiftY !== 0;
+  const finalNodes = shifted ? layoutNodes.map((n) => ({ ...n, x: n.x + shiftX, y: n.y + shiftY })) : layoutNodes;
+  const finalEdges = shifted ? layoutEdges.map((e) => ({
+    ...e,
+    points: e.points.map((pt) => ({ x: pt.x + shiftX, y: pt.y + shiftY }))
+  })) : layoutEdges;
+  const finalGroups = shifted ? layoutGroups.map((gr) => ({ ...gr, x: gr.x + shiftX, y: gr.y + shiftY })) : layoutGroups;
+  const totalWidth = bbMaxX + shiftX + 40;
+  const totalHeight = bbMaxY + shiftY + 40;
+  return {
+    nodes: finalNodes,
+    edges: finalEdges,
+    groups: finalGroups,
+    width: totalWidth,
+    height: totalHeight
+  };
+}
+
+export {
+  layoutGraph
+};
+//# sourceMappingURL=chunk-T3UBLACL.js.map

package/dist/chunk-TLVIHFRO.js

@@ -0,0 +1,296 @@
+import {
+  makeDgmoError,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/colors.ts
+var nord = {
+  // Polar Night (dark)
+  nord0: "#2e3440",
+  nord1: "#3b4252",
+  nord2: "#434c5e",
+  nord3: "#4c566a",
+  // Snow Storm (light)
+  nord4: "#d8dee9",
+  nord5: "#e5e9f0",
+  nord6: "#eceff4",
+  // Frost (accent blues)
+  nord7: "#8fbcbb",
+  nord8: "#88c0d0",
+  nord9: "#81a1c1",
+  nord10: "#5e81ac",
+  // Aurora (colors)
+  nord11: "#bf616a",
+  // red
+  nord12: "#d08770",
+  // orange
+  nord13: "#ebcb8b",
+  // yellow
+  nord14: "#a3be8c",
+  // green
+  nord15: "#b48ead"
+  // purple
+};
+var colorNames = {
+  red: nord.nord11,
+  orange: nord.nord12,
+  yellow: nord.nord13,
+  green: nord.nord14,
+  blue: nord.nord10,
+  purple: nord.nord15,
+  teal: nord.nord7,
+  cyan: nord.nord8,
+  gray: nord.nord3,
+  black: nord.nord0,
+  white: nord.nord6
+};
+var RECOGNIZED_COLOR_NAMES = Object.freeze([
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "teal",
+  "cyan",
+  "gray",
+  "black",
+  "white"
+]);
+var CATEGORICAL_COLOR_ORDER = Object.freeze([
+  "red",
+  "green",
+  "blue",
+  "yellow",
+  "teal",
+  "purple",
+  "orange",
+  "cyan"
+]);
+function isRecognizedColorName(name) {
+  return Object.prototype.hasOwnProperty.call(colorNames, name.toLowerCase());
+}
+function resolveColor(color, palette) {
+  if (!color) return null;
+  if (color.startsWith("#")) return null;
+  const lower = color.toLowerCase();
+  if (!isRecognizedColorName(lower)) return null;
+  if (palette) {
+    const named = palette.colors[lower];
+    if (named) return named;
+  }
+  return colorNames[lower] ?? null;
+}
+var INVALID_COLOR_CODE = "E_INVALID_COLOR";
+var INVALID_CSS_COLOR_HEX = Object.freeze({
+  pink: "#ffc0cb",
+  hotpink: "#ff69b4",
+  deeppink: "#ff1493",
+  lightpink: "#ffb6c1",
+  palevioletred: "#db7093",
+  crimson: "#dc143c",
+  scarlet: "#ff2400",
+  firebrick: "#b22222",
+  darkred: "#8b0000",
+  maroon: "#800000",
+  salmon: "#fa8072",
+  lightsalmon: "#ffa07a",
+  darksalmon: "#e9967a",
+  coral: "#ff7f50",
+  lightcoral: "#f08080",
+  tomato: "#ff6347",
+  orangered: "#ff4500",
+  darkorange: "#ff8c00",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  darkgoldenrod: "#b8860b",
+  khaki: "#f0e68c",
+  darkkhaki: "#bdb76b",
+  amber: "#ffbf00",
+  lavender: "#e6e6fa",
+  violet: "#ee82ee",
+  magenta: "#ff00ff",
+  fuchsia: "#ff00ff",
+  orchid: "#da70d6",
+  plum: "#dda0dd",
+  indigo: "#4b0082",
+  navy: "#000080",
+  midnightblue: "#191970",
+  darkblue: "#00008b",
+  mediumblue: "#0000cd",
+  royalblue: "#4169e1",
+  cornflowerblue: "#6495ed",
+  dodgerblue: "#1e90ff",
+  deepskyblue: "#00bfff",
+  skyblue: "#87ceeb",
+  lightskyblue: "#87cefa",
+  lightblue: "#add8e6",
+  powderblue: "#b0e0e6",
+  steelblue: "#4682b4",
+  slateblue: "#6a5acd",
+  cadetblue: "#5f9ea0",
+  turquoise: "#40e0d0",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  lightgreen: "#90ee90",
+  palegreen: "#98fb98",
+  seagreen: "#2e8b57",
+  mediumseagreen: "#3cb371",
+  forestgreen: "#228b22",
+  darkgreen: "#006400",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  darkolivegreen: "#556b2f",
+  chartreuse: "#7fff00",
+  lawngreen: "#7cfc00",
+  springgreen: "#00ff7f",
+  greenyellow: "#adff2f",
+  brown: "#a52a2a",
+  sienna: "#a0522d",
+  chocolate: "#d2691e",
+  peru: "#cd853f",
+  tan: "#d2b48c",
+  beige: "#f5f5dc",
+  wheat: "#f5deb3",
+  ivory: "#fffff0",
+  silver: "#c0c0c0",
+  lightgray: "#d3d3d3",
+  lightgrey: "#d3d3d3",
+  darkgray: "#a9a9a9",
+  darkgrey: "#a9a9a9",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  slategray: "#708090",
+  slategrey: "#708090",
+  gainsboro: "#dcdcdc",
+  grey: "#808080"
+});
+function nearestNamedColor(input) {
+  const cssHex = INVALID_CSS_COLOR_HEX[input.trim().toLowerCase()];
+  if (cssHex) input = cssHex;
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(input.trim());
+  if (!m) return null;
+  let h = m[1].toLowerCase();
+  if (h.length === 3)
+    h = h.split("").map((c) => c + c).join("");
+  const r = parseInt(h.slice(0, 2), 16) / 255;
+  const g = parseInt(h.slice(2, 4), 16) / 255;
+  const b = parseInt(h.slice(4, 6), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  const l = (max + min) / 2;
+  const s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+  if (s < 0.15) {
+    if (l < 0.2) return "black";
+    if (l > 0.85) return "white";
+    return "gray";
+  }
+  let hue;
+  if (max === r) hue = 60 * ((g - b) / delta % 6);
+  else if (max === g) hue = 60 * ((b - r) / delta + 2);
+  else hue = 60 * ((r - g) / delta + 4);
+  if (hue < 0) hue += 360;
+  const anchors = [
+    ["red", 0],
+    ["orange", 30],
+    ["yellow", 55],
+    ["green", 120],
+    ["teal", 170],
+    ["cyan", 190],
+    ["blue", 225],
+    ["purple", 285],
+    ["red", 360]
+  ];
+  let best = "red";
+  let bestD = Infinity;
+  for (const [name, deg] of anchors) {
+    const d = Math.abs(hue - deg);
+    if (d < bestD) {
+      bestD = d;
+      best = name;
+    }
+  }
+  return best;
+}
+function isInvalidColorToken(token) {
+  if (/^(#|rgba?\(|hsla?\()/i.test(token)) return true;
+  const lower = token.toLowerCase();
+  return INVALID_CSS_COLOR_HEX[lower] !== void 0 && !isRecognizedColorName(lower);
+}
+function invalidColorDiagnostic(token, line) {
+  if (!isInvalidColorToken(token)) return null;
+  const nearest = nearestNamedColor(token);
+  const near = nearest ? ` Nearest: ${nearest}.` : "";
+  return makeDgmoError(
+    line,
+    `Color "${token}" is not a valid DGMO color \u2014 DGMO accepts only these 11 named colors: ${RECOGNIZED_COLOR_NAMES.join(", ")} (no hex, no CSS color names).${near}`,
+    "warning",
+    INVALID_COLOR_CODE
+  );
+}
+function resolveColorWithDiagnostic(color, line, diagnostics, palette) {
+  const resolved = resolveColor(color, palette);
+  if (resolved !== null) return resolved;
+  if (/^(#|rgba?\(|hsla?\()/i.test(color)) {
+    const nearest = nearestNamedColor(color);
+    const near = nearest ? ` Nearest: ${nearest}.` : "";
+    diagnostics.push(
+      makeDgmoError(
+        line,
+        `Color "${color}" is not supported \u2014 DGMO does not accept hex or CSS color values. Use a named palette color: ${RECOGNIZED_COLOR_NAMES.join(", ")}.${near}`,
+        "error",
+        INVALID_COLOR_CODE
+      )
+    );
+    return void 0;
+  }
+  const hint = suggest(color, RECOGNIZED_COLOR_NAMES);
+  const suggestion = hint ? ` ${hint}` : "";
+  diagnostics.push(
+    makeDgmoError(
+      line,
+      `Unknown color "${color}". DGMO accepts only these 11 named colors: ${RECOGNIZED_COLOR_NAMES.join(", ")} (no hex, no CSS color names).${suggestion}`,
+      "warning",
+      INVALID_COLOR_CODE
+    )
+  );
+  return void 0;
+}
+var seriesColors = [
+  nord.nord10,
+  // blue
+  nord.nord14,
+  // green
+  nord.nord13,
+  // yellow
+  nord.nord12,
+  // orange
+  nord.nord15,
+  // purple
+  nord.nord11,
+  // red
+  nord.nord7,
+  // teal
+  nord.nord8
+  // light blue
+];
+
+export {
+  nord,
+  colorNames,
+  RECOGNIZED_COLOR_NAMES,
+  CATEGORICAL_COLOR_ORDER,
+  isRecognizedColorName,
+  resolveColor,
+  INVALID_COLOR_CODE,
+  INVALID_CSS_COLOR_HEX,
+  nearestNamedColor,
+  isInvalidColorToken,
+  invalidColorDiagnostic,
+  resolveColorWithDiagnostic,
+  seriesColors
+};
+//# sourceMappingURL=chunk-TLVIHFRO.js.map

package/dist/chunk-TYS6CSS5.js

@@ -0,0 +1,52 @@
+import {
+  NOTE_BULLET_INDENT,
+  NOTE_FOLD,
+  NOTE_FONT_SIZE,
+  NOTE_LINE_H,
+  NOTE_MAX_W,
+  NOTE_PAD_H,
+  NOTE_PAD_V
+} from "./chunk-5DH3KYFH.js";
+import {
+  wrapDescriptionLines
+} from "./chunk-BMR4CIEO.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+
+// src/utils/note-box/metrics.ts
+function normalizeBulletLine(line) {
+  return line.replace(/^\s*[-*]\s+/, "\u2022 ");
+}
+function wrapNoteBody(body, textMaxWidth, fontSize = NOTE_FONT_SIZE) {
+  const sourceLines = body.split("\n").map(normalizeBulletLine);
+  return wrapDescriptionLines(
+    sourceLines,
+    textMaxWidth,
+    (s) => measureText(s, fontSize)
+  );
+}
+function noteBoxSize(body, opts = {}) {
+  const fontSize = opts.fontSize ?? NOTE_FONT_SIZE;
+  const maxW = opts.maxW ?? NOTE_MAX_W;
+  const textMaxWidth = maxW - NOTE_PAD_H * 2;
+  const lines = wrapNoteBody(body, textMaxWidth, fontSize);
+  let maxLineW = 0;
+  for (const line of lines) {
+    const indent = line.kind === "plain" ? 0 : NOTE_BULLET_INDENT;
+    const w = measureText(line.text, fontSize) + indent;
+    if (w > maxLineW) maxLineW = w;
+  }
+  const width = Math.min(
+    maxW,
+    Math.max(80, maxLineW + NOTE_PAD_H * 2 + NOTE_FOLD)
+  );
+  const height = Math.max(1, lines.length) * NOTE_LINE_H + NOTE_PAD_V * 2;
+  return { width, height, lines };
+}
+
+export {
+  wrapNoteBody,
+  noteBoxSize
+};
+//# sourceMappingURL=chunk-TYS6CSS5.js.map