@diagrammo/dgmo 0.92.1 → 0.94.0

package/dist/chunk-7SXV7NUS.js

@@ -0,0 +1,416 @@
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  NOTE_GAP,
+  noteBoxSize,
+  noteConnectorPoints
+} from "./chunk-VDY2GR6U.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-NPWVOFB3.js → chunk-7WEYXYLC.js}

@@ -1,6 +1,6 @@
 import {
   stripInlineMarkdown
-} from "./chunk-S7W75MIM.js";
+} from "./chunk-QKPOIJBT.js";
 
 // src/utils/wrapped-desc.ts
 var BULLET_PREFIX = "\u2022 ";

package/dist/{chunk-GE7ICBX6.js → chunk-AM42TLSZ.js}

@@ -9,14 +9,14 @@ import {
   rectsOverlap,
   segmentRectOverlap
 } from "./chunk-KMU65FYM.js";
-import {
-  compactNumber,
-  computeLegendLayout
-} from "./chunk-JILEYZ2V.js";
 import {
   TITLE_FONT_SIZE,
   TITLE_Y
 } from "./chunk-VLC6WNRD.js";
+import {
+  compactNumber,
+  computeLegendLayout
+} from "./chunk-JILEYZ2V.js";
 import {
   tagAttrKey
 } from "./chunk-4SACN2C5.js";
@@ -620,6 +620,88 @@ function layoutEdgeLabels(args) {
   return chosen;
 }
 
+// src/map/dot-labels.ts
+var DOT_LABEL_GAP = 3;
+function dotLabelRect(dot, w, h, side) {
+  const GAP2 = DOT_LABEL_GAP;
+  switch (side) {
+    case "right":
+      return { x: dot.cx + dot.r + GAP2, y: dot.cy - h / 2, w, h };
+    case "left":
+      return { x: dot.cx - dot.r - GAP2 - w, y: dot.cy - h / 2, w, h };
+    case "above":
+      return { x: dot.cx - w / 2, y: dot.cy - dot.r - GAP2 - h, w, h };
+    case "below":
+      return { x: dot.cx - w / 2, y: dot.cy + dot.r + GAP2, w, h };
+    // Diagonal corners: offset both axes by (r+GAP)/√2 so the box's near
+    // corner clears the dot rim by the same gap as a cardinal side.
+    case "below-right": {
+      const d = (dot.r + GAP2) * 0.7071;
+      return { x: dot.cx + d, y: dot.cy + d, w, h };
+    }
+    case "below-left": {
+      const d = (dot.r + GAP2) * 0.7071;
+      return { x: dot.cx - d - w, y: dot.cy + d, w, h };
+    }
+    case "above-right": {
+      const d = (dot.r + GAP2) * 0.7071;
+      return { x: dot.cx + d, y: dot.cy - d - h, w, h };
+    }
+    case "above-left": {
+      const d = (dot.r + GAP2) * 0.7071;
+      return { x: dot.cx - d - w, y: dot.cy - d - h, w, h };
+    }
+  }
+}
+function dotLabelFits(rect, width, height, collides) {
+  return rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect);
+}
+var CLEAR_CAP = 48;
+var CLEAR_W = 8;
+var WATER_W = 0.25;
+var LEGIBILITY = {
+  right: 160,
+  left: 160,
+  above: 100,
+  below: 100,
+  "below-right": 0,
+  "below-left": 0,
+  "above-right": 0,
+  "above-left": 0
+};
+var ALL_SIDES = Object.keys(LEGIBILITY);
+function ptSegDist(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  let t = len2 > 0 ? ((px - ax) * dx + (py - ay) * dy) / len2 : 0;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+function clearanceOf(rect, ownId, dots, segments) {
+  const cxL = rect.x + rect.w / 2;
+  const cyL = rect.y + rect.h / 2;
+  let d = CLEAR_CAP;
+  for (const q of dots) {
+    if (q.id === ownId) continue;
+    d = Math.min(d, Math.hypot(q.cx - cxL, q.cy - cyL) - q.r);
+  }
+  for (const s of segments)
+    d = Math.min(d, ptSegDist(cxL, cyL, s[0], s[1], s[2], s[3]));
+  return Math.max(0, d);
+}
+function placeDotLabel(args) {
+  const { dot, w, h, width, height, collides, dots, segments, openness } = args;
+  let best = null;
+  for (const side of ALL_SIDES) {
+    const rect = dotLabelRect(dot, w, h, side);
+    if (!dotLabelFits(rect, width, height, collides)) continue;
+    const v = CLEAR_W * clearanceOf(rect, dot.id, dots, segments) + WATER_W * openness(rect) + LEGIBILITY[side];
+    if (best === null || v > best.v) best = { side, rect, v };
+  }
+  return best && { side: best.side, rect: best.rect };
+}
+
 // src/map/connectors.ts
 var W_MIN = 1.25;
 var W_MAX = 8;
@@ -2920,7 +3002,7 @@ function layoutMap(resolvedIn, data, size, opts) {
       const text = labelText(p);
       return { text, w: measureLegendText(text, FONT2) };
     };
-    const GAP2 = 3;
+    const GAP2 = DOT_LABEL_GAP;
     const POI_EDGE_CLEAR = Math.max(
       20,
       Math.round(Math.min(width, height) * 0.03)
@@ -2932,46 +3014,7 @@ function layoutMap(resolvedIn, data, size, opts) {
       if (arr) arr.push(p);
       else clusterMembersById.set(p.clusterId, [p]);
     }
-    const inlineRect = (p, w, side) => {
-      switch (side) {
-        case "right":
-          return { x: p.cx + p.r + GAP2, y: p.cy - poiLabH / 2, w, h: poiLabH };
-        case "left":
-          return {
-            x: p.cx - p.r - GAP2 - w,
-            y: p.cy - poiLabH / 2,
-            w,
-            h: poiLabH
-          };
-        case "above":
-          return {
-            x: p.cx - w / 2,
-            y: p.cy - p.r - GAP2 - poiLabH,
-            w,
-            h: poiLabH
-          };
-        case "below":
-          return { x: p.cx - w / 2, y: p.cy + p.r + GAP2, w, h: poiLabH };
-        // Diagonal corners: offset both axes by (r+GAP)/√2 so the box's near
-        // corner clears the dot rim by the same gap as a cardinal side.
-        case "below-right": {
-          const d = (p.r + GAP2) * 0.7071;
-          return { x: p.cx + d, y: p.cy + d, w, h: poiLabH };
-        }
-        case "below-left": {
-          const d = (p.r + GAP2) * 0.7071;
-          return { x: p.cx - d - w, y: p.cy + d, w, h: poiLabH };
-        }
-        case "above-right": {
-          const d = (p.r + GAP2) * 0.7071;
-          return { x: p.cx + d, y: p.cy - d - poiLabH, w, h: poiLabH };
-        }
-        case "above-left": {
-          const d = (p.r + GAP2) * 0.7071;
-          return { x: p.cx - d - w, y: p.cy - d - poiLabH, w, h: poiLabH };
-        }
-      }
-    };
+    const inlineRect = (p, w, side) => dotLabelRect(p, w, poiLabH, side);
     const pushInline = (p, text, w, side, clusterId) => {
       const rect = inlineRect(p, w, side);
       obstacles.push(rect);
@@ -2992,10 +3035,6 @@ function layoutMap(resolvedIn, data, size, opts) {
         ...clusterId !== void 0 && { clusterMember: clusterId }
       });
     };
-    const inlineFits = (p, w, side) => {
-      const rect = inlineRect(p, w, side);
-      return rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect);
-    };
     const GROUP_R = 30;
     const groups2 = [];
     for (const p of ordered) {
@@ -3135,7 +3174,7 @@ function layoutMap(resolvedIn, data, size, opts) {
         ];
         const side = order.find((s) => {
           const rect = inlineRect(p, w, s);
-          return rect.x >= 0 && rect.x + rect.w <= width && rect.y >= 0 && rect.y + rect.h <= height && !collides(rect) && !temp.some((t) => rectsOverlap(t, rect));
+          return dotLabelFits(rect, width, height, collides) && !temp.some((t) => rectsOverlap(t, rect));
         });
         if (side === void 0) return false;
         temp.push(inlineRect(p, w, side));
@@ -3154,62 +3193,28 @@ function layoutMap(resolvedIn, data, size, opts) {
       const side = cleanR && cleanL ? defaultColumnSide(items) : cleanR ? "right" : cleanL ? "left" : defaultColumnSide(items);
       commitColumn(items, side, clusterId);
     }
-    const CLEAR_CAP = 48;
-    const CLEAR_W = 8;
-    const WATER_W = 0.25;
-    const ptSegDist = (px, py, ax, ay, bx, by) => {
-      const dx = bx - ax;
-      const dy = by - ay;
-      const len2 = dx * dx + dy * dy;
-      let t = len2 > 0 ? ((px - ax) * dx + (py - ay) * dy) / len2 : 0;
-      t = Math.max(0, Math.min(1, t));
-      return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
-    };
-    const clearanceOf = (rect, ownId) => {
-      const cxL = rect.x + rect.w / 2;
-      const cyL = rect.y + rect.h / 2;
-      let d = CLEAR_CAP;
-      for (const q of pois) {
-        if (q.id === ownId) continue;
-        d = Math.min(d, Math.hypot(q.cx - cxL, q.cy - cyL) - q.r);
-      }
-      for (const s of legSegments)
-        d = Math.min(d, ptSegDist(cxL, cyL, s[0], s[1], s[2], s[3]));
-      return Math.max(0, d);
-    };
-    const LEGIBILITY = {
-      right: 160,
-      left: 160,
-      above: 100,
-      below: 100,
-      "below-right": 0,
-      "below-left": 0,
-      "above-right": 0,
-      "above-left": 0
-    };
-    const ALL_SIDES = Object.keys(LEGIBILITY);
-    const placementScore = (p, w, side) => {
-      const rect = inlineRect(p, w, side);
-      return CLEAR_W * clearanceOf(rect, p.id) + WATER_W * openness(rect) + LEGIBILITY[side];
-    };
     const maxExtent = MAX_CLUSTER_EXTENT_FACTOR * Math.min(width, height);
     const clusterPending = [];
     for (const g of groups2) {
       const items = makeItems(g);
       if (g.length === 1) {
         const { p, text, w } = items[0];
-        const scored = ALL_SIDES.filter((s) => inlineFits(p, w, s)).map(
-          (s) => ({
-            s,
-            v: placementScore(p, w, s)
-          })
-        );
-        if (scored.length === 0) {
+        const placed = placeDotLabel({
+          dot: p,
+          w,
+          h: poiLabH,
+          width,
+          height,
+          collides,
+          dots: pois,
+          segments: legSegments,
+          openness
+        });
+        if (placed === null) {
           commitColumn(items, defaultColumnSide(items));
           continue;
         }
-        const side = scored.reduce((b, c) => c.v > b.v ? c : b).s;
-        pushInline(p, text, w, side);
+        pushInline(p, text, w, placed.side);
         continue;
       }
       const left = Math.min(...items.map((o) => o.p.cx - o.p.r));