@cardenelabs/cdl 0.30.1 → 0.30.2

package/dist/react.cjs

@@ -2015,6 +2015,234 @@ function resolveEdgeLabelOverlapsWithChainAndPropagate(edges, obstacles, minClea
     edgePathShifts: edgePathShiftMap
   };
 }
+function resolveLabelClearanceAfterPathPasses(edges, obstacles, maxIter = 8) {
+  if (edges.length === 0) return edges;
+  const labeledIds = new Set(
+    edges.filter((e) => e.label?.trim() || e.sub?.trim()).map((e) => e.id)
+  );
+  if (labeledIds.size === 0) return edges;
+  const \u7BB1\u305F\u3061 = obstacles.filter((o) => o.kind === "node" || o.kind === "lane-label");
+  const edgeById = /* @__PURE__ */ new Map();
+  for (const e of edges) edgeById.set(e.id, e);
+  const \u533A\u9593cache = /* @__PURE__ */ new Map();
+  const \u533A\u9593 = (id, d) => {
+    const hit = \u533A\u9593cache.get(id);
+    if (hit) return hit;
+    const segs = flattenPathSegments(extractPathSegments(d));
+    \u533A\u9593cache.set(id, segs);
+    return segs;
+  };
+  const \u5916\u63A5cache = /* @__PURE__ */ new Map();
+  const \u5916\u63A5 = (id, d) => {
+    const hit = \u5916\u63A5cache.get(id);
+    if (hit !== void 0) return hit;
+    const segs = \u533A\u9593(id, d);
+    if (segs.length === 0) {
+      \u5916\u63A5cache.set(id, null);
+      return null;
+    }
+    let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+    for (const g of segs) {
+      x1 = Math.min(x1, g.x1, g.x2);
+      y1 = Math.min(y1, g.y1, g.y2);
+      x2 = Math.max(x2, g.x1, g.x2);
+      y2 = Math.max(y2, g.y1, g.y2);
+    }
+    const box = { x: x1, y: y1, w: x2 - x1, h: y2 - y1 };
+    \u5916\u63A5cache.set(id, box);
+    return box;
+  };
+  const \u9060\u3044 = (box, edgeId, d, \u4F59\u88D5) => {
+    const b = \u5916\u63A5(edgeId, d);
+    if (!b) return true;
+    const dx = Math.max(0, Math.max(box.x - (b.x + b.w), b.x - (box.x + box.w)));
+    const dy = Math.max(0, Math.max(box.y - (b.y + b.h), b.y - (box.y + box.h)));
+    return Math.hypot(dx, dy) >= \u4F59\u88D5;
+  };
+  const \u6700\u5927\u79FB\u52D5 = CHAIN_SHIFT_MAX_ACCUMULATED * 2;
+  const shiftMap = /* @__PURE__ */ new Map();
+  const getShift = (id) => shiftMap.get(id) ?? { dx: 0, dy: 0 };
+  const labelBBoxes = () => {
+    const out = [];
+    for (const e of edges) {
+      if (!labeledIds.has(e.id)) continue;
+      const base = computeLabelBBoxWorld(e);
+      const s = getShift(e.id);
+      out.push({ kind: "edge-label", id: e.id, x: base.x + s.dx, y: base.y + s.dy, w: base.w, h: base.h });
+    }
+    return out;
+  };
+  const \u96E2\u308C\u91CF = (a, b) => ({
+    x: Math.max(a.x - (b.x + b.w), b.x - (a.x + a.w)),
+    y: Math.max(a.y - (b.y + b.h), b.y - (a.y + a.h))
+  });
+  const \u52D5\u304B\u3057\u305F\u7BB1 = (box, axis, sign, amount) => ({
+    ...box,
+    x: box.x + (axis === "x" ? sign * amount : 0),
+    y: box.y + (axis === "y" ? sign * amount : 0)
+  });
+  for (let iter = 0; iter < maxIter; iter += 1) {
+    const labels = labelBBoxes();
+    const \u672D\u306E\u8981\u6C42 = requiredNearClearance("edge-label", "edge-label");
+    let \u52D5\u3044\u305F = false;
+    const \u4ECA\u56DE\u52D5\u304B\u3057\u305F = /* @__PURE__ */ new Set();
+    const \u5B89\u5168\u304B = (label, \u884C\u304D\u5148) => {
+      for (const obs of \u7BB1\u305F\u3061) {
+        const \u524D = computeGap(label, obs);
+        const \u5F8C = computeGap(\u884C\u304D\u5148, obs);
+        if (\u5F8C < Math.min(\u524D, requiredNearClearance("edge-label", obs.kind))) return false;
+      }
+      for (const \u4ED6 of labels) {
+        if (\u4ED6.id === label.id) continue;
+        const \u524D = computeGap(label, \u4ED6);
+        const \u5F8C = computeGap(\u884C\u304D\u5148, \u4ED6);
+        if (\u5F8C < Math.min(\u524D, \u672D\u306E\u8981\u6C42)) return false;
+      }
+      const \u81EA\u5206 = edgeById.get(label.id);
+      const \u81EA\u5206\u306E\u533A\u9593 = \u81EA\u5206 ? \u533A\u9593(\u81EA\u5206.id, \u81EA\u5206.d) : [];
+      if (\u81EA\u5206\u306E\u533A\u9593.length > 0) {
+        const \u524D = measurePathLabelGapSegs(\u81EA\u5206\u306E\u533A\u9593, label);
+        const \u5F8C = measurePathLabelGapSegs(\u81EA\u5206\u306E\u533A\u9593, \u884C\u304D\u5148);
+        if (\u5F8C > Math.max(\u524D, DIST_LABEL_PATH_MAX)) return false;
+      }
+      for (const \u76F8\u624B of edges) {
+        if (\u76F8\u624B.id === label.id) continue;
+        if (\u9060\u3044(label, \u76F8\u624B.id, \u76F8\u624B.d, LABEL_TO_PATH_CLEARANCE) && \u9060\u3044(\u884C\u304D\u5148, \u76F8\u624B.id, \u76F8\u624B.d, LABEL_TO_PATH_CLEARANCE)) continue;
+        const segs = segmentsExcludingOwnPath(\u533A\u9593(\u76F8\u624B.id, \u76F8\u624B.d), \u81EA\u5206\u306E\u533A\u9593);
+        if (segs.length === 0) continue;
+        const \u524D = measurePathLabelGapSegs(segs, label);
+        const \u5F8C = measurePathLabelGapSegs(segs, \u884C\u304D\u5148);
+        if (\u5F8C < Math.min(\u524D, LABEL_TO_PATH_CLEARANCE)) return false;
+      }
+      return true;
+    };
+    const \u9003\u304C\u3059 = (label, \u5019\u88DC) => {
+      for (const c of \u5019\u88DC.slice().sort((a, b) => a.amount - b.amount)) {
+        if (c.amount <= 0) continue;
+        const \u884C\u304D\u5148 = \u52D5\u304B\u3057\u305F\u7BB1(label, c.axis, c.sign, c.amount);
+        if (!\u5B89\u5168\u304B(label, \u884C\u304D\u5148)) continue;
+        const cur = getShift(label.id);
+        const dx = c.axis === "x" ? cur.dx + c.sign * c.amount : cur.dx;
+        const dy = c.axis === "y" ? cur.dy + c.sign * c.amount : cur.dy;
+        if (Math.hypot(dx, dy) > \u6700\u5927\u79FB\u52D5) continue;
+        shiftMap.set(label.id, { dx, dy });
+        \u4ECA\u56DE\u52D5\u304B\u3057\u305F.add(label.id);
+        return true;
+      }
+      return false;
+    };
+    const \u77E9\u5F62\u306E\u5019\u88DC = (label, static\u7BB1, required) => {
+      const sep = \u96E2\u308C\u91CF(label, static\u7BB1);
+      const \u5411\u304D = (axis) => {
+        const a = axis === "x" ? label.x + label.w / 2 : label.y + label.h / 2;
+        const b = axis === "x" ? static\u7BB1.x + static\u7BB1.w / 2 : static\u7BB1.y + static\u7BB1.h / 2;
+        return a >= b ? 1 : -1;
+      };
+      return [
+        { axis: "x", sign: \u5411\u304D("x"), amount: required - sep.x + NEAR_MISS_MARGIN },
+        { axis: "y", sign: \u5411\u304D("y"), amount: required - sep.y + NEAR_MISS_MARGIN }
+      ];
+    };
+    for (const label of labels) {
+      if (\u4ECA\u56DE\u52D5\u304B\u3057\u305F.has(label.id)) continue;
+      for (const obs of \u7BB1\u305F\u3061) {
+        const required = requiredNearClearance(label.kind, obs.kind);
+        if (required <= 0) continue;
+        if (computeGap(label, obs) >= required) continue;
+        if (\u9003\u304C\u3059(label, \u77E9\u5F62\u306E\u5019\u88DC(label, obs, required))) {
+          \u52D5\u3044\u305F = true;
+          break;
+        }
+      }
+    }
+    const \u672D\u9806 = /* @__PURE__ */ new Map();
+    edges.forEach((e, i) => \u672D\u9806.set(e.id, i));
+    for (let i = 0; i < labels.length; i += 1) {
+      for (let j = i + 1; j < labels.length; j += 1) {
+        const a = labels[i];
+        const b = labels[j];
+        if (computeGap(a, b) >= \u672D\u306E\u8981\u6C42) continue;
+        const aIsLater = \u672D\u9806.get(a.id) > \u672D\u9806.get(b.id);
+        const moveBox = aIsLater ? a : b;
+        const staticBox = aIsLater ? b : a;
+        if (\u4ECA\u56DE\u52D5\u304B\u3057\u305F.has(moveBox.id)) continue;
+        if (\u9003\u304C\u3059(moveBox, \u77E9\u5F62\u306E\u5019\u88DC(moveBox, staticBox, \u672D\u306E\u8981\u6C42))) \u52D5\u3044\u305F = true;
+      }
+    }
+    for (const label of labels) {
+      if (\u4ECA\u56DE\u52D5\u304B\u3057\u305F.has(label.id)) continue;
+      const \u81EA\u5206 = edgeById.get(label.id);
+      if (!\u81EA\u5206) continue;
+      const \u81EA\u5206\u306E\u533A\u9593 = \u533A\u9593(\u81EA\u5206.id, \u81EA\u5206.d);
+      for (const \u4ED6 of edges) {
+        if (\u4ED6.id === label.id) continue;
+        if (\u81EA\u5206.from === \u4ED6.from && \u81EA\u5206.to === \u4ED6.to) continue;
+        if (\u9060\u3044(label, \u4ED6.id, \u4ED6.d, LABEL_TO_PATH_CLEARANCE)) continue;
+        const segs = segmentsExcludingOwnPath(\u533A\u9593(\u4ED6.id, \u4ED6.d), \u81EA\u5206\u306E\u533A\u9593);
+        if (segs.length === 0) continue;
+        const gap = measurePathLabelGapSegs(segs, label);
+        if (gap >= LABEL_TO_PATH_CLEARANCE) continue;
+        const \u82AF = { x: label.x + label.w / 2, y: label.y + label.h / 2 };
+        let \u8FD1\u3044\u70B9 = null;
+        let \u6700\u77ED = Infinity;
+        for (const seg of segs) {
+          for (const \u70B9 of [
+            { x: seg.x1, y: seg.y1 },
+            { x: seg.x2, y: seg.y2 },
+            { x: (seg.x1 + seg.x2) / 2, y: (seg.y1 + seg.y2) / 2 }
+          ]) {
+            const d = Math.hypot(\u70B9.x - \u82AF.x, \u70B9.y - \u82AF.y);
+            if (d < \u6700\u77ED) {
+              \u6700\u77ED = d;
+              \u8FD1\u3044\u70B9 = \u70B9;
+            }
+          }
+        }
+        if (!\u8FD1\u3044\u70B9) continue;
+        const \u5FC5\u8981\u91CF = (axis, sign) => {
+          const \u6E80\u305F\u3059 = (\u91CF) => measurePathLabelGapSegs(segs, \u52D5\u304B\u3057\u305F\u7BB1(label, axis, sign, \u91CF)) >= LABEL_TO_PATH_CLEARANCE;
+          let lo = 0;
+          let hi = Math.max(4, LABEL_TO_PATH_CLEARANCE - gap);
+          while (!\u6E80\u305F\u3059(hi)) {
+            if (hi >= \u6700\u5927\u79FB\u52D5) return null;
+            lo = hi;
+            hi = Math.min(hi * 2, \u6700\u5927\u79FB\u52D5);
+          }
+          for (let k = 0; k < 12; k += 1) {
+            const mid = (lo + hi) / 2;
+            if (\u6E80\u305F\u3059(mid)) hi = mid;
+            else lo = mid;
+          }
+          return hi + NEAR_MISS_MARGIN;
+        };
+        const dx = \u82AF.x - \u8FD1\u3044\u70B9.x;
+        const dy = \u82AF.y - \u8FD1\u3044\u70B9.y;
+        const \u5019\u88DC = [];
+        for (const c of [
+          { axis: "x", sign: dx >= 0 ? 1 : -1 },
+          { axis: "y", sign: dy >= 0 ? 1 : -1 },
+          // 近い点から離れる向きが塞がれていることがある。 反対向きも候補に入れる。
+          { axis: "x", sign: dx >= 0 ? -1 : 1 },
+          { axis: "y", sign: dy >= 0 ? -1 : 1 }
+        ]) {
+          const \u91CF = \u5FC5\u8981\u91CF(c.axis, c.sign);
+          if (\u91CF !== null) \u5019\u88DC.push({ ...c, amount: \u91CF });
+        }
+        if (\u9003\u304C\u3059(label, \u5019\u88DC)) {
+          \u52D5\u3044\u305F = true;
+          break;
+        }
+      }
+    }
+    if (!\u52D5\u3044\u305F) break;
+  }
+  if (shiftMap.size === 0) return edges;
+  return edges.map((e) => {
+    const s = shiftMap.get(e.id);
+    if (!s || s.dx === 0 && s.dy === 0) return e;
+    return { ...e, labelX: e.labelX + s.dx, labelY: e.labelY + s.dy };
+  });
+}
 function applyEdgeLabelAndPathShifts(edges, labelShiftMap, edgePathShiftMap) {
   if (labelShiftMap.size === 0 && edgePathShiftMap.size === 0) return edges;
   return edges.map((e) => {
@@ -9089,6 +9317,14 @@ function layout(diag) {
   hopEdgeCrossings(edges);
   repositionParallelLabels(edges, nodesFinal);
   slideLabelsAlongOwnPath(edges, nodesFinal);
+  if (!isChainEdgeLabelDisabled()) {
+    edges = resolveLabelClearanceAfterPathPasses(
+      edges,
+      collectBBoxes(containedLanesFinal, nodesFinal, []).filter(
+        (b) => b.kind === "node" || b.kind === "lane-label"
+      )
+    );
+  }
   const bboxes = collectBBoxes(containedLanesFinal, nodesFinal, edges);
   const collisions = detectCollisions(bboxes, edges);
   const nearCollisions = detectNearCollisions(bboxes, edges);