@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/chunk-Z6XJQ6KO.js

@@ -0,0 +1,452 @@
+import {
+  SKETCH_DIAGNOSTIC_CODES
+} from "./chunk-XHVV4NVW.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/sketch/geometry.ts
+var SKETCH_PHI = (1 + Math.sqrt(5)) / 2;
+var SKETCH_GEOMETRY = {
+  /** px per grid cell (the dot-grid pitch) */
+  cellPx: 26,
+  /** universal footprint width, in grid cells */
+  footprintCellsW: 8,
+  /**
+   * Legacy — the gap is now a derived half-unit (footprint/2 per axis), not
+   * these cell counts. Kept only so the shape of SKETCH_GEOMETRY is stable.
+   */
+  gapCellsX: 4,
+  gapCellsY: 4,
+  /** box reserved top band, px (spec decision 12) */
+  bandPx: 44,
+  /** box frame padding around the children bbox, px */
+  boxPadPx: 26,
+  /** edge-ring (connect hook) width as a fraction of footprint height */
+  ringFrac: 0.22
+};
+var SKETCH_FOOT_W = SKETCH_GEOMETRY.footprintCellsW * SKETCH_GEOMETRY.cellPx;
+var SKETCH_FOOT_H = 2 * Math.round(SKETCH_FOOT_W / SKETCH_PHI / 2);
+var SKETCH_HALF_SLOT_X = SKETCH_FOOT_W / 2;
+var SKETCH_HALF_SLOT_Y = SKETCH_FOOT_H / 2;
+var SKETCH_SEP = 3;
+var SKETCH_SLOT_X = SKETCH_HALF_SLOT_X * SKETCH_SEP;
+var SKETCH_SLOT_Y = SKETCH_HALF_SLOT_Y * SKETCH_SEP;
+function sketchSlotToPx(c, r) {
+  return { x: c * SKETCH_HALF_SLOT_X, y: r * SKETCH_HALF_SLOT_Y };
+}
+
+// src/sketch/collapse.ts
+function collapseSketch(parsed, collapsedLabels) {
+  const collapsed = collapsedLabels ?? new Set(parsed.boxes.filter((b) => b.collapsed).map((b) => b.label));
+  if (collapsed.size === 0) {
+    return {
+      nodes: parsed.nodes,
+      boxes: parsed.boxes,
+      virtualBoxes: [],
+      edges: parsed.edges,
+      collapsedChildCounts: /* @__PURE__ */ new Map()
+    };
+  }
+  const virtualBoxes = parsed.boxes.filter((b) => collapsed.has(b.label));
+  const boxes = parsed.boxes.filter((b) => !collapsed.has(b.label));
+  const nodeToVirtual = /* @__PURE__ */ new Map();
+  const collapsedChildCounts = /* @__PURE__ */ new Map();
+  for (const box of virtualBoxes) {
+    collapsedChildCounts.set(box.label, box.children.length);
+    for (const childId of box.children) nodeToVirtual.set(childId, box.id);
+  }
+  const nodes = parsed.nodes.filter((n) => !nodeToVirtual.has(n.id));
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const edge of parsed.edges) {
+    const sourceId = nodeToVirtual.get(edge.sourceId) ?? edge.sourceId;
+    const targetId = nodeToVirtual.get(edge.targetId) ?? edge.targetId;
+    if (sourceId === targetId) continue;
+    const key = `${sourceId}|${targetId}|${edge.label ?? ""}|${edge.heads}|${edge.dashed}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({ ...edge, sourceId, targetId });
+  }
+  return { nodes, boxes, virtualBoxes, edges, collapsedChildCounts };
+}
+
+// src/sketch/layout.ts
+function unitRect(c, r) {
+  return { c, r, w: SKETCH_SEP, h: SKETCH_SEP };
+}
+function rectsOverlap(a, b) {
+  return a.c < b.c + b.w && b.c < a.c + a.w && a.r < b.r + b.h && b.r < a.r + a.h;
+}
+function collidesAny(rect, occupied) {
+  for (const o of occupied) if (rectsOverlap(rect, o)) return true;
+  return false;
+}
+function nearestFree(base, occupied) {
+  if (!collidesAny(base, occupied)) return { c: base.c, r: base.r };
+  for (let d = 1; d <= 200; d++) {
+    const candidates = [];
+    for (let dc = -d; dc <= d; dc++) {
+      const dr = d - Math.abs(dc);
+      candidates.push({ c: base.c + dc, r: base.r + dr });
+      if (dr !== 0) candidates.push({ c: base.c + dc, r: base.r - dr });
+    }
+    candidates.sort((a, b) => {
+      const costA = (a.r < base.r ? 2 : 0) + (a.c < base.c ? 1 : 0);
+      const costB = (b.r < base.r ? 2 : 0) + (b.c < base.c ? 1 : 0);
+      return costA - costB || a.r - b.r || a.c - b.c;
+    });
+    for (const cand of candidates) {
+      if (!collidesAny({ ...base, c: cand.c, r: cand.r }, occupied)) {
+        return cand;
+      }
+    }
+  }
+  return { c: base.c, r: base.r };
+}
+function layoutChildren(box, nodesById, warn) {
+  const occupied = [];
+  const children = [];
+  const pending = [];
+  for (const id of box.children) {
+    const node = nodesById.get(id);
+    if (!node) continue;
+    if (node.at === null) {
+      pending.push(node);
+      continue;
+    }
+    const target = unitRect(node.at.c, node.at.r);
+    const spot = nearestFree(target, occupied);
+    if (spot.c !== node.at.c || spot.r !== node.at.r) {
+      warn(node.lineNumber, node.label);
+    }
+    occupied.push(unitRect(spot.c, spot.r));
+    children.push({ node, c: spot.c, r: spot.r });
+  }
+  let flowRow = occupied.length > 0 ? Math.max(...occupied.map((o) => o.r)) + SKETCH_SEP : 0;
+  let flowCol = 0;
+  const wrapAt = Math.max(
+    SKETCH_SEP * 3,
+    occupied.length > 0 ? Math.max(...occupied.map((o) => o.c)) + SKETCH_SEP : SKETCH_SEP * 3
+  );
+  for (const node of pending) {
+    let placed = false;
+    while (!placed) {
+      const rect = unitRect(flowCol, flowRow);
+      if (!collidesAny(rect, occupied)) {
+        occupied.push(rect);
+        children.push({ node, c: flowCol, r: flowRow });
+        placed = true;
+      }
+      flowCol += SKETCH_SEP;
+      if (flowCol > wrapAt) {
+        flowCol = 0;
+        flowRow += SKETCH_SEP;
+      }
+    }
+  }
+  let extent;
+  if (occupied.length === 0) {
+    extent = { c: 0, r: 0, w: SKETCH_SEP, h: SKETCH_SEP };
+  } else {
+    const cMin = Math.min(...occupied.map((o) => o.c));
+    const rMin = Math.min(...occupied.map((o) => o.r));
+    const cMax = Math.max(...occupied.map((o) => o.c + o.w));
+    const rMax = Math.max(...occupied.map((o) => o.r + o.h));
+    extent = { c: cMin, r: rMin, w: cMax - cMin, h: rMax - rMin };
+  }
+  return { children, extent };
+}
+function layoutSketch(parsed, options = {}) {
+  const diagnostics = [];
+  const overlapWarn = (line, label) => {
+    diagnostics.push(
+      makeDgmoError(
+        line,
+        `Shape "${label}" overlapped another at its authored position \u2014 moved to the nearest free slot`,
+        "warning",
+        SKETCH_DIAGNOSTIC_CODES.OVERLAP_RESOLVED
+      )
+    );
+  };
+  const collapsed = collapseSketch(parsed, options.collapsedBoxes);
+  const nodesById = new Map(collapsed.nodes.map((n) => [n.id, n]));
+  const padHsX = SKETCH_GEOMETRY.boxPadPx / SKETCH_HALF_SLOT_X;
+  const padHsY = SKETCH_GEOMETRY.boxPadPx / SKETCH_HALF_SLOT_Y;
+  const bandHs = SKETCH_GEOMETRY.bandPx / SKETCH_HALF_SLOT_Y;
+  const boxLocal = /* @__PURE__ */ new Map();
+  const inExpandedBox = /* @__PURE__ */ new Set();
+  for (const box of collapsed.boxes) {
+    const local = layoutChildren(box, nodesById, overlapWarn);
+    boxLocal.set(box.id, local);
+    for (const child of local.children) inExpandedBox.add(child.node.id);
+  }
+  const rootUnits = [];
+  for (const node of collapsed.nodes) {
+    if (!inExpandedBox.has(node.id)) rootUnits.push({ kind: "shape", node });
+  }
+  for (const box of collapsed.virtualBoxes) {
+    rootUnits.push({ kind: "virtual", box });
+  }
+  for (const box of collapsed.boxes) {
+    rootUnits.push({ kind: "box", box });
+  }
+  rootUnits.sort((a, b) => {
+    const la = a.kind === "shape" ? a.node.lineNumber : a.box.lineNumber;
+    const lb = b.kind === "shape" ? b.node.lineNumber : b.box.lineNumber;
+    return la - lb;
+  });
+  const rectFor = (unit, c, r) => {
+    if (unit.kind === "box") {
+      const local = boxLocal.get(unit.box.id);
+      return {
+        c: c + local.extent.c - padHsX,
+        r: r + local.extent.r - bandHs,
+        w: local.extent.w + 2 * padHsX,
+        h: local.extent.h + bandHs + padHsY
+      };
+    }
+    return unitRect(c, r);
+  };
+  const occupied = [];
+  const placedAt = /* @__PURE__ */ new Map();
+  const pending = [];
+  for (const unit of rootUnits) {
+    const at = unit.kind === "shape" ? unit.node.at : unit.box.at;
+    if (at === null) {
+      pending.push(unit);
+      continue;
+    }
+    const base = rectFor(unit, at.c, at.r);
+    let spot = { c: at.c, r: at.r };
+    if (collidesAny(base, occupied)) {
+      const freed = nearestFree(base, occupied);
+      spot = {
+        c: at.c + (freed.c - base.c),
+        r: at.r + (freed.r - base.r)
+      };
+      const line = unit.kind === "shape" ? unit.node.lineNumber : unit.box.lineNumber;
+      const label = unit.kind === "shape" ? unit.node.label : unit.box.label;
+      overlapWarn(line, label);
+    }
+    occupied.push(rectFor(unit, spot.c, spot.r));
+    placedAt.set(unit, spot);
+  }
+  let flowRow = occupied.length > 0 ? Math.ceil(Math.max(...occupied.map((o) => o.r + o.h))) : 0;
+  let flowCol = 0;
+  const wrapAt = Math.max(
+    SKETCH_SEP * 4,
+    occupied.length > 0 ? Math.ceil(Math.max(...occupied.map((o) => o.c + o.w))) : SKETCH_SEP * 4
+  );
+  for (const unit of pending) {
+    let placed = false;
+    while (!placed) {
+      const rect = rectFor(unit, flowCol, flowRow);
+      if (!collidesAny(rect, occupied)) {
+        occupied.push(rect);
+        placedAt.set(unit, { c: flowCol, r: flowRow });
+        placed = true;
+      }
+      flowCol += SKETCH_SEP;
+      if (flowCol > wrapAt) {
+        flowCol = 0;
+        flowRow += SKETCH_SEP;
+      }
+    }
+  }
+  const allRects = rootUnits.map((u) => {
+    const spot = placedAt.get(u);
+    return rectFor(u, spot.c, spot.r);
+  });
+  const cMin = allRects.length > 0 ? Math.min(...allRects.map((r) => r.c)) : 0;
+  const rMin = allRects.length > 0 ? Math.min(...allRects.map((r) => r.r)) : 0;
+  const toPx = (c, r) => ({
+    x: (c - cMin) * SKETCH_HALF_SLOT_X,
+    y: (r - rMin) * SKETCH_HALF_SLOT_Y
+  });
+  const nodes = [];
+  const boxes = [];
+  for (const unit of rootUnits) {
+    const spot = placedAt.get(unit);
+    if (unit.kind === "shape") {
+      const { x, y } = toPx(spot.c, spot.r);
+      nodes.push({
+        id: unit.node.id,
+        label: unit.node.label,
+        shape: unit.node.shape,
+        metadata: unit.node.metadata,
+        ...unit.node.description && { description: unit.node.description },
+        lineNumber: unit.node.lineNumber,
+        slot: spot,
+        x,
+        y,
+        w: SKETCH_FOOT_W,
+        h: SKETCH_FOOT_H
+      });
+    } else if (unit.kind === "virtual") {
+      const { x, y } = toPx(spot.c, spot.r);
+      nodes.push({
+        id: unit.box.id,
+        label: unit.box.label,
+        shape: "rectangle",
+        metadata: unit.box.metadata,
+        lineNumber: unit.box.lineNumber,
+        slot: spot,
+        x,
+        y,
+        w: SKETCH_FOOT_W,
+        h: SKETCH_FOOT_H,
+        isCollapsedBox: true,
+        childCount: collapsed.collapsedChildCounts.get(unit.box.label) ?? 0
+      });
+    } else {
+      const local = boxLocal.get(unit.box.id);
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const child of local.children) {
+        const abs = toPx(spot.c + child.c, spot.r + child.r);
+        nodes.push({
+          id: child.node.id,
+          label: child.node.label,
+          shape: child.node.shape,
+          metadata: child.node.metadata,
+          ...child.node.description && {
+            description: child.node.description
+          },
+          boxLabel: unit.box.label,
+          lineNumber: child.node.lineNumber,
+          slot: { c: spot.c + child.c, r: spot.r + child.r },
+          x: abs.x,
+          y: abs.y,
+          w: SKETCH_FOOT_W,
+          h: SKETCH_FOOT_H
+        });
+        minX = Math.min(minX, abs.x);
+        minY = Math.min(minY, abs.y);
+        maxX = Math.max(maxX, abs.x + SKETCH_FOOT_W);
+        maxY = Math.max(maxY, abs.y + SKETCH_FOOT_H);
+      }
+      if (minX === Infinity) {
+        const origin = toPx(spot.c, spot.r);
+        minX = origin.x;
+        minY = origin.y + SKETCH_GEOMETRY.bandPx;
+        maxX = origin.x + SKETCH_FOOT_W;
+        maxY = minY;
+      }
+      boxes.push({
+        id: unit.box.id,
+        label: unit.box.label,
+        metadata: unit.box.metadata,
+        lineNumber: unit.box.lineNumber,
+        x: minX - SKETCH_GEOMETRY.boxPadPx,
+        y: minY - SKETCH_GEOMETRY.bandPx,
+        w: maxX - minX + 2 * SKETCH_GEOMETRY.boxPadPx,
+        h: maxY - minY + SKETCH_GEOMETRY.bandPx + SKETCH_GEOMETRY.boxPadPx,
+        bandH: SKETCH_GEOMETRY.bandPx
+      });
+    }
+  }
+  {
+    const centerOf = (id) => {
+      const n = nodes.find((nd) => nd.id === id);
+      if (n) return { x: n.x + n.w / 2, y: n.y + n.h / 2 };
+      const b = boxes.find((bx) => bx.id === id);
+      if (b) return { x: b.x + b.w / 2, y: b.y + b.h / 2 };
+      return null;
+    };
+    const segHitsRect = (ax, ay, bx, by, rx0, ry0, rx1, ry1) => {
+      let t0 = 0;
+      let t1 = 1;
+      const p = [-(bx - ax), bx - ax, -(by - ay), by - ay];
+      const q = [ax - rx0, rx1 - ax, ay - ry0, ry1 - ay];
+      for (let i = 0; i < 4; i++) {
+        if (p[i] === 0) {
+          if (q[i] < 0) return false;
+        } else {
+          const t = q[i] / p[i];
+          if (p[i] < 0) {
+            if (t > t1) return false;
+            if (t > t0) t0 = t;
+          } else {
+            if (t < t0) return false;
+            if (t < t1) t1 = t;
+          }
+        }
+      }
+      return t0 <= t1;
+    };
+    const warned = /* @__PURE__ */ new Set();
+    for (let pass = 0; pass < 4; pass++) {
+      let moved = false;
+      for (const n of nodes) {
+        if (n.boxLabel) continue;
+        for (const e of collapsed.edges) {
+          if (e.sourceId === n.id || e.targetId === n.id) continue;
+          const a = centerOf(e.sourceId);
+          const b = centerOf(e.targetId);
+          if (!a || !b) continue;
+          if (!segHitsRect(a.x, a.y, b.x, b.y, n.x, n.y, n.x + n.w, n.y + n.h))
+            continue;
+          const ncx = n.x + n.w / 2;
+          const ncy = n.y + n.h / 2;
+          const m = n;
+          if (Math.abs(b.x - a.x) >= Math.abs(b.y - a.y)) {
+            const lineY = a.y + (b.y - a.y) * (ncx - a.x) / (b.x - a.x || 1);
+            let dir = ncy >= lineY ? 1 : -1;
+            if (n.slot.r + dir * SKETCH_SEP < 0) dir = 1;
+            m.y += dir * SKETCH_SLOT_Y;
+            m.slot = { c: n.slot.c, r: n.slot.r + dir * SKETCH_SEP };
+          } else {
+            const lineX = a.x + (b.x - a.x) * (ncy - a.y) / (b.y - a.y || 1);
+            let dir = ncx >= lineX ? 1 : -1;
+            if (n.slot.c + dir * SKETCH_SEP < 0) dir = 1;
+            m.x += dir * SKETCH_SLOT_X;
+            m.slot = { c: n.slot.c + dir * SKETCH_SEP, r: n.slot.r };
+          }
+          if (!warned.has(n.id)) {
+            overlapWarn(n.lineNumber, n.label);
+            warned.add(n.id);
+          }
+          moved = true;
+          break;
+        }
+      }
+      if (!moved) break;
+    }
+  }
+  let width = 0;
+  let height = 0;
+  for (const n of nodes) {
+    width = Math.max(width, n.x + n.w);
+    height = Math.max(height, n.y + n.h);
+  }
+  for (const b of boxes) {
+    width = Math.max(width, b.x + b.w);
+    height = Math.max(height, b.y + b.h);
+  }
+  return {
+    nodes,
+    boxes,
+    edges: collapsed.edges,
+    width,
+    height,
+    diagnostics
+  };
+}
+
+export {
+  SKETCH_GEOMETRY,
+  SKETCH_FOOT_W,
+  SKETCH_FOOT_H,
+  SKETCH_HALF_SLOT_X,
+  SKETCH_HALF_SLOT_Y,
+  SKETCH_SEP,
+  SKETCH_SLOT_X,
+  SKETCH_SLOT_Y,
+  sketchSlotToPx,
+  collapseSketch,
+  layoutSketch
+};
+//# sourceMappingURL=chunk-Z6XJQ6KO.js.map