@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-6NYWYNBI.js

@@ -0,0 +1,329 @@
+import {
+  buildPlacedNotes
+} from "./chunk-JED6ZDEE.js";
+import {
+  noteCanvasShift
+} from "./chunk-6EK55ART.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+
+// src/er/layout.ts
+import dagre from "@dagrejs/dagre";
+var MIN_WIDTH = 140;
+var PADDING_X = 24;
+var HEADER_BASE = 36;
+var TABLE_FONT_SIZE = 13;
+var COLUMN_FONT_SIZE = 11;
+var EDGE_LABEL_FONT_SIZE = 11;
+var CONSTRAINT_ICON_WIDTH = 16;
+var MEMBER_LINE_HEIGHT = 18;
+var COMPARTMENT_PADDING_Y = 8;
+var SEPARATOR_HEIGHT = 1;
+var HALF_MARGIN = 30;
+var COMP_GAP = 60;
+function computeNodeDimensions(table) {
+  let maxTextWidth = measureText(table.name, TABLE_FONT_SIZE);
+  for (const col of table.columns) {
+    let colText = col.name;
+    if (col.type) colText += `: ${col.type}`;
+    let colWidth = measureText(colText, COLUMN_FONT_SIZE);
+    if (col.constraints.length > 0) colWidth += CONSTRAINT_ICON_WIDTH;
+    maxTextWidth = Math.max(maxTextWidth, colWidth);
+  }
+  const width = Math.max(MIN_WIDTH, maxTextWidth + PADDING_X);
+  const headerHeight = HEADER_BASE;
+  let columnsHeight = 0;
+  if (table.columns.length > 0) {
+    columnsHeight = COMPARTMENT_PADDING_Y * 2 + table.columns.length * MEMBER_LINE_HEIGHT + SEPARATOR_HEIGHT;
+  }
+  const height = headerHeight + columnsHeight + (columnsHeight === 0 ? 4 : 0);
+  return { width, height, headerHeight, columnsHeight };
+}
+function findConnectedComponents(tableIds, relationships) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const id of tableIds) adj.set(id, /* @__PURE__ */ new Set());
+  for (const rel of relationships) {
+    adj.get(rel.source)?.add(rel.target);
+    adj.get(rel.target)?.add(rel.source);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const id of tableIds) {
+    if (visited.has(id)) continue;
+    const comp = [];
+    const queue = [id];
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      if (visited.has(cur)) continue;
+      visited.add(cur);
+      comp.push(cur);
+      for (const nb of adj.get(cur) ?? []) {
+        if (!visited.has(nb)) queue.push(nb);
+      }
+    }
+    components.push(comp);
+  }
+  return components;
+}
+function layoutComponent(tables, rels, dimMap) {
+  const nodePositions = /* @__PURE__ */ new Map();
+  const edgePoints = /* @__PURE__ */ new Map();
+  if (tables.length === 1) {
+    const onlyTable = tables[0];
+    const dims = dimMap.get(onlyTable.id);
+    nodePositions.set(onlyTable.id, {
+      x: dims.width / 2,
+      y: dims.height / 2,
+      ...dims
+    });
+    return {
+      nodePositions,
+      edgePoints,
+      width: dims.width,
+      height: dims.height
+    };
+  }
+  const g = new dagre.graphlib.Graph({ multigraph: true });
+  g.setGraph({ rankdir: "LR", nodesep: 40, ranksep: 80, edgesep: 20 });
+  g.setDefaultEdgeLabel(() => ({}));
+  for (const table of tables) {
+    const dims = dimMap.get(table.id);
+    g.setNode(table.id, { width: dims.width, height: dims.height });
+  }
+  for (const rel of rels) {
+    g.setEdge(
+      rel.source,
+      rel.target,
+      { label: rel.label ?? "" },
+      String(rel.lineNumber)
+    );
+  }
+  dagre.layout(g);
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const table of tables) {
+    const pos = g.node(table.id);
+    const dims = dimMap.get(table.id);
+    minX = Math.min(minX, pos.x - dims.width / 2);
+    minY = Math.min(minY, pos.y - dims.height / 2);
+    maxX = Math.max(maxX, pos.x + dims.width / 2);
+    maxY = Math.max(maxY, pos.y + dims.height / 2);
+  }
+  for (const rel of rels) {
+    const ed = g.edge(rel.source, rel.target, String(rel.lineNumber));
+    for (const pt of ed?.points ?? []) {
+      minX = Math.min(minX, pt.x);
+      minY = Math.min(minY, pt.y);
+      maxX = Math.max(maxX, pt.x);
+      maxY = Math.max(maxY, pt.y);
+    }
+    if (rel.label && (ed?.points ?? []).length > 0) {
+      const pts = ed.points;
+      const mid = pts[Math.floor(pts.length / 2)];
+      const hw = (measureText(rel.label, EDGE_LABEL_FONT_SIZE) + 8) / 2;
+      minX = Math.min(minX, mid.x - hw);
+      maxX = Math.max(maxX, mid.x + hw);
+    }
+  }
+  for (const table of tables) {
+    const pos = g.node(table.id);
+    const dims = dimMap.get(table.id);
+    nodePositions.set(table.id, {
+      x: pos.x - minX,
+      y: pos.y - minY,
+      ...dims
+    });
+  }
+  for (const rel of rels) {
+    const ed = g.edge(rel.source, rel.target, String(rel.lineNumber));
+    edgePoints.set(
+      rel.lineNumber,
+      (ed?.points ?? []).map((pt) => ({
+        x: pt.x - minX,
+        y: pt.y - minY
+      }))
+    );
+  }
+  return {
+    nodePositions,
+    edgePoints,
+    width: Math.max(0, maxX - minX),
+    height: Math.max(0, maxY - minY)
+  };
+}
+function packComponents(items) {
+  if (items.length === 0) return [];
+  const sorted = [...items].sort((a, b) => {
+    const aConnected = a.compIds.length > 1 ? 1 : 0;
+    const bConnected = b.compIds.length > 1 ? 1 : 0;
+    if (aConnected !== bConnected) return bConnected - aConnected;
+    return b.compLayout.height - a.compLayout.height;
+  });
+  const totalArea = items.reduce(
+    (s, c) => s + (c.compLayout.width || MIN_WIDTH) * (c.compLayout.height || HEADER_BASE),
+    0
+  );
+  const targetW = Math.max(
+    Math.sqrt(totalArea) * 1.5,
+    // In-bounds: sorted.length === items.length and items.length === 0 returned above.
+    sorted[0].compLayout.width
+    // at least as wide as the widest component
+  );
+  const placements = [];
+  let curX = 0;
+  let curY = 0;
+  let rowH = 0;
+  for (const item of sorted) {
+    const w = item.compLayout.width || MIN_WIDTH;
+    const h = item.compLayout.height || HEADER_BASE;
+    if (curX > 0 && curX + w > targetW) {
+      curY += rowH + COMP_GAP;
+      curX = 0;
+      rowH = 0;
+    }
+    placements.push({
+      compIds: item.compIds,
+      compLayout: item.compLayout,
+      offsetX: curX,
+      offsetY: curY
+    });
+    curX += w + COMP_GAP;
+    rowH = Math.max(rowH, h);
+  }
+  return placements;
+}
+function layoutERDiagram(parsed, options) {
+  if (parsed.tables.length === 0) {
+    return { nodes: [], edges: [], width: 0, height: 0 };
+  }
+  const dimMap = /* @__PURE__ */ new Map();
+  for (const table of parsed.tables) {
+    dimMap.set(table.id, computeNodeDimensions(table));
+  }
+  const compIdSets = findConnectedComponents(
+    parsed.tables.map((t) => t.id),
+    parsed.relationships
+  );
+  const tableById = new Map(parsed.tables.map((t) => [t.id, t]));
+  const componentItems = compIdSets.map((ids) => {
+    const tables = ids.map((id) => tableById.get(id));
+    const rels = parsed.relationships.filter((r) => ids.includes(r.source));
+    return { compIds: ids, compLayout: layoutComponent(tables, rels, dimMap) };
+  });
+  const packed = packComponents(componentItems);
+  const placementByTableId = /* @__PURE__ */ new Map();
+  for (const p of packed) {
+    for (const id of p.compIds) placementByTableId.set(id, p);
+  }
+  const placementByRelLine = /* @__PURE__ */ new Map();
+  for (const p of packed) {
+    for (const lineNum of p.compLayout.edgePoints.keys()) {
+      placementByRelLine.set(lineNum, p);
+    }
+  }
+  const layoutNodes = parsed.tables.map((table) => {
+    const p = placementByTableId.get(table.id);
+    const pos = p.compLayout.nodePositions.get(table.id);
+    return {
+      ...table,
+      x: pos.x + p.offsetX + HALF_MARGIN,
+      y: pos.y + p.offsetY + HALF_MARGIN,
+      width: pos.width,
+      height: pos.height,
+      headerHeight: pos.headerHeight,
+      columnsHeight: pos.columnsHeight
+    };
+  });
+  const layoutEdges = parsed.relationships.map((rel) => {
+    const p = placementByRelLine.get(rel.lineNumber);
+    const pts = p?.compLayout.edgePoints.get(rel.lineNumber) ?? [];
+    return {
+      source: rel.source,
+      target: rel.target,
+      cardinality: rel.cardinality,
+      points: pts.map((pt) => ({
+        x: pt.x + (p?.offsetX ?? 0) + HALF_MARGIN,
+        y: pt.y + (p?.offsetY ?? 0) + HALF_MARGIN
+      })),
+      ...rel.label !== void 0 && { label: rel.label },
+      lineNumber: rel.lineNumber
+    };
+  });
+  const notesSuppressed = parsed.options?.["no-notes"] === "on";
+  const noteByNode = notesSuppressed || !parsed.notes ? /* @__PURE__ */ new Map() : resolveNotes(
+    parsed.notes,
+    parsed.tables.map((t) => ({ id: t.id, label: t.name }))
+  );
+  const placedNotes = buildPlacedNotes(
+    layoutNodes.map((n) => ({
+      id: n.id,
+      x: n.x,
+      y: n.y,
+      width: n.width,
+      height: n.height
+    })),
+    noteByNode,
+    "TB",
+    options?.collapsedNotes
+  );
+  const notedNodes = layoutNodes.map((n) => {
+    const note = placedNotes.get(n.id);
+    return note ? { ...n, note } : n;
+  });
+  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 notedNodes) {
+    extend(
+      node.x - node.width / 2,
+      node.y - node.height / 2,
+      node.x + node.width / 2,
+      node.y + node.height / 2
+    );
+    if (node.note && !node.note.collapsed) {
+      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 edge of layoutEdges) {
+    for (const pt of edge.points) extend(pt.x, pt.y, pt.x, pt.y);
+  }
+  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 ? notedNodes.map((n) => ({ ...n, x: n.x + shiftX, y: n.y + shiftY })) : notedNodes;
+  const finalEdges = shifted ? layoutEdges.map((e) => ({
+    ...e,
+    points: e.points.map((pt) => ({ x: pt.x + shiftX, y: pt.y + shiftY }))
+  })) : layoutEdges;
+  return {
+    nodes: finalNodes,
+    edges: finalEdges,
+    width: bbMaxX + shiftX + HALF_MARGIN,
+    height: bbMaxY + shiftY + HALF_MARGIN
+  };
+}
+
+export {
+  layoutERDiagram
+};
+//# sourceMappingURL=chunk-6NYWYNBI.js.map