@canvas-harness/core 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -233,53 +233,6 @@ var rotatePoint = (px, py, cx, cy, cos, sin) => {
   return { x: cx + dx * cos - dy * sin, y: cy + dx * sin + dy * cos };
 };
 
-// src/edges/auto-route.ts
-var CONTROL_MAX = 200;
-var CONTROL_FRACTION = 0.4;
-var sideOf = (node, localX, localY) => {
-  const distLeft = localX;
-  const distRight = node.w - localX;
-  const distTop = localY;
-  const distBottom = node.h - localY;
-  const minDist = Math.min(distLeft, distRight, distTop, distBottom);
-  if (minDist === distLeft) return "w";
-  if (minDist === distRight) return "e";
-  if (minDist === distTop) return "n";
-  return "s";
-};
-var sideNormalLocal = (side) => {
-  switch (side) {
-    case "n":
-      return { x: 0, y: -1 };
-    case "s":
-      return { x: 0, y: 1 };
-    case "e":
-      return { x: 1, y: 0 };
-    case "w":
-      return { x: -1, y: 0 };
-  }
-};
-var rotateVecByAngle = (v, angle) => {
-  if (angle === 0) return v;
-  const cos = Math.cos(angle);
-  const sin = Math.sin(angle);
-  return { x: v.x * cos - v.y * sin, y: v.x * sin + v.y * cos };
-};
-var autoRouteControls = (sourceWorld, targetWorld, sourceNormalWorld, targetNormalWorld) => {
-  const dx = targetWorld.x - sourceWorld.x;
-  const dy = targetWorld.y - sourceWorld.y;
-  const dist = Math.hypot(dx, dy);
-  const offset = Math.min(CONTROL_MAX, CONTROL_FRACTION * dist);
-  const fallbackSource = dist > 0 ? { x: dx / dist, y: dy / dist } : { x: 1, y: 0 };
-  const fallbackTarget = dist > 0 ? { x: -dx / dist, y: -dy / dist } : { x: -1, y: 0 };
-  const ns = sourceNormalWorld ?? fallbackSource;
-  const nt = targetNormalWorld ?? fallbackTarget;
-  return {
-    c1: { x: sourceWorld.x + ns.x * offset, y: sourceWorld.y + ns.y * offset },
-    c2: { x: targetWorld.x + nt.x * offset, y: targetWorld.y + nt.y * offset }
-  };
-};
-
 // src/edges/project.ts
 var projectEndToWorld = (end, getNode) => {
   if (!isAttached(end)) return end.worldPoint;
@@ -328,6 +281,112 @@ var projectToNodeBoundary = (world, node) => {
   return { x: clampedX, y: node.h };
 };
 
+// src/edges/auto-route.ts
+var CONTROL_MAX = 200;
+var CONTROL_FRACTION = 0.4;
+var BOUNDARY_EPS = 0.5;
+var isLocalOffsetInsideBody = (localOffset, node) => {
+  const onLeft = Math.abs(localOffset.x) <= BOUNDARY_EPS;
+  const onRight = Math.abs(localOffset.x - node.w) <= BOUNDARY_EPS;
+  const onTop = Math.abs(localOffset.y) <= BOUNDARY_EPS;
+  const onBottom = Math.abs(localOffset.y - node.h) <= BOUNDARY_EPS;
+  const inside = localOffset.x > -BOUNDARY_EPS && localOffset.x < node.w + BOUNDARY_EPS && localOffset.y > -BOUNDARY_EPS && localOffset.y < node.h + BOUNDARY_EPS;
+  return inside && !onLeft && !onRight && !onTop && !onBottom;
+};
+var sideOf = (node, localX, localY) => {
+  const distLeft = localX;
+  const distRight = node.w - localX;
+  const distTop = localY;
+  const distBottom = node.h - localY;
+  const minDist = Math.min(distLeft, distRight, distTop, distBottom);
+  if (minDist === distLeft) return "w";
+  if (minDist === distRight) return "e";
+  if (minDist === distTop) return "n";
+  return "s";
+};
+var sideNormalLocal = (side) => {
+  switch (side) {
+    case "n":
+      return { x: 0, y: -1 };
+    case "s":
+      return { x: 0, y: 1 };
+    case "e":
+      return { x: 1, y: 0 };
+    case "w":
+      return { x: -1, y: 0 };
+  }
+};
+var rotateVecByAngle = (v, angle) => {
+  if (angle === 0) return v;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  return { x: v.x * cos - v.y * sin, y: v.x * sin + v.y * cos };
+};
+var autoRouteControls = (sourceWorld, targetWorld, sourceNormalWorld, targetNormalWorld) => {
+  const dx = targetWorld.x - sourceWorld.x;
+  const dy = targetWorld.y - sourceWorld.y;
+  const dist = Math.hypot(dx, dy);
+  const offset = Math.min(CONTROL_MAX, CONTROL_FRACTION * dist);
+  const fallbackSource = dist > 0 ? { x: dx / dist, y: dy / dist } : { x: 1, y: 0 };
+  const fallbackTarget = dist > 0 ? { x: -dx / dist, y: -dy / dist } : { x: -1, y: 0 };
+  const ns = sourceNormalWorld ?? fallbackSource;
+  const nt = targetNormalWorld ?? fallbackTarget;
+  return {
+    c1: { x: sourceWorld.x + ns.x * offset, y: sourceWorld.y + ns.y * offset },
+    c2: { x: targetWorld.x + nt.x * offset, y: targetWorld.y + nt.y * offset }
+  };
+};
+var computeAsymmetricRoute = (sourceNode, targetNode) => {
+  const srcCenterWorld = {
+    x: sourceNode.x + sourceNode.w / 2,
+    y: sourceNode.y + sourceNode.h / 2
+  };
+  const srcInTgtLocal = worldToNodeLocal(srcCenterWorld, targetNode);
+  const tgtHalfW = targetNode.w / 2;
+  const tgtHalfH = targetNode.h / 2;
+  const dxNorm = (srcInTgtLocal.x - tgtHalfW) / Math.max(1, tgtHalfW);
+  const dyNorm = (srcInTgtLocal.y - tgtHalfH) / Math.max(1, tgtHalfH);
+  const targetSide = Math.abs(dxNorm) >= Math.abs(dyNorm) ? dxNorm > 0 ? "e" : "w" : dyNorm > 0 ? "s" : "n";
+  let tgtEntryLocal;
+  if (targetSide === "n" || targetSide === "s") {
+    const sideY = targetSide === "n" ? 0 : targetNode.h;
+    const clampX = Math.max(0, Math.min(targetNode.w, srcInTgtLocal.x));
+    tgtEntryLocal = { x: clampX, y: sideY };
+  } else {
+    const sideX = targetSide === "w" ? 0 : targetNode.w;
+    const clampY = Math.max(0, Math.min(targetNode.h, srcInTgtLocal.y));
+    tgtEntryLocal = { x: sideX, y: clampY };
+  }
+  const targetEntryWorld = nodeLocalToWorld(tgtEntryLocal, targetNode);
+  const tgtEntryInSrcLocal = worldToNodeLocal(targetEntryWorld, sourceNode);
+  const srcHalfW = sourceNode.w / 2;
+  const srcHalfH = sourceNode.h / 2;
+  const rayDx = tgtEntryInSrcLocal.x - srcHalfW;
+  const rayDy = tgtEntryInSrcLocal.y - srcHalfH;
+  const tx = rayDx === 0 ? Number.POSITIVE_INFINITY : (rayDx > 0 ? srcHalfW : -srcHalfW) / rayDx;
+  const ty = rayDy === 0 ? Number.POSITIVE_INFINITY : (rayDy > 0 ? srcHalfH : -srcHalfH) / rayDy;
+  const t = Math.min(tx, ty);
+  const srcExitLocal = {
+    x: srcHalfW + rayDx * t,
+    y: srcHalfH + rayDy * t
+  };
+  const sourceExitWorld = nodeLocalToWorld(srcExitLocal, sourceNode);
+  const dxWorld = targetEntryWorld.x - sourceExitWorld.x;
+  const dyWorld = targetEntryWorld.y - sourceExitWorld.y;
+  const distance2 = Math.hypot(dxWorld, dyWorld);
+  const offset = Math.min(CONTROL_MAX, CONTROL_FRACTION * distance2);
+  const c1 = distance2 > 0 ? {
+    x: sourceExitWorld.x + dxWorld / distance2 * offset,
+    y: sourceExitWorld.y + dyWorld / distance2 * offset
+  } : { ...sourceExitWorld };
+  const tgtNormalWorld = rotateVecByAngle(sideNormalLocal(targetSide), targetNode.angle);
+  const c2 = {
+    x: targetEntryWorld.x + tgtNormalWorld.x * offset,
+    y: targetEntryWorld.y + tgtNormalWorld.y * offset
+  };
+  return { source: sourceExitWorld, target: targetEntryWorld, c1, c2 };
+};
+
 // src/edges/clip.ts
 var fullVisibleClipResult = (samples) => ({
   startIndex: 0,
@@ -588,8 +647,8 @@ var computeEdgeGeometry = (edge, getNode) => {
       targetNodeId
     };
   }
-  const sourceWorld = projectEndToWorld(edge.source, getNode);
-  const targetWorld = projectEndToWorld(edge.target, getNode);
+  let sourceWorld = projectEndToWorld(edge.source, getNode);
+  let targetWorld = projectEndToWorld(edge.target, getNode);
   if (!sourceWorld || !targetWorld) return null;
   let samples;
   if (edge.pathStyle === "bezier") {
@@ -598,6 +657,12 @@ var computeEdgeGeometry = (edge, getNode) => {
     if (edge.control && edge.control.length >= 2) {
       c1 = edge.control[0];
       c2 = edge.control[1];
+    } else if (sourceNode && targetNode && isAttached(edge.source) && isAttached(edge.target) && isLocalOffsetInsideBody(edge.source.localOffset, sourceNode) && isLocalOffsetInsideBody(edge.target.localOffset, targetNode)) {
+      const r = computeAsymmetricRoute(sourceNode, targetNode);
+      sourceWorld = r.source;
+      targetWorld = r.target;
+      c1 = r.c1;
+      c2 = r.c2;
     } else {
       const sourceNormal = sourceNode && isAttached(edge.source) ? rotateVecByAngle(
         sideNormalLocal(
@@ -1607,7 +1672,7 @@ var buildPath = (type, x, y, w, h, radius) => {
 };
 
 // src/text/tokens.ts
-var INLINE_PATTERN = /(\$[^$\n]+?\$|\*\*[^*]+\*\*|==[^=\s](?:[^=]*?[^=\s])?==|`[^`]+`|\*[^*]+\*|__[^_]+__|~~[^~]+~~|_[^_]+_|\[[^\]]+\]\([^)]+\))/g;
+var INLINE_PATTERN = /(\$\$[^\n]+?\$\$|\*\*[^*]+\*\*|==[^=\s](?:[^=]*?[^=\s])?==|`[^`]+`|\*[^*]+\*|__[^_]+__|~~[^~]+~~|_[^_]+_|\[[^\]]+\]\([^)]+\))/g;
 var HR_LINE_PATTERN = /^[ \t]*---[ \t]*$/;
 var DOUBLE_HR_LINE_PATTERN = /^[ \t]*===[ \t]*$/;
 var transformSymbols = (value) => value.replace(/<=>|<->|<-|->|\[\]|\[[vx]\]/gi, (match) => {
@@ -1645,8 +1710,8 @@ var tokenizeInline = (segment) => {
       tokens.push({ type: "link", content: transformSymbols(match.slice(1, splitIndex)) });
     } else if (match.startsWith("`") && match.endsWith("`")) {
       tokens.push({ type: "code", content: match.slice(1, -1) });
-    } else if (match.startsWith("$") && match.endsWith("$")) {
-      tokens.push({ type: "math", content: match.slice(1, -1) });
+    } else if (match.startsWith("$$") && match.endsWith("$$")) {
+      tokens.push({ type: "math", content: match.slice(2, -2) });
     } else {
       tokens.push({ type: "text", content: transformSymbols(match) });
     }