@skygraph/core 0.4.0 → 0.5.1

package/dist/graph.cjs

@@ -22,12 +22,17 @@ var graph_exports = {};
 __export(graph_exports, {
   aabbFromOBB: () => aabbFromOBB,
   createGraph: () => createGraph,
+  floatingAnchor: () => floatingAnchor,
   getBezierPath: () => getBezierPath,
+  getEdgePosition: () => getEdgePosition,
+  getNodeIntersection: () => getNodeIntersection,
+  inferSide: () => inferSide,
   nearestSide: () => nearestSide,
   obbContainsPoint: () => obbContainsPoint,
   obbCorners: () => obbCorners,
   pointsToPath: () => pointsToPath,
   pointsToRoundedPath: () => pointsToRoundedPath,
+  resolveEdgeEndpoint: () => resolveEdgeEndpoint,
   routeOrthogonal: () => routeOrthogonal
 });
 module.exports = __toCommonJS(graph_exports);
@@ -660,22 +665,27 @@ function createGraph(core, options) {
 function routeOrthogonal(start, end, options) {
   const opts = typeof options === "string" ? { preferred: options } : options ?? {};
   const gridSize = opts.gridSize ?? 10;
-  const stubLength = opts.stubLength ?? Math.max(8, gridSize);
+  const stubLength = opts.stubLength ?? Math.max(20, gridSize);
+  const stepPosition = opts.stepPosition ?? 0.5;
   let sExit = null;
   let sStub = null;
   let sCorner = null;
+  let sSide = null;
   if (opts.sourceBounds) {
-    const exitInfo = exitOnNearestSide(opts.sourceBounds, end);
+    const exitInfo = exitOnNearestSide(opts.sourceBounds, end, start);
     sExit = exitInfo.point;
+    sSide = exitInfo.side;
     sStub = extrudePoint(exitInfo.point, exitInfo.side, stubLength);
     sCorner = orthoBridge(start, sExit, exitInfo.side);
   }
   let tExit = null;
   let tStub = null;
   let tCorner = null;
+  let tSide = null;
   if (opts.targetBounds) {
-    const enterInfo = exitOnNearestSide(opts.targetBounds, start);
+    const enterInfo = exitOnNearestSide(opts.targetBounds, start, end);
     tExit = enterInfo.point;
+    tSide = enterInfo.side;
     tStub = extrudePoint(enterInfo.point, enterInfo.side, stubLength);
     tCorner = orthoBridge(end, tExit, enterInfo.side);
   }
@@ -685,8 +695,12 @@ function routeOrthogonal(start, end, options) {
   const filteredObstacles = obstacles.length > 0 && (opts.sourceBounds || opts.targetBounds) ? obstacles.filter((o) => o !== opts.sourceBounds && o !== opts.targetBounds) : obstacles;
   let core;
   if (filteredObstacles.length === 0) {
-    const snap2 = opts.snap ?? gridSize;
-    core = lRoute(coreStart, coreEnd, opts.preferred ?? "auto", snap2);
+    if (sSide && tSide) {
+      core = smoothStepRoute(coreStart, sSide, coreEnd, tSide, stepPosition);
+    } else {
+      const snap2 = opts.snap ?? gridSize;
+      core = lRoute(coreStart, coreEnd, opts.preferred ?? "auto", snap2);
+    }
   } else {
     const inflate = opts.inflate ?? 0;
     const maxNodes = opts.maxNodes ?? 5e3;
@@ -710,6 +724,68 @@ function routeOrthogonal(start, end, options) {
   if (!pointsEqual(end, points[points.length - 1])) pushIfDistinct(points, end);
   return compressCollinear(points);
 }
+function smoothStepRoute(coreStart, sSide, coreEnd, tSide, stepPosition) {
+  const [sx, sy] = coreStart;
+  const [tx, ty] = coreEnd;
+  const sAxis = sideAxis(sSide);
+  const tAxis = sideAxis(tSide);
+  const sDir = sideDir(sSide);
+  const tDir = sideDir(tSide);
+  if (sAxis === tAxis) {
+    if (sDir + tDir === 0) {
+      if (sAxis === "x") {
+        const cx = sx + (tx - sx) * stepPosition;
+        return [
+          [sx, sy],
+          [cx, sy],
+          [cx, ty],
+          [tx, ty]
+        ];
+      }
+      const cy = sy + (ty - sy) * stepPosition;
+      return [
+        [sx, sy],
+        [sx, cy],
+        [tx, cy],
+        [tx, ty]
+      ];
+    }
+    if (sAxis === "x") {
+      const extX = sDir > 0 ? Math.max(sx, tx) : Math.min(sx, tx);
+      return [
+        [sx, sy],
+        [extX, sy],
+        [extX, ty],
+        [tx, ty]
+      ];
+    }
+    const extY = sDir > 0 ? Math.max(sy, ty) : Math.min(sy, ty);
+    return [
+      [sx, sy],
+      [sx, extY],
+      [tx, extY],
+      [tx, ty]
+    ];
+  }
+  if (sAxis === "x") {
+    return [
+      [sx, sy],
+      [tx, sy],
+      [tx, ty]
+    ];
+  }
+  return [
+    [sx, sy],
+    [sx, ty],
+    [tx, ty]
+  ];
+}
+function sideAxis(s) {
+  return s === "left" || s === "right" ? "x" : "y";
+}
+function sideDir(s) {
+  return s === "right" || s === "bottom" ? 1 : -1;
+}
 function pointsToPath(points) {
   if (points.length === 0) return "";
   const [head, ...rest] = points;
@@ -769,6 +845,31 @@ function getBezierPath(opts) {
   const [c2x, c2y] = controlPoint(opts.targetSide, tx, ty, sx, sy, curvature);
   return `M ${sx} ${sy} C ${c1x} ${c1y} ${c2x} ${c2y} ${tx} ${ty}`;
 }
+function floatingAnchor(box, opposite) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const dx = opposite[0] - cx;
+  const dy = opposite[1] - cy;
+  if (dx === 0 && dy === 0) {
+    return { point: [box.x + box.w, cy], side: "right" };
+  }
+  const hw = box.w / 2;
+  const hh = box.h / 2;
+  const tx = dx === 0 ? Infinity : hw / Math.abs(dx);
+  const ty = dy === 0 ? Infinity : hh / Math.abs(dy);
+  if (tx < ty) {
+    const sign2 = dx > 0 ? 1 : -1;
+    return {
+      point: [cx + sign2 * hw, cy + sign2 * (hw / Math.abs(dx)) * dy],
+      side: sign2 > 0 ? "right" : "left"
+    };
+  }
+  const sign = dy > 0 ? 1 : -1;
+  return {
+    point: [cx + sign * (hh / Math.abs(dy)) * dx, cy + sign * hh],
+    side: sign > 0 ? "bottom" : "top"
+  };
+}
 function nearestSide(box, target) {
   const cx = box.x + box.w / 2;
   const cy = box.y + box.h / 2;
@@ -777,9 +878,107 @@ function nearestSide(box, target) {
   if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
   return dy >= 0 ? "bottom" : "top";
 }
-function exitOnNearestSide(box, target) {
+function getNodeIntersection(intersectionBox, targetCenter) {
+  const w = intersectionBox.w / 2;
+  const h = intersectionBox.h / 2;
+  const x2 = intersectionBox.x + w;
+  const y2 = intersectionBox.y + h;
+  if (w === 0 || h === 0) return [x2, y2];
+  const x1 = targetCenter[0];
+  const y1 = targetCenter[1];
+  const xx1 = (x1 - x2) / (2 * w) - (y1 - y2) / (2 * h);
+  const yy1 = (x1 - x2) / (2 * w) + (y1 - y2) / (2 * h);
+  const denom = Math.abs(xx1) + Math.abs(yy1);
+  if (denom === 0) {
+    return [intersectionBox.x + intersectionBox.w, y2];
+  }
+  const a = 1 / denom;
+  const xx3 = a * xx1;
+  const yy3 = a * yy1;
+  const x = w * (xx3 + yy3) + x2;
+  const y = h * (-xx3 + yy3) + y2;
+  return [x, y];
+}
+function getEdgePosition(box, intersectionPoint) {
+  const nx = Math.round(box.x);
+  const ny = Math.round(box.y);
+  const px = Math.round(intersectionPoint[0]);
+  const py = Math.round(intersectionPoint[1]);
+  if (px <= nx + 1) return "left";
+  if (px >= nx + box.w - 1) return "right";
+  if (py <= ny + 1) return "top";
+  if (py >= ny + box.h - 1) return "bottom";
+  return "top";
+}
+function resolveEdgeEndpoint(sourceBox, targetBox, padding = 0) {
+  const targetCenter = [targetBox.x + targetBox.w / 2, targetBox.y + targetBox.h / 2];
+  const raw = getNodeIntersection(sourceBox, targetCenter);
+  const side = getEdgePosition(sourceBox, raw);
+  if (padding === 0) return { point: raw, side };
+  let point = raw;
+  switch (side) {
+    case "right":
+      point = [raw[0] + padding, raw[1]];
+      break;
+    case "left":
+      point = [raw[0] - padding, raw[1]];
+      break;
+    case "bottom":
+      point = [raw[0], raw[1] + padding];
+      break;
+    case "top":
+      point = [raw[0], raw[1] - padding];
+      break;
+  }
+  return { point, side };
+}
+function inferSide(box, anchor, opposite, tolerance = 1) {
+  const onLeft = Math.abs(anchor[0] - box.x) <= tolerance;
+  const onRight = Math.abs(anchor[0] - (box.x + box.w)) <= tolerance;
+  const onTop = Math.abs(anchor[1] - box.y) <= tolerance;
+  const onBottom = Math.abs(anchor[1] - (box.y + box.h)) <= tolerance;
+  const horizontalHit = onLeft || onRight;
+  const verticalHit = onTop || onBottom;
+  if (horizontalHit && verticalHit) {
+    const cx = box.x + box.w / 2;
+    const cy = box.y + box.h / 2;
+    const dx = opposite[0] - cx;
+    const dy = opposite[1] - cy;
+    if (Math.abs(dx) >= Math.abs(dy)) {
+      return { side: onRight ? "right" : "left", confident: true };
+    }
+    return { side: onBottom ? "bottom" : "top", confident: true };
+  }
+  if (onLeft) return { side: "left", confident: true };
+  if (onRight) return { side: "right", confident: true };
+  if (onTop) return { side: "top", confident: true };
+  if (onBottom) return { side: "bottom", confident: true };
+  return { side: nearestSide(box, opposite), confident: false };
+}
+function exitOnNearestSide(box, target, anchor) {
   const cx = box.x + box.w / 2;
   const cy = box.y + box.h / 2;
+  if (anchor) {
+    const tolerance = 1;
+    const onLeft = Math.abs(anchor[0] - box.x) <= tolerance;
+    const onRight = Math.abs(anchor[0] - (box.x + box.w)) <= tolerance;
+    const onTop = Math.abs(anchor[1] - box.y) <= tolerance;
+    const onBottom = Math.abs(anchor[1] - (box.y + box.h)) <= tolerance;
+    const horizontalHit = onLeft || onRight;
+    const verticalHit = onTop || onBottom;
+    if (horizontalHit && verticalHit) {
+      const dx2 = target[0] - cx;
+      const dy2 = target[1] - cy;
+      if (Math.abs(dx2) >= Math.abs(dy2)) {
+        return onRight ? { point: [box.x + box.w, cy], side: "right" } : { point: [box.x, cy], side: "left" };
+      }
+      return onBottom ? { point: [cx, box.y + box.h], side: "bottom" } : { point: [cx, box.y], side: "top" };
+    }
+    if (onRight) return { point: [box.x + box.w, cy], side: "right" };
+    if (onLeft) return { point: [box.x, cy], side: "left" };
+    if (onBottom) return { point: [cx, box.y + box.h], side: "bottom" };
+    if (onTop) return { point: [cx, box.y], side: "top" };
+  }
   const dx = target[0] - cx;
   const dy = target[1] - cy;
   if (Math.abs(dx) >= Math.abs(dy)) {
@@ -1054,12 +1253,17 @@ function obbContainsPoint(obb, p) {
 0 && (module.exports = {
   aabbFromOBB,
   createGraph,
+  floatingAnchor,
   getBezierPath,
+  getEdgePosition,
+  getNodeIntersection,
+  inferSide,
   nearestSide,
   obbContainsPoint,
   obbCorners,
   pointsToPath,
   pointsToRoundedPath,
+  resolveEdgeEndpoint,
   routeOrthogonal
 });
 //# sourceMappingURL=graph.cjs.map