@canvas-harness/core 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -284,15 +284,6 @@ var projectToNodeBoundary = (world, node) => {
 // 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;
@@ -336,55 +327,17 @@ var autoRouteControls = (sourceWorld, targetWorld, sourceNormalWorld, targetNorm
     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 };
+var sideToward = (node, towardWorld) => {
+  const local = worldToNodeLocal(towardWorld, node);
+  const halfW = node.w / 2;
+  const halfH = node.h / 2;
+  const dx = local.x - halfW;
+  const dy = local.y - halfH;
+  if (dx === 0 && dy === 0) return "e";
+  const tx = dx === 0 ? Number.POSITIVE_INFINITY : (dx > 0 ? halfW : -halfW) / dx;
+  const ty = dy === 0 ? Number.POSITIVE_INFINITY : (dy > 0 ? halfH : -halfH) / dy;
+  if (tx <= ty) return dx > 0 ? "e" : "w";
+  return dy > 0 ? "s" : "n";
 };
 
 // src/edges/clip.ts
@@ -647,8 +600,8 @@ var computeEdgeGeometry = (edge, getNode) => {
       targetNodeId
     };
   }
-  let sourceWorld = projectEndToWorld(edge.source, getNode);
-  let targetWorld = projectEndToWorld(edge.target, getNode);
+  const sourceWorld = projectEndToWorld(edge.source, getNode);
+  const targetWorld = projectEndToWorld(edge.target, getNode);
   if (!sourceWorld || !targetWorld) return null;
   let samples;
   if (edge.pathStyle === "bezier") {
@@ -657,25 +610,9 @@ 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(
-          sideOf(sourceNode, edge.source.localOffset.x, edge.source.localOffset.y)
-        ),
-        sourceNode.angle
-      ) : null;
-      const targetNormal = targetNode && isAttached(edge.target) ? rotateVecByAngle(
-        sideNormalLocal(
-          sideOf(targetNode, edge.target.localOffset.x, edge.target.localOffset.y)
-        ),
-        targetNode.angle
-      ) : null;
+      const sourceNormal = sourceNode ? rotateVecByAngle(sideNormalLocal(sideToward(sourceNode, targetWorld)), sourceNode.angle) : null;
+      const targetNormal = targetNode ? rotateVecByAngle(sideNormalLocal(sideToward(targetNode, sourceWorld)), targetNode.angle) : null;
       ({ c1, c2 } = autoRouteControls(sourceWorld, targetWorld, sourceNormal, targetNormal));
     }
     samples = samplesFor("bezier", sourceWorld, targetWorld, [c1, c2]);
@@ -2338,6 +2275,7 @@ var createDefaultTextareaEditor = ({
   wrap.style.borderRadius = "4px";
   wrap.style.background = style.backgroundColor ?? "#ffffff";
   wrap.style.zIndex = "20";
+  wrap.style.pointerEvents = "auto";
   const ta = document.createElement("textarea");
   ta.value = node.content ?? "";
   ta.spellcheck = false;
@@ -4786,7 +4724,13 @@ var paintAtomicRough = (rc, ctx, type, w, h, style, scale, theme, seed) => {
       strokeWidth,
       roughness,
       seed,
-      strokeLineDash: dash.length > 0 ? dash : void 0,
+      // Always pass an explicit array (empty = solid) so rough.js calls
+      // ctx.setLineDash() to a known state. Passing `undefined` makes
+      // rough skip that call, and the canvas inherits whatever the
+      // previous draw left behind — a transparent-stroke node's
+      // fill-derived outline would pick up the dash from an earlier
+      // dashed node in the same paint pass.
+      strokeLineDash: dash,
       curveStepCount: detail.curveStepCount,
       maxRandomnessOffset: detail.maxRandomnessOffset
     });
@@ -6812,6 +6756,7 @@ exports.shouldAutoFit = shouldAutoFit;
 exports.shouldRejectTouch = shouldRejectTouch;
 exports.sideNormalLocal = sideNormalLocal;
 exports.sideOf = sideOf;
+exports.sideToward = sideToward;
 exports.sizeSurface = sizeSurface;
 exports.storeToJSON = storeToJSON;
 exports.subscribeFontEpoch = subscribeFontEpoch;