@diagrammo/dgmo 0.75.0 → 0.77.0

package/dist/{chunk-6DYZ2JM6.js → chunk-FR5EVD2X.js}

@@ -1,6 +1,6 @@
 import {
   SKETCH_DIAGNOSTIC_CODES
-} from "./chunk-RT7ACF77.js";
+} from "./chunk-EGY3TS62.js";
 import {
   makeDgmoError
 } from "./chunk-5SI6T5A5.js";
@@ -9,7 +9,7 @@ import {
 var SKETCH_PHI = (1 + Math.sqrt(5)) / 2;
 var SKETCH_GEOMETRY = {
   /** px per grid cell (the dot-grid pitch) */
-  cellPx: 26,
+  cellPx: 16,
   /** universal footprint width, in grid cells */
   footprintCellsW: 8,
   /**
@@ -19,9 +19,9 @@ var SKETCH_GEOMETRY = {
   gapCellsX: 4,
   gapCellsY: 4,
   /** box reserved top band, px (spec decision 12) */
-  bandPx: 44,
+  bandPx: 28,
   /** box frame padding around the children bbox, px */
-  boxPadPx: 26,
+  boxPadPx: 16,
   /** edge-ring (connect hook) width as a fraction of footprint height */
   ringFrac: 0.22
 };
@@ -94,15 +94,85 @@ function resolveAutoFlags(f = {}) {
 function unitRect(c, r) {
   return { c, r, w: SKETCH_SEP, h: SKETCH_SEP };
 }
+var childBoxAt = /* @__PURE__ */ new Map();
+function nearestFreeRect(base, occupied) {
+  if (!occupied.hits(base)) 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 (!occupied.hits({ ...base, c: cand.c, r: cand.r })) return cand;
+    }
+  }
+  return { c: base.c, r: base.r };
+}
 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;
+var CELL = SKETCH_SEP;
+var OVERSIZED_CELLS = 64;
+function cellRange(rect) {
+  return [
+    Math.floor(rect.c / CELL),
+    Math.floor(rect.r / CELL),
+    Math.floor((rect.c + rect.w) / CELL),
+    Math.floor((rect.r + rect.h) / CELL)
+  ];
+}
+function cellSpan(range) {
+  return (range[2] - range[0] + 1) * (range[3] - range[1] + 1);
 }
+var Occupancy = class {
+  grid = /* @__PURE__ */ new Map();
+  oversized = [];
+  /** Every rect, in insertion order — the extent and flow-origin maths want it. */
+  rects = [];
+  add(rect) {
+    this.rects.push(rect);
+    const range = cellRange(rect);
+    if (cellSpan(range) > OVERSIZED_CELLS) {
+      this.oversized.push(rect);
+      return;
+    }
+    const [c0, r0, c1, r1] = range;
+    for (let c = c0; c <= c1; c++) {
+      for (let r = r0; r <= r1; r++) {
+        const key = `${c},${r}`;
+        const bucket = this.grid.get(key);
+        if (bucket) bucket.push(rect);
+        else this.grid.set(key, [rect]);
+      }
+    }
+  }
+  hits(rect) {
+    for (const o of this.oversized) if (rectsOverlap(rect, o)) return true;
+    const range = cellRange(rect);
+    if (cellSpan(range) > OVERSIZED_CELLS) {
+      for (const o of this.rects) if (rectsOverlap(rect, o)) return true;
+      return false;
+    }
+    const [c0, r0, c1, r1] = range;
+    for (let c = c0; c <= c1; c++) {
+      for (let r = r0; r <= r1; r++) {
+        const bucket = this.grid.get(`${c},${r}`);
+        if (!bucket) continue;
+        for (const o of bucket) if (rectsOverlap(rect, o)) return true;
+      }
+    }
+    return false;
+  }
+};
 function nearestFree(base, occupied) {
-  if (!collidesAny(base, occupied)) return { c: base.c, r: base.r };
+  if (!occupied.hits(base)) return { c: base.c, r: base.r };
   for (let d = 1; d <= 200; d++) {
     const candidates = [];
     for (let dc = -d; dc <= d; dc++) {
@@ -116,17 +186,28 @@ function nearestFree(base, occupied) {
       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)) {
+      if (!occupied.hits({ ...base, c: cand.c, r: cand.r })) {
         return cand;
       }
     }
   }
   return { c: base.c, r: base.r };
 }
-function layoutChildren(box, nodesById, warn, flags) {
-  const occupied = [];
+function layoutChildren(box, nodesById, warn, flags, childBoxRects = /* @__PURE__ */ new Map()) {
+  const occupied = new Occupancy();
   const children = [];
+  const localBoxes = [];
   const pending = [];
+  for (const boxId of box.childBoxes) {
+    const rect = childBoxRects.get(boxId);
+    if (!rect) continue;
+    const at = childBoxAt.get(boxId) ?? null;
+    const base = at ?? { c: 0, r: 0 };
+    const want = { ...rect, c: base.c, r: base.r };
+    const spot = flags.resolveOverlap ? nearestFreeRect(want, occupied) : { c: want.c, r: want.r };
+    occupied.add({ ...rect, c: spot.c, r: spot.r });
+    localBoxes.push({ boxId, c: spot.c, r: spot.r, rect });
+  }
   for (const id of box.children) {
     const node = nodesById.get(id);
     if (!node) continue;
@@ -139,25 +220,25 @@ function layoutChildren(box, nodesById, warn, flags) {
     if (spot.c !== node.at.c || spot.r !== node.at.r) {
       warn(node.lineNumber, node.label);
     }
-    occupied.push(unitRect(spot.c, spot.r));
+    occupied.add(unitRect(spot.c, spot.r));
     children.push({ node, c: spot.c, r: spot.r });
   }
   if (!flags.flowPlaceUnpositioned) {
     for (const node of pending) children.push({ node, c: 0, r: 0 });
     pending.length = 0;
   }
-  let flowRow = occupied.length > 0 ? Math.max(...occupied.map((o) => o.r)) + SKETCH_SEP : 0;
+  let flowRow = occupied.rects.length > 0 ? Math.max(...occupied.rects.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
+    occupied.rects.length > 0 ? Math.max(...occupied.rects.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);
+      if (!occupied.hits(rect)) {
+        occupied.add(rect);
         children.push({ node, c: flowCol, r: flowRow });
         placed = true;
       }
@@ -169,16 +250,16 @@ function layoutChildren(box, nodesById, warn, flags) {
     }
   }
   let extent;
-  if (occupied.length === 0) {
+  if (occupied.rects.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));
+    const cMin = Math.min(...occupied.rects.map((o) => o.c));
+    const rMin = Math.min(...occupied.rects.map((o) => o.r));
+    const cMax = Math.max(...occupied.rects.map((o) => o.c + o.w));
+    const rMax = Math.max(...occupied.rects.map((o) => o.r + o.h));
     extent = { c: cMin, r: rMin, w: cMax - cMin, h: rMax - rMin };
   }
-  return { children, extent };
+  return { children, boxes: localBoxes, extent };
 }
 function layoutSketch(parsed, options = {}) {
   const diagnostics = [];
@@ -200,11 +281,41 @@ function layoutSketch(parsed, options = {}) {
   const bandHs = SKETCH_GEOMETRY.bandPx / SKETCH_HALF_SLOT_Y;
   const boxLocal = /* @__PURE__ */ new Map();
   const inExpandedBox = /* @__PURE__ */ new Set();
+  const boxById = new Map(collapsed.boxes.map((b) => [b.id, b]));
+  const nestedBoxIds = new Set(
+    collapsed.boxes.filter((b) => b.parentBoxId !== null).map((b) => b.id)
+  );
+  childBoxAt.clear();
   for (const box of collapsed.boxes) {
+    if (!nestedBoxIds.has(box.id)) continue;
+    childBoxAt.set(box.id, box.at);
     const local = layoutChildren(box, nodesById, overlapWarn, flags);
     boxLocal.set(box.id, local);
     for (const child of local.children) inExpandedBox.add(child.node.id);
   }
+  const childBoxRects = /* @__PURE__ */ new Map();
+  for (const box of collapsed.boxes) {
+    if (!nestedBoxIds.has(box.id)) continue;
+    const local = boxLocal.get(box.id);
+    childBoxRects.set(box.id, {
+      c: 0,
+      r: 0,
+      w: local.extent.w + 2 * padHsX,
+      h: local.extent.h + bandHs + padHsY
+    });
+  }
+  for (const box of collapsed.boxes) {
+    if (nestedBoxIds.has(box.id)) continue;
+    const local = layoutChildren(
+      box,
+      nodesById,
+      overlapWarn,
+      flags,
+      childBoxRects
+    );
+    boxLocal.set(box.id, local);
+    for (const child of local.children) inExpandedBox.add(child.node.id);
+  }
   const allNodesById = new Map(parsed.nodes.map((n) => [n.id, n]));
   const noWarn = () => {
   };
@@ -242,6 +353,7 @@ function layoutSketch(parsed, options = {}) {
     rootUnits.push({ kind: "virtual", box });
   }
   for (const box of collapsed.boxes) {
+    if (nestedBoxIds.has(box.id)) continue;
     rootUnits.push({ kind: "box", box });
   }
   const lineOf = (u) => u.kind === "shape" ? u.node.lineNumber : u.box.lineNumber;
@@ -274,7 +386,7 @@ function layoutSketch(parsed, options = {}) {
     }
     return unitRect(c, r);
   };
-  const occupied = [];
+  const occupied = new Occupancy();
   const placedAt = /* @__PURE__ */ new Map();
   const pending = [];
   for (const unit of rootUnits) {
@@ -285,7 +397,7 @@ function layoutSketch(parsed, options = {}) {
     }
     const base = rectFor(unit, at.c, at.r);
     let spot = { c: at.c, r: at.r };
-    if (flags.resolveOverlap && unit.kind === "shape" && collidesAny(base, occupied)) {
+    if (flags.resolveOverlap && unit.kind === "shape" && occupied.hits(base)) {
       const freed = nearestFree(base, occupied);
       spot = {
         c: at.c + (freed.c - base.c),
@@ -293,28 +405,28 @@ function layoutSketch(parsed, options = {}) {
       };
       overlapWarn(unit.node.lineNumber, unit.node.label);
     }
-    occupied.push(rectFor(unit, spot.c, spot.r));
+    occupied.add(rectFor(unit, spot.c, spot.r));
     placedAt.set(unit, spot);
   }
   if (!flags.flowPlaceUnpositioned) {
     for (const unit of pending) {
-      occupied.push(rectFor(unit, 0, 0));
+      occupied.add(rectFor(unit, 0, 0));
       placedAt.set(unit, { c: 0, r: 0 });
     }
     pending.length = 0;
   }
-  let flowRow = occupied.length > 0 ? Math.ceil(Math.max(...occupied.map((o) => o.r + o.h))) : 0;
+  let flowRow = occupied.rects.length > 0 ? Math.ceil(Math.max(...occupied.rects.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
+    occupied.rects.length > 0 ? Math.ceil(Math.max(...occupied.rects.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);
+      if (!occupied.hits(rect)) {
+        occupied.add(rect);
         placedAt.set(unit, { c: flowCol, r: flowRow });
         placed = true;
       }
@@ -409,6 +521,64 @@ function layoutSketch(parsed, options = {}) {
         maxX = origin.x + SKETCH_FOOT_W;
         maxY = minY;
       }
+      for (const inner of local.boxes) {
+        const innerBox = boxById.get(inner.boxId);
+        const innerLocal = boxLocal.get(inner.boxId);
+        if (!innerBox || !innerLocal) continue;
+        const innerRectOrigin = toPx(spot.c + inner.c, spot.r + inner.r);
+        const innerContentX = innerRectOrigin.x + SKETCH_GEOMETRY.boxPadPx - innerLocal.extent.c * SKETCH_HALF_SLOT_X;
+        const innerContentY = innerRectOrigin.y + SKETCH_GEOMETRY.bandPx - innerLocal.extent.r * SKETCH_HALF_SLOT_Y;
+        let iMinX = Infinity;
+        let iMinY = Infinity;
+        let iMaxX = -Infinity;
+        let iMaxY = -Infinity;
+        for (const gc of innerLocal.children) {
+          const gx = innerContentX + gc.c * SKETCH_HALF_SLOT_X;
+          const gy = innerContentY + gc.r * SKETCH_HALF_SLOT_Y;
+          nodes.push({
+            id: gc.node.id,
+            label: gc.node.label,
+            shape: gc.node.shape,
+            metadata: gc.node.metadata,
+            ...gc.node.description && { description: gc.node.description },
+            boxLabel: innerBox.label,
+            lineNumber: gc.node.lineNumber,
+            slot: { c: spot.c + inner.c, r: spot.r + inner.r },
+            x: gx,
+            y: gy,
+            w: SKETCH_FOOT_W,
+            h: SKETCH_FOOT_H
+          });
+          iMinX = Math.min(iMinX, gx);
+          iMinY = Math.min(iMinY, gy);
+          iMaxX = Math.max(iMaxX, gx + SKETCH_FOOT_W);
+          iMaxY = Math.max(iMaxY, gy + SKETCH_FOOT_H);
+        }
+        if (iMinX === Infinity) {
+          iMinX = innerContentX;
+          iMinY = innerContentY + SKETCH_GEOMETRY.bandPx;
+          iMaxX = innerContentX + SKETCH_FOOT_W;
+          iMaxY = iMinY;
+        }
+        const iFrame = {
+          x: iMinX - SKETCH_GEOMETRY.boxPadPx,
+          y: iMinY - SKETCH_GEOMETRY.bandPx,
+          w: iMaxX - iMinX + 2 * SKETCH_GEOMETRY.boxPadPx,
+          h: iMaxY - iMinY + SKETCH_GEOMETRY.bandPx + SKETCH_GEOMETRY.boxPadPx
+        };
+        boxes.push({
+          id: innerBox.id,
+          label: innerBox.label,
+          metadata: innerBox.metadata,
+          lineNumber: innerBox.lineNumber,
+          ...iFrame,
+          bandH: SKETCH_GEOMETRY.bandPx
+        });
+        minX = Math.min(minX, iFrame.x);
+        minY = Math.min(minY, iFrame.y);
+        maxX = Math.max(maxX, iFrame.x + iFrame.w);
+        maxY = Math.max(maxY, iFrame.y + iFrame.h);
+      }
       boxes.push({
         id: unit.box.id,
         label: unit.box.label,
@@ -507,9 +677,13 @@ function layoutSketch(parsed, options = {}) {
     width = Math.max(width, b.x + b.w);
     height = Math.max(height, b.y + b.h);
   }
+  const orderedBoxes = [
+    ...boxes.filter((b) => !nestedBoxIds.has(b.id)),
+    ...boxes.filter((b) => nestedBoxIds.has(b.id))
+  ];
   return {
     nodes,
-    boxes,
+    boxes: orderedBoxes,
     edges: collapsed.edges,
     width,
     height,
@@ -532,4 +706,4 @@ export {
   SKETCH_AUTO_LAYOUT_DEFAULTS,
   layoutSketch
 };
-//# sourceMappingURL=chunk-6DYZ2JM6.js.map
+//# sourceMappingURL=chunk-FR5EVD2X.js.map

package/dist/{chunk-R5JPMW2F.js → chunk-FTTB64OJ.js}

@@ -51,7 +51,7 @@ import {
 } from "./chunk-KRTLS3G6.js";
 import {
   parseSketch
-} from "./chunk-TDHD3HNO.js";
+} from "./chunk-F4X5NVKY.js";
 import {
   parseSwimlane
 } from "./chunk-W7UBPARG.js";
@@ -89,7 +89,7 @@ import {
 } from "./chunk-ZM27UI5O.js";
 import {
   parseInfra
-} from "./chunk-2NRIGEHZ.js";
+} from "./chunk-46KVXDUJ.js";
 import {
   parseGantt
 } from "./chunk-TPN7RJOM.js";
@@ -106,7 +106,7 @@ import {
 import {
   looksLikeFlowchart,
   parseFlowchart
-} from "./chunk-DU3OIBQE.js";
+} from "./chunk-NWNSXHA5.js";
 import {
   looksLikeState,
   parseState
@@ -114,7 +114,7 @@ import {
 import {
   looksLikeClassDiagram,
   parseClassDiagram
-} from "./chunk-SUA56ZSB.js";
+} from "./chunk-LTTZX6RD.js";
 import {
   looksLikeERDiagram,
   parseERDiagram
@@ -1716,4 +1716,4 @@ export {
   knownChartTypeIds,
   parseDgmo
 };
-//# sourceMappingURL=chunk-R5JPMW2F.js.map
+//# sourceMappingURL=chunk-FTTB64OJ.js.map