@weasel-js/core 1.9.4 → 1.10.0

package/dist/affordances/hitAffordanceRegions.js

@@ -1,96 +1,54 @@
-import { poseRotationOf as e } from "../core/geometry/poseRotation.js";
-import { pxExtent as t, scaleDelta as n, screenAngleOf as r, standoff as i } from "../core/viewport/pxExtent.js";
+import { IDENTITY_TARGET as e, angleOf as t, localToWorld as n, normalToWorld as r, pxExtentIn as i, targetTransformOf as a, worldToLocal as o } from "../core/geometry/targetFrame.js";
+import { scaleDelta as s, screenAngleOf as c, standoff as l } from "@weasel-js/geom";
 //#region src/affordances/hitAffordanceRegions.ts
-function a(e, t, n, r, i, a) {
-	for (let s = e.length - 1; s >= 0; s--) {
-		let l = e[s];
-		if (a && !a(l.id)) continue;
-		let u = l.regions(r), d = null;
-		for (let e = 0; e < u.length; e++) {
-			let a = u[e], s = c(r, a.targetId);
-			if (!_(a, t, n, s, i)) continue;
-			let l = o(a, t, n, s, i);
-			(d === null || l <= d.d2) && (d = {
+function u(e, t, n, r, i, a) {
+	for (let o = e.length - 1; o >= 0; o--) {
+		let s = e[o];
+		if (a && !a(s.id)) continue;
+		let c = s.regions(r), l = null;
+		for (let e = 0; e < c.length; e++) {
+			let a = c[e], o = f(r, a.targetId);
+			if (!v(a, t, n, o, i)) continue;
+			let s = d(a, t, n, o, i);
+			(l === null || s <= l.d2) && (l = {
 				region: a,
-				d2: l
+				d2: s
 			});
 		}
-		if (d) return {
-			affordanceId: l.id,
-			regionId: d.region.id,
-			region: d.region,
-			binding: d.region.bind()
+		if (l) return {
+			affordanceId: s.id,
+			regionId: l.region.id,
+			region: l.region,
+			binding: l.region.bind()
 		};
 	}
 	return null;
 }
-function o(e, t, n, r, i) {
-	let a = e.shape, o = a.kind === "point" ? h(a, r, i) : a.kind === "annulus" ? u(r, a.cx, a.cy) : u(r, a.x + a.width / 2, a.y + a.height / 2), s = o.x - t, c = o.y - n;
-	return s * s + c * c;
+function d(e, t, r, i, a) {
+	let o = e.shape, s = o.kind === "point" ? g(o, i, a) : o.kind === "annulus" ? n(i, o.cx, o.cy) : n(i, o.x + o.width / 2, o.y + o.height / 2), c = s.x - t, l = s.y - r;
+	return c * c + l * l;
 }
-var s = {
-	cx: 0,
-	cy: 0,
-	cos: 1,
-	sin: 0,
-	identity: !0
-};
-function c(t, n) {
-	if (n === null) return s;
-	let r = t.boundsOf(n);
-	if (!r) return s;
-	let i = e(r);
-	return i ? {
-		cx: i.cx,
-		cy: i.cy,
-		cos: Math.cos(i.rotation),
-		sin: Math.sin(i.rotation),
-		identity: !1
-	} : s;
+function f(t, n) {
+	return n === null ? e : a(t.boundsOf(n));
 }
-function l(e) {
-	return e.identity ? 0 : Math.atan2(e.sin, e.cos);
-}
-function u(e, t, n) {
-	if (e.identity) return {
-		x: t,
-		y: n
-	};
-	let r = t - e.cx, i = n - e.cy;
-	return {
-		x: e.cx + e.cos * r - e.sin * i,
-		y: e.cy + e.sin * r + e.cos * i
-	};
-}
-function d(e, t, n) {
-	if (e.identity) return {
-		x: t,
-		y: n
-	};
-	let r = t - e.cx, i = n - e.cy;
-	return {
-		x: e.cx + e.cos * r + e.sin * i,
-		y: e.cy - e.sin * r + e.cos * i
-	};
-}
-function f(e, n, i) {
-	let a = h(e, n, i), o = e.turned ? r(l(n), i.scale) : 0, s = e.hitRadiusPx, c = [-s, s], u = [-s, s], d = e.cornerOf;
+function p(e, n, r) {
+	let a = g(e, n, r), o = e.turned ? c(t(n), r.scale) : 0, s = e.hitRadiusPx, l = [-s, s], u = [-s, s], d = e.cornerOf;
 	if (d) {
-		let e = t(p * s, i.scale, l(n)), r = d.outward.y * Math.sign(i.scale.x * i.scale.y);
-		d.width < e.x && (c[d.outward.x > 0 ? 0 : 1] = 0), d.height < e.y && (u[r > 0 ? 0 : 1] = 0);
+		let e = i(m * s, r.scale, n), [t, a, o, c] = n.toWorld, f = d.outward.y * Math.sign(r.scale.x * r.scale.y * (t * c - a * o));
+		d.width < e.x && (l[d.outward.x > 0 ? 0 : 1] = 0), d.height < e.y && (u[f > 0 ? 0 : 1] = 0);
 	}
 	return {
 		x: a.x,
 		y: a.y,
 		angle: o,
 		half: s,
-		u: c,
+		u: l,
 		v: u
 	};
 }
-var p = 4;
-function m(e, t, n, r) {
-	let i = f(e, t, n), [a, o] = r(i.x, i.y), s = Math.cos(i.angle), c = Math.sin(i.angle);
+var m = 4;
+function h(e, t, n, r) {
+	let i = p(e, t, n), [a, o] = r(i.x, i.y), s = Math.cos(i.angle), c = Math.sin(i.angle);
 	return [
 		[i.u[0], i.v[0]],
 		[i.u[1], i.v[0]],
@@ -101,45 +59,41 @@ function m(e, t, n, r) {
 		y: o + c * e + s * t
 	}));
 }
-function h(e, t, n) {
-	let r = u(t, e.x, e.y);
-	if (!e.standoff) return r;
-	let a = e.standoff.normal, o = t.identity ? a : {
-		x: t.cos * a.x - t.sin * a.y,
-		y: t.sin * a.x + t.cos * a.y
-	};
-	return i(r, o, e.standoff.px, n.scale);
+function g(e, t, i) {
+	let a = n(t, e.x, e.y);
+	return e.standoff ? l(a, r(t, e.standoff.normal), e.standoff.px, i.scale) : a;
 }
-function g(e, n, r = 0) {
-	let i = e.minBandPx ?? 0;
-	if (i === 0) return {
-		rx: e.rx,
-		ry: e.ry
+function _(t, n, r = e) {
+	let a = t.minBandPx ?? 0;
+	if (a === 0) return {
+		rx: t.rx,
+		ry: t.ry
 	};
-	let a = t(i, n.scale, r);
+	let o = i(a, n.scale, r);
 	return {
-		rx: Math.max(e.rx, e.innerWidth / 2 + a.x),
-		ry: Math.max(e.ry, e.innerHeight / 2 + a.y)
+		rx: Math.max(t.rx, t.innerWidth / 2 + o.x),
+		ry: Math.max(t.ry, t.innerHeight / 2 + o.y)
 	};
 }
-function _(e, t, r, i, a) {
-	let o = d(i, t, r);
+function v(e, t, n, r, i) {
 	if (e.shape.kind === "point") {
-		let o = f(e.shape, i, a), s = n(t - o.x, r - o.y, a.scale), c = Math.cos(o.angle), l = Math.sin(o.angle), u = c * s.x + l * s.y, d = -l * s.x + c * s.y;
-		return u >= o.u[0] && u <= o.u[1] && d >= o.v[0] && d <= o.v[1];
+		let a = p(e.shape, r, i), o = s(t - a.x, n - a.y, i.scale), c = Math.cos(a.angle), l = Math.sin(a.angle), u = c * o.x + l * o.y, d = -l * o.x + c * o.y;
+		return u >= a.u[0] && u <= a.u[1] && d >= a.v[0] && d <= a.v[1];
 	}
+	let a = o(r, t, n);
+	if (!a) return !1;
 	if (e.shape.kind === "annulus") {
 		let t = e.shape;
-		if (o.x >= t.innerX && o.x <= t.innerX + t.innerWidth && o.y >= t.innerY && o.y <= t.innerY + t.innerHeight) return !1;
-		let { rx: n, ry: r } = g(t, a, l(i));
-		if (n <= 0 || r <= 0) return !1;
-		let s = (o.x - t.cx) / n, c = (o.y - t.cy) / r;
+		if (a.x >= t.innerX && a.x <= t.innerX + t.innerWidth && a.y >= t.innerY && a.y <= t.innerY + t.innerHeight) return !1;
+		let { rx: n, ry: o } = _(t, i, r);
+		if (n <= 0 || o <= 0) return !1;
+		let s = (a.x - t.cx) / n, c = (a.y - t.cy) / o;
 		return s * s + c * c <= 1;
 	}
-	let s = e.shape;
-	return o.x >= s.x && o.x <= s.x + s.width && o.y >= s.y && o.y <= s.y + s.height;
+	let c = e.shape;
+	return a.x >= c.x && a.x <= c.x + c.width && a.y >= c.y && a.y <= c.y + c.height;
 }
 //#endregion
-export { l as angleOf, g as annulusSemiAxes, a as hitAffordanceRegions, u as localToWorld, h as pointRegionAnchor, f as pointRegionFrame, m as pointRegionScreenQuad, c as transformOf };
+export { t as angleOf, _ as annulusSemiAxes, u as hitAffordanceRegions, n as localToWorld, g as pointRegionAnchor, p as pointRegionFrame, h as pointRegionScreenQuad, f as transformOf };
 
 //# sourceMappingURL=hitAffordanceRegions.js.map

package/dist/affordances/hitAffordanceRegions.js.map

@@ -1 +1 @@
-{"version":3,"file":"hitAffordanceRegions.js","names":["hitAffordanceRegions","i","affordances","a","isVisible","regions","state","best","j","region","xf","transformOf","hitRegion","wx","wy","view","d2","regionDistance2","s","w","pointRegionAnchor","localToWorld","dx","dy","IDENTITY_XF","targetId","b","r","poseRotationOf","angleOf","lx","ly","worldToLocal","pointRegionFrame","shape","angle","screenAngleOf","half","u","v","body","floor","pxExtent","SMALL_BODY_RADII","vOut","pointRegionScreenQuad","f","cx","cy","toScreen","c","sn","n","wn","standoff","annulusSemiAxes","bandPx","band","rotation","local","d","scaleDelta","rx","ry","ex","ey"],"sources":["../../src/affordances/hitAffordanceRegions.ts"],"sourcesContent":["/**\n * The one affordance hit-test walk.\n *\n * The kit used to hit-test selection chrome two ways: this region walk\n * (reached through `composeAffordanceLayer`'s `RenderLayer.hitTest`) and a\n * hand-written classifier in `canvas/affordanceAt.ts` that re-derived corner\n * positions, the rotate ring, and anchor points from `ChromeState` itself.\n * Both read the same state and answered the same question, so the geometry\n * lived twice and could disagree — and only the hand-written side ran for the\n * kit's own chrome, which is why `AffordanceRegion.cursor` was declared, set,\n * and never consumed.\n *\n * Now there is one walk. `composeAffordanceLayer.hitTest` delegates here, and\n * so does `buildAffordanceAt`, so an affordance's `regions()` is the single\n * source of truth for where its chrome is and what a press on it means.\n */\n\nimport type { View } from 'core/viewport/view';\nimport { pxExtent, scaleDelta, screenAngleOf, standoff } from 'core/viewport/pxExtent';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport type { Affordance, AffordanceBinding, AffordanceRegion } from './types';\n\n/** What the walk found: the region, plus the ids needed to describe it. */\nexport interface AffordanceRegionHit {\n  /** `Affordance.id` — also the chrome-caps visibility id. */\n  affordanceId: string;\n  /** `AffordanceRegion.id`. */\n  regionId: string;\n  /** The region itself, so callers can read `hitKind` / `cursor`. */\n  region: AffordanceRegion;\n  /** Result of the region's `bind()`, called exactly once. */\n  binding: AffordanceBinding;\n}\n\n/**\n * Walk affordances for a world-space hit, topmost first.\n *\n * **Across affordances**: order mirrors paint. Affordances are drawn first →\n * last (bottom → top), so the walk runs last → first and stops at the first\n * one that claims the point. Layering wins outright — a nearer region on a\n * lower affordance does not beat a farther one on top of it.\n *\n * **Within an affordance**: the *nearest* hit region wins, ties going to the\n * later-declared one. Both hit-testers this replaced took the first region\n * they found instead, in opposite orders, which is only invisible while\n * regions don't overlap. They do: the four corner handles of a selection\n * smaller than the hit radius all contain the same click, and \"first in the\n * table\" silently answered top-left (or bottom-right) no matter which handle\n * the pointer was actually on.\n *\n * `isVisible` (when supplied) gates by the same chrome id used at paint time,\n * so chrome that isn't drawn can't be hit either.\n */\nexport function hitAffordanceRegions(\n  affordances: readonly Affordance[],\n  wx: number,\n  wy: number,\n  state: ChromeState,\n  view: View,\n  isVisible?: (id: string) => boolean,\n): AffordanceRegionHit | null {\n  for (let i = affordances.length - 1; i >= 0; i--) {\n    const a = affordances[i];\n    if (isVisible && !isVisible(a.id)) continue;\n    const regions = a.regions(state);\n    let best: { region: AffordanceRegion; d2: number } | null = null;\n    for (let j = 0; j < regions.length; j++) {\n      const region = regions[j];\n      const xf = transformOf(state, region.targetId);\n      if (!hitRegion(region, wx, wy, xf, view)) continue;\n      const d2 = regionDistance2(region, wx, wy, xf, view);\n      // `<=` so a later-declared region wins an exact tie, preserving the\n      // \"later is on top\" reading of declaration order.\n      if (best === null || d2 <= best.d2) best = { region, d2 };\n    }\n    if (best) {\n      return {\n        affordanceId: a.id,\n        regionId: best.region.id,\n        region: best.region,\n        binding: best.region.bind(),\n      };\n    }\n  }\n  return null;\n}\n\n/** Squared world distance from the point to a region's representative center,\n *  used only to rank regions that all already contain the point. */\nfunction regionDistance2(\n  region: AffordanceRegion,\n  wx: number,\n  wy: number,\n  xf: TargetTransform,\n  view: View,\n): number {\n  const s = region.shape;\n  const w = s.kind === 'point'\n    ? pointRegionAnchor(s, xf, view)\n    : s.kind === 'annulus'\n      ? localToWorld(xf, s.cx, s.cy)\n      : localToWorld(xf, s.x + s.width / 2, s.y + s.height / 2);\n  const dx = w.x - wx;\n  const dy = w.y - wy;\n  return dx * dx + dy * dy;\n}\n\n// ─── Transform helpers ──────────────────────────────────────────────────────\n\n/** Local↔world transform for an affordance target. Translation is the AABB\n *  origin; rotation is around the AABB center. `identity` short-circuits the\n *  math when the target isn't rotated. */\nexport interface TargetTransform {\n  /** Rotation pivot (AABB center) in world coords. */\n  cx: number;\n  cy: number;\n  /** cos(rotation) — 1 when identity. */\n  cos: number;\n  /** sin(rotation) — 0 when identity. */\n  sin: number;\n  identity: boolean;\n}\n\nconst IDENTITY_XF: TargetTransform = { cx: 0, cy: 0, cos: 1, sin: 0, identity: true };\n\nexport function transformOf(state: ChromeState, targetId: string | null): TargetTransform {\n  if (targetId === null) return IDENTITY_XF;\n  const b: Bounds | null = state.boundsOf(targetId);\n  if (!b) return IDENTITY_XF;\n  // Pivot + angle come from the kit's one rotation convention.\n  const r = poseRotationOf(b);\n  if (!r) return IDENTITY_XF;\n  return {\n    cx: r.cx,\n    cy: r.cy,\n    cos: Math.cos(r.rotation),\n    sin: Math.sin(r.rotation),\n    identity: false,\n  };\n}\n\n/** A target transform's rotation in radians, for cursors baked at an angle. */\nexport function angleOf(xf: TargetTransform): number {\n  return xf.identity ? 0 : Math.atan2(xf.sin, xf.cos);\n}\n\n/** local point → world point. */\nexport function localToWorld(xf: TargetTransform, lx: number, ly: number): { x: number; y: number } {\n  if (xf.identity) return { x: lx, y: ly };\n  const dx = lx - xf.cx;\n  const dy = ly - xf.cy;\n  return {\n    x: xf.cx + xf.cos * dx - xf.sin * dy,\n    y: xf.cy + xf.sin * dx + xf.cos * dy,\n  };\n}\n\n/** world point → local point. */\nfunction worldToLocal(xf: TargetTransform, wx: number, wy: number): { x: number; y: number } {\n  if (xf.identity) return { x: wx, y: wy };\n  const dx = wx - xf.cx;\n  const dy = wy - xf.cy;\n  // Inverse rotation: cos stays, sin negates.\n  return {\n    x: xf.cx + xf.cos * dx + xf.sin * dy,\n    y: xf.cy - xf.sin * dx + xf.cos * dy,\n  };\n}\n\n// ─── Shape resolution ───────────────────────────────────────────────────────\n\ntype PointShape = Extract<AffordanceRegion['shape'], { kind: 'point' }>;\n\n/** Where a point region's hit square sits: its center in world coords, its\n *  turn on screen, its screen half-extent, and the span of the square that\n *  takes a press along each of its own axes (`[-half, half]` unless\n *  `cornerOf` cuts it). Hit-test, paint, the debug hitbox and the slops\n *  overlay all read it from here. */\nexport function pointRegionFrame(\n  shape: PointShape,\n  xf: TargetTransform,\n  view: View,\n): { x: number; y: number; angle: number; half: number; u: [number, number]; v: [number, number] } {\n  const a = pointRegionAnchor(shape, xf, view);\n  const angle = shape.turned ? screenAngleOf(angleOf(xf), view.scale) : 0;\n  const half = shape.hitRadiusPx;\n  const u: [number, number] = [-half, half];\n  const v: [number, number] = [-half, half];\n  const body = shape.cornerOf;\n  if (body) {\n    // The body in world units that spans four hit radii on screen, per axis.\n    const floor = pxExtent(SMALL_BODY_RADII * half, view.scale, angleOf(xf));\n    // `v` runs a quarter turn on from `u` on screen, which is the target's +y\n    // only while the view keeps its handedness.\n    const vOut = body.outward.y * Math.sign(view.scale.x * view.scale.y);\n    if (body.width < floor.x) u[body.outward.x > 0 ? 0 : 1] = 0;\n    if (body.height < floor.y) v[vOut > 0 ? 0 : 1] = 0;\n  }\n  return { x: a.x, y: a.y, angle, half, u, v };\n}\n\n/** A body under this many hit radii across gives up the inward half of each\n *  corner's hit square, so there is somewhere on it that is not a handle. */\nconst SMALL_BODY_RADII = 4;\n\n/** A point region's hit square as four screen-space corners, relative to its\n *  world center carried to the screen by `toScreen`. */\nexport function pointRegionScreenQuad(\n  shape: PointShape,\n  xf: TargetTransform,\n  view: View,\n  toScreen: (x: number, y: number) => [number, number],\n): { x: number; y: number }[] {\n  const f = pointRegionFrame(shape, xf, view);\n  const [cx, cy] = toScreen(f.x, f.y);\n  const c = Math.cos(f.angle), sn = Math.sin(f.angle);\n  return [[f.u[0], f.v[0]], [f.u[1], f.v[0]], [f.u[1], f.v[1]], [f.u[0], f.v[1]]].map(([u, v]) => ({\n    x: cx + c * u - sn * v,\n    y: cy + sn * u + c * v,\n  }));\n}\n\n/** A point region's anchor in world coords, its `standoff` applied. */\nexport function pointRegionAnchor(\n  shape: PointShape,\n  xf: TargetTransform,\n  view: View,\n): { x: number; y: number } {\n  const a = localToWorld(xf, shape.x, shape.y);\n  if (!shape.standoff) return a;\n  const n = shape.standoff.normal;\n  const wn = xf.identity\n    ? n\n    : { x: xf.cos * n.x - xf.sin * n.y, y: xf.sin * n.x + xf.cos * n.y };\n  return standoff(a, wn, shape.standoff.px, view.scale);\n}\n\n/**\n * An annulus region's effective outer semi-axes, with `minBandPx` applied.\n *\n * The affordance declares the natural ellipse (typically the smallest one\n * containing the inner rect) plus a screen-space floor on band thickness;\n * this is where the floor becomes world units, because this is where the view\n * is known. Paint calls it too, so the visible ring and the hoverable ring\n * are the same ring.\n */\nexport function annulusSemiAxes(\n  shape: Extract<AffordanceRegion['shape'], { kind: 'annulus' }>,\n  view: View,\n  /** The target's rotation, which decides what a screen pixel is along each\n   *  of its axes. */\n  rotation = 0,\n): { rx: number; ry: number } {\n  const bandPx = shape.minBandPx ?? 0;\n  if (bandPx === 0) return { rx: shape.rx, ry: shape.ry };\n  const band = pxExtent(bandPx, view.scale, rotation);\n  return {\n    rx: Math.max(shape.rx, shape.innerWidth / 2 + band.x),\n    ry: Math.max(shape.ry, shape.innerHeight / 2 + band.y),\n  };\n}\n\n// ─── Per-shape hit-test ─────────────────────────────────────────────────────\n\nfunction hitRegion(\n  region: AffordanceRegion,\n  wx: number,\n  wy: number,\n  xf: TargetTransform,\n  view: View,\n): boolean {\n  const local = worldToLocal(xf, wx, wy);\n  if (region.shape.kind === 'point') {\n    // Square hit, not circular: the handle a `point` region paints is a\n    // square, and the hit zone should match what the user sees. (The old\n    // hand-written classifier used a circle here, which made the corners of\n    // an 8px handle unclickable.)\n    //\n    // Compared in screen space, where that square is axis-aligned. Testing it\n    // in the target's local frame instead would tilt it under a rotated\n    // target and stretch it under non-uniform zoom.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const d = scaleDelta(wx - f.x, wy - f.y, view.scale);\n    const c = Math.cos(f.angle), sn = Math.sin(f.angle);\n    const u = c * d.x + sn * d.y, v = -sn * d.x + c * d.y;\n    return u >= f.u[0] && u <= f.u[1] && v >= f.v[0] && v <= f.v[1];\n  }\n  if (region.shape.kind === 'annulus') {\n    const s = region.shape;\n    // Outside the inner-rect cutout?\n    const insideInner =\n      local.x >= s.innerX && local.x <= s.innerX + s.innerWidth &&\n      local.y >= s.innerY && local.y <= s.innerY + s.innerHeight;\n    if (insideInner) return false;\n    // Inside the outer ellipse? `((x-cx)/rx)² + ((y-cy)/ry)² ≤ 1`.\n    const { rx, ry } = annulusSemiAxes(s, view, angleOf(xf));\n    if (rx <= 0 || ry <= 0) return false;\n    const ex = (local.x - s.cx) / rx;\n    const ey = (local.y - s.cy) / ry;\n    return ex * ex + ey * ey <= 1;\n  }\n  // rect: axis-aligned in local frame.\n  const r = region.shape;\n  return local.x >= r.x && local.x <= r.x + r.width\n      && local.y >= r.y && local.y <= r.y + r.height;\n}\n"],"mappings":"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"}
+{"version":3,"file":"hitAffordanceRegions.js","names":["hitAffordanceRegions","i","affordances","a","isVisible","regions","state","best","j","region","xf","transformOf","hitRegion","wx","wy","view","d2","regionDistance2","s","w","pointRegionAnchor","localToWorld","dx","dy","targetId","IDENTITY_TARGET","targetTransformOf","pointRegionFrame","shape","angle","screenAngleOf","angleOf","half","u","v","body","floor","pxExtentIn","SMALL_BODY_RADII","b","c","d","vOut","pointRegionScreenQuad","f","cx","cy","toScreen","sn","standoff","normalToWorld","annulusSemiAxes","bandPx","band","scaleDelta","local","worldToLocal","rx","ry","ex","ey","r"],"sources":["../../src/affordances/hitAffordanceRegions.ts"],"sourcesContent":["/**\n * The one affordance hit-test walk: an affordance's `regions()` is the single\n * source of truth for where its chrome is and what a press on it means.\n */\n\nimport type { View } from 'core/viewport/view';\nimport { scaleDelta, screenAngleOf, standoff } from '@weasel-js/geom';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport {\n  angleOf, IDENTITY_TARGET, localToWorld, normalToWorld, pxExtentIn, targetTransformOf, worldToLocal,\n  type TargetTransform,\n} from 'core/geometry/targetFrame';\nimport type { Affordance, AffordanceBinding, AffordanceRegion } from './types';\n\n/** What the walk found: the region, plus the ids needed to describe it. */\nexport interface AffordanceRegionHit {\n  /** `Affordance.id` — also the chrome-caps visibility id. */\n  affordanceId: string;\n  /** `AffordanceRegion.id`. */\n  regionId: string;\n  /** The region itself, so callers can read `hitKind` / `cursor`. */\n  region: AffordanceRegion;\n  /** Result of the region's `bind()`, called exactly once. */\n  binding: AffordanceBinding;\n}\n\n/**\n * Walk affordances for a world-space hit, topmost first.\n *\n * **Across affordances**: order mirrors paint. Affordances are drawn first →\n * last (bottom → top), so the walk runs last → first and stops at the first\n * one that claims the point. Layering wins outright — a nearer region on a\n * lower affordance does not beat a farther one on top of it.\n *\n * **Within an affordance**: the *nearest* hit region wins, ties going to the\n * later-declared one. Regions overlap: the four corner handles of a selection\n * smaller than the hit radius all contain the same click.\n *\n * `isVisible` (when supplied) gates by the same chrome id used at paint time,\n * so chrome that isn't drawn can't be hit either.\n */\nexport function hitAffordanceRegions(\n  affordances: readonly Affordance[],\n  wx: number,\n  wy: number,\n  state: ChromeState,\n  view: View,\n  isVisible?: (id: string) => boolean,\n): AffordanceRegionHit | null {\n  for (let i = affordances.length - 1; i >= 0; i--) {\n    const a = affordances[i];\n    if (isVisible && !isVisible(a.id)) continue;\n    const regions = a.regions(state);\n    let best: { region: AffordanceRegion; d2: number } | null = null;\n    for (let j = 0; j < regions.length; j++) {\n      const region = regions[j];\n      const xf = transformOf(state, region.targetId);\n      if (!hitRegion(region, wx, wy, xf, view)) continue;\n      const d2 = regionDistance2(region, wx, wy, xf, view);\n      // `<=` so a later-declared region wins an exact tie, preserving the\n      // \"later is on top\" reading of declaration order.\n      if (best === null || d2 <= best.d2) best = { region, d2 };\n    }\n    if (best) {\n      return {\n        affordanceId: a.id,\n        regionId: best.region.id,\n        region: best.region,\n        binding: best.region.bind(),\n      };\n    }\n  }\n  return null;\n}\n\n/** Squared world distance from the point to a region's representative center,\n *  used only to rank regions that all already contain the point. */\nfunction regionDistance2(\n  region: AffordanceRegion,\n  wx: number,\n  wy: number,\n  xf: TargetTransform,\n  view: View,\n): number {\n  const s = region.shape;\n  const w = s.kind === 'point'\n    ? pointRegionAnchor(s, xf, view)\n    : s.kind === 'annulus'\n      ? localToWorld(xf, s.cx, s.cy)\n      : localToWorld(xf, s.x + s.width / 2, s.y + s.height / 2);\n  const dx = w.x - wx;\n  const dy = w.y - wy;\n  return dx * dx + dy * dy;\n}\n\n// ─── Transform helpers ──────────────────────────────────────────────────────\n\nexport { angleOf, localToWorld, type TargetTransform };\n\n/** The frame `targetId`'s bounds are drawn in; identity for no target. */\nexport function transformOf(state: ChromeState, targetId: string | null): TargetTransform {\n  if (targetId === null) return IDENTITY_TARGET;\n  return targetTransformOf(state.boundsOf(targetId));\n}\n\n// ─── Shape resolution ───────────────────────────────────────────────────────\n\ntype PointShape = Extract<AffordanceRegion['shape'], { kind: 'point' }>;\n\n/** Where a point region's hit square sits: its center in world coords, its\n *  turn on screen, its screen half-extent, and the span of the square that\n *  takes a press along each of its own axes (`[-half, half]` unless\n *  `cornerOf` cuts it). */\nexport function pointRegionFrame(\n  shape: PointShape,\n  xf: TargetTransform,\n  view: View,\n): { x: number; y: number; angle: number; half: number; u: [number, number]; v: [number, number] } {\n  const a = pointRegionAnchor(shape, xf, view);\n  const angle = shape.turned ? screenAngleOf(angleOf(xf), view.scale) : 0;\n  const half = shape.hitRadiusPx;\n  const u: [number, number] = [-half, half];\n  const v: [number, number] = [-half, half];\n  const body = shape.cornerOf;\n  if (body) {\n    // The body in world units that spans four hit radii on screen, per axis.\n    const floor = pxExtentIn(SMALL_BODY_RADII * half, view.scale, xf);\n    // `v` runs a quarter turn on from `u` on screen, which is the target's +y\n    // only while the view and the target's frame keep their handedness.\n    const [a, b, c, d] = xf.toWorld;\n    const vOut = body.outward.y * Math.sign(view.scale.x * view.scale.y * (a * d - b * c));\n    if (body.width < floor.x) u[body.outward.x > 0 ? 0 : 1] = 0;\n    if (body.height < floor.y) v[vOut > 0 ? 0 : 1] = 0;\n  }\n  return { x: a.x, y: a.y, angle, half, u, v };\n}\n\n/** A body under this many hit radii across gives up the inward half of each\n *  corner's hit square, so there is somewhere on it that is not a handle. */\nconst SMALL_BODY_RADII = 4;\n\n/** A point region's hit square as four screen-space corners, relative to its\n *  world center carried to the screen by `toScreen`. */\nexport function pointRegionScreenQuad(\n  shape: PointShape,\n  xf: TargetTransform,\n  view: View,\n  toScreen: (x: number, y: number) => [number, number],\n): { x: number; y: number }[] {\n  const f = pointRegionFrame(shape, xf, view);\n  const [cx, cy] = toScreen(f.x, f.y);\n  const c = Math.cos(f.angle), sn = Math.sin(f.angle);\n  return [[f.u[0], f.v[0]], [f.u[1], f.v[0]], [f.u[1], f.v[1]], [f.u[0], f.v[1]]].map(([u, v]) => ({\n    x: cx + c * u - sn * v,\n    y: cy + sn * u + c * v,\n  }));\n}\n\n/** A point region's anchor in world coords, its `standoff` applied. */\nexport function pointRegionAnchor(\n  shape: PointShape,\n  xf: TargetTransform,\n  view: View,\n): { x: number; y: number } {\n  const a = localToWorld(xf, shape.x, shape.y);\n  if (!shape.standoff) return a;\n  return standoff(a, normalToWorld(xf, shape.standoff.normal), shape.standoff.px, view.scale);\n}\n\n/**\n * An annulus region's effective outer semi-axes, in world units, with the\n * screen-space `minBandPx` floor on band thickness applied. Paint calls it\n * too, so the visible ring and the hoverable ring are the same ring.\n */\nexport function annulusSemiAxes(\n  shape: Extract<AffordanceRegion['shape'], { kind: 'annulus' }>,\n  view: View,\n  /** The target's frame, which decides what a screen pixel is along each of\n   *  its axes. */\n  xf: TargetTransform = IDENTITY_TARGET,\n): { rx: number; ry: number } {\n  const bandPx = shape.minBandPx ?? 0;\n  if (bandPx === 0) return { rx: shape.rx, ry: shape.ry };\n  const band = pxExtentIn(bandPx, view.scale, xf);\n  return {\n    rx: Math.max(shape.rx, shape.innerWidth / 2 + band.x),\n    ry: Math.max(shape.ry, shape.innerHeight / 2 + band.y),\n  };\n}\n\n// ─── Per-shape hit-test ─────────────────────────────────────────────────────\n\nfunction hitRegion(\n  region: AffordanceRegion,\n  wx: number,\n  wy: number,\n  xf: TargetTransform,\n  view: View,\n): boolean {\n  if (region.shape.kind === 'point') {\n    // Square hit, not circular: the handle a `point` region paints is a\n    // square, and a circle leaves its corners unclickable.\n    //\n    // Compared in screen space: testing it in the target's local frame would\n    // stretch it under non-uniform zoom.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const d = scaleDelta(wx - f.x, wy - f.y, view.scale);\n    const c = Math.cos(f.angle), sn = Math.sin(f.angle);\n    const u = c * d.x + sn * d.y, v = -sn * d.x + c * d.y;\n    return u >= f.u[0] && u <= f.u[1] && v >= f.v[0] && v <= f.v[1];\n  }\n  const local = worldToLocal(xf, wx, wy);\n  if (!local) return false;\n  if (region.shape.kind === 'annulus') {\n    const s = region.shape;\n    // Outside the inner-rect cutout?\n    const insideInner =\n      local.x >= s.innerX && local.x <= s.innerX + s.innerWidth &&\n      local.y >= s.innerY && local.y <= s.innerY + s.innerHeight;\n    if (insideInner) return false;\n    // Inside the outer ellipse? `((x-cx)/rx)² + ((y-cy)/ry)² ≤ 1`.\n    const { rx, ry } = annulusSemiAxes(s, view, xf);\n    if (rx <= 0 || ry <= 0) return false;\n    const ex = (local.x - s.cx) / rx;\n    const ey = (local.y - s.cy) / ry;\n    return ex * ex + ey * ey <= 1;\n  }\n  // rect: axis-aligned in local frame.\n  const r = region.shape;\n  return local.x >= r.x && local.x <= r.x + r.width\n      && local.y >= r.y && local.y <= r.y + r.height;\n}\n"],"mappings":"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"}

package/dist/affordances/pathAnchors.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathAnchors.js","names":["PATH_ANCHOR_CHROME_ID","createPathAnchorAffordances","opts","editablePaths","anchorState","getAnchorState","out","id","state","pose","point","hitRadius","scratch","editingId","a","enumerateAnchors","path"],"sources":["../../src/affordances/pathAnchors.ts"],"sourcesContent":["/**\n * Path anchor + control-handle affordances.\n *\n * These were the last piece of selection chrome whose geometry lived only\n * inside `canvas/affordanceAt.ts`'s hand-written classifier. Expressing them\n * as regions puts every kit affordance behind one hit-test walk, which is\n * what lets `AffordanceRegion.cursor` and nearest-region picking apply here\n * too rather than only to the chrome that happened to be declarative already.\n */\n\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors } from 'interactions/actions/edit-anchors/geometry';\n\n/**\n * Live anchor-editing state, read fresh on every hit-test.\n *\n * Anchors are not derivable from `ChromeState` — they come off the editable\n * path behind whatever the consumer's `editAnchors` dep exposes — so this\n * thunk is the seam. It's called on every pointer event, so it must be cheap\n * (O(1) field reads); enumeration happens inside `regions()`.\n */\nexport interface AnchorState {\n  /** Id of the path currently in anchor-edit mode, or `null`. Control handles\n   *  are only hittable on the path that is being edited. */\n  editingId: string | null;\n  /** Current editable path for a node id. Non-polygon values are ignored. */\n  getPose(id: string): unknown;\n}\n\n/** Options for the path-anchor affordances. */\nexport interface PathAnchorAffordanceOptions {\n  /** Hit radius (screen-px) for anchor and control points. Default 8. */\n  hitRadius?: number;\n  /** Cursor while hovering an anchor or control. Defaults to `'pointer'`. */\n  cursor?: CursorSpec;\n}\n\n/** What an anchor hit hands to the action that follows: which path, which\n *  anchor, and whether the grab was on the anchor itself or one of its two\n *  control points. */\nexport interface AnchorScratch extends CommonAffordanceScratch {\n  /** Node id of the path the anchor belongs to. */\n  targetId: string;\n  /** Sequential anchor index in path walk order. */\n  anchorIndex: number;\n  /** Which of the anchor's three grabbable points this is. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n}\n\n/** Chrome-caps id gating both returned affordances. */\nexport const PATH_ANCHOR_CHROME_ID = 'path-edit.anchors';\n\n/**\n * Anchor + control affordances for the selected paths, bottom → top.\n *\n * Returns **two** affordances rather than one so that a control handle beats\n * an anchor regardless of which is nearer — the same preference `hitAnchor`\n * encodes, and the same one the rendering has (controls draw on top). Within\n * each of the two, nearest wins. They deliberately share one id: chrome-caps\n * gates anchor editing as a single piece of chrome, and splitting the id\n * would invent a visibility rule nothing asked for.\n *\n * Order matters — spread this into an affordance list in the returned order.\n */\nexport function createPathAnchorAffordances(\n  getAnchorState: () => AnchorState | null,\n  opts: PathAnchorAffordanceOptions = {},\n): Affordance[] {\n  const { hitRadius = 8, cursor = 'pointer' } = opts;\n\n  /** Selected polygon paths, paired with their node id. */\n  const editablePaths = (state: ChromeState): Array<{ id: string; path: PolygonPath }> => {\n    const anchorState = getAnchorState();\n    if (!anchorState) return [];\n    const out: Array<{ id: string; path: PolygonPath }> = [];\n    for (const id of state.selection) {\n      const pose = anchorState.getPose(id);\n      if (!pose || (pose as { kind?: string }).kind !== 'polygon') continue;\n      out.push({ id, path: pose as PolygonPath });\n    }\n    return out;\n  };\n\n  const point = (\n    id: string,\n    targetId: string,\n    x: number,\n    y: number,\n    scratch: AnchorScratch,\n    hitKind: string,\n  ): AffordanceRegion => ({\n    id,\n    // Anchor coordinates are already in the path's own space, which for an\n    // editable path is world space — the pose rotation that `targetId` would\n    // introduce is baked into the coords. Anchoring to `null` keeps the\n    // framework from applying it twice.\n    targetId: null,\n    shape: { kind: 'point', x, y, hitRadiusPx: hitRadius },\n    hitKind,\n    cursor,\n    bind: (): AffordanceBinding => ({ initialScratch: { ...scratch, targetId } }),\n  });\n\n  const anchors: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const editingId = getAnchorState()?.editingId ?? null;\n      const out: AffordanceRegion[] = [];\n      for (const { id, path } of editablePaths(state)) {\n        // `editAnchorsAction` edits whatever path the dep says is in edit\n        // mode, ignoring which one was hit — so once a path IS being edited,\n        // only its own anchors may claim the press. The overlay paints only\n        // that path's anchors too.\n        if (editingId !== null && id !== editingId) continue;\n        for (const a of enumerateAnchors(path)) {\n          out.push(point(\n            `${id}:anchor:${a.anchorIndex}`,\n            id, a.x, a.y,\n            { targetId: id, anchorIndex: a.anchorIndex, part: 'anchor' },\n            `anchor:${a.anchorIndex}`,\n          ));\n        }\n      }\n      return out;\n    },\n  };\n\n  const controls: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const anchorState = getAnchorState();\n      const editingId = anchorState?.editingId ?? null;\n      if (editingId === null) return [];\n      const out: AffordanceRegion[] = [];\n      for (const { id, path } of editablePaths(state)) {\n        // Controls are grabbable only on the path actually in edit mode.\n        if (id !== editingId) continue;\n        for (const a of enumerateAnchors(path)) {\n          if (a.controlIn) {\n            out.push(point(\n              `${id}:controlIn:${a.anchorIndex}`,\n              id, a.controlIn.x, a.controlIn.y,\n              { targetId: id, anchorIndex: a.anchorIndex, part: 'controlIn' },\n              `controlIn:${a.anchorIndex}`,\n            ));\n          }\n          if (a.controlOut) {\n            out.push(point(\n              `${id}:controlOut:${a.anchorIndex}`,\n              id, a.controlOut.x, a.controlOut.y,\n              { targetId: id, anchorIndex: a.anchorIndex, part: 'controlOut' },\n              `controlOut:${a.anchorIndex}`,\n            ));\n          }\n        }\n      }\n      return out;\n    },\n  };\n\n  return [anchors, controls];\n}\n"],"mappings":";;AAqDA,IAAaA,IAAwB;AAcrC,SAAgBC,EACd,GACA,IAAoC,CAAC,GACvB;CACd,IAAM,EAAE,eAAY,GAAG,YAAS,cAAcC,GAGxCC,KAAiB,MAAiE;EACtF,IAAMC,IAAcC,EAAe;EACnC,IAAI,CAACD,GAAa,OAAO,CAAC;EAC1B,IAAME,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAMC,EAAM,WAAW;GAChC,IAAMC,IAAOL,EAAY,QAAQG,CAAE;GACnC,AAAKE,KAASA,EAA2B,SAAS,aAClDH,EAAI,KAAK;IAAE;IAAI,MAAMG;GAAoB,CAAC;EAC5C;EACA,OAAOH;CACT,GAEMI,KACJ,GACA,GACA,GACA,GACA,GACA,OACsB;EACtB;EAKA,UAAU;EACV,OAAO;GAAE,MAAM;GAAS;GAAG;GAAG,aAAaC;EAAU;EACrD;EACA;EACA,aAAgC,EAAE,gBAAgB;GAAE,GAAGC;GAAS;EAAS,EAAE;CAC7E;CA2DA,OAAO,CAAC;EAxDN,IAAIZ;EACJ,QAAQ,GAAO;GACb,IAAMa,IAAYR,EAAe,CAAC,EAAE,aAAa,MAC3CC,IAA0B,CAAC;GACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAK5C,IAAIK,MAAc,QAAQN,MAAOM,GACjC,KAAK,IAAMC,KAAKC,EAAiBC,CAAI,GACnC,EAAI,KAAKN,EACP,GAAGH,EAAG,UAAUO,EAAE,eAClBP,GAAIO,EAAE,GAAGA,EAAE,GACX;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAS,GAC3D,UAAUA,EAAE,aACd,CAAC;GAGL,OAAOR;EACT;CAoCM,GAAS;EAhCf,IAAIN;EACJ,QAAQ,GAAO;GAEb,IAAMa,IADcR,EACF,CAAA,EAAa,aAAa;GAC5C,IAAIQ,MAAc,MAAM,OAAO,CAAC;GAChC,IAAMP,IAA0B,CAAC;GACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAE5C,IAAID,MAAOM,GACX,KAAK,IAAMC,KAAKC,EAAiBC,CAAI,GASnC,AARIF,EAAE,aACJR,EAAI,KAAKI,EACP,GAAGH,EAAG,aAAaO,EAAE,eACrBP,GAAIO,EAAE,UAAU,GAAGA,EAAE,UAAU,GAC/B;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAY,GAC9D,aAAaA,EAAE,aACjB,CAAC,GAECA,EAAE,cACJR,EAAI,KAAKI,EACP,GAAGH,EAAG,cAAcO,EAAE,eACtBP,GAAIO,EAAE,WAAW,GAAGA,EAAE,WAAW,GACjC;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAa,GAC/D,cAAcA,EAAE,aAClB,CAAC;GAIP,OAAOR;EACT;CAGe,CAAQ;AAC3B"}
+{"version":3,"file":"pathAnchors.js","names":["PATH_ANCHOR_CHROME_ID","createPathAnchorAffordances","opts","editablePaths","anchorState","getAnchorState","out","id","state","pose","point","hitRadius","scratch","editingId","a","enumerateAnchors","path"],"sources":["../../src/affordances/pathAnchors.ts"],"sourcesContent":["/** Path anchor + control-handle affordances. */\n\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors } from 'interactions/actions/edit-anchors/geometry';\n\n/**\n * Live anchor-editing state. The thunk that returns it is called on every\n * pointer event, so it must be cheap (O(1) field reads).\n */\nexport interface AnchorState {\n  /** Id of the path currently in anchor-edit mode, or `null`. Control handles\n   *  are only hittable on the path that is being edited. */\n  editingId: string | null;\n  /** Current editable path for a node id. Non-polygon values are ignored. */\n  getPose(id: string): unknown;\n}\n\n/** Options for the path-anchor affordances. */\nexport interface PathAnchorAffordanceOptions {\n  /** Hit radius (screen-px) for anchor and control points. Default 8. */\n  hitRadius?: number;\n  /** Cursor while hovering an anchor or control. Defaults to `'pointer'`. */\n  cursor?: CursorSpec;\n}\n\n/** What an anchor hit hands to the action that follows. */\nexport interface AnchorScratch extends CommonAffordanceScratch {\n  /** Node id of the path the anchor belongs to. */\n  targetId: string;\n  /** Sequential anchor index in path walk order. */\n  anchorIndex: number;\n  /** Which of the anchor's three grabbable points this is. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n}\n\n/** Chrome-caps id gating both returned affordances. */\nexport const PATH_ANCHOR_CHROME_ID = 'path-edit.anchors';\n\n/**\n * Anchor + control affordances for the selected paths, bottom → top.\n *\n * Returns **two** affordances rather than one so that a control handle beats\n * an anchor regardless of which is nearer, the way controls draw on top.\n * Within each of the two, nearest wins. They deliberately share one id:\n * chrome-caps gates anchor editing as a single piece of chrome.\n *\n * Order matters — spread this into an affordance list in the returned order.\n */\nexport function createPathAnchorAffordances(\n  getAnchorState: () => AnchorState | null,\n  opts: PathAnchorAffordanceOptions = {},\n): Affordance[] {\n  const { hitRadius = 8, cursor = 'pointer' } = opts;\n\n  /** Selected polygon paths, paired with their node id. */\n  const editablePaths = (state: ChromeState): Array<{ id: string; path: PolygonPath }> => {\n    const anchorState = getAnchorState();\n    if (!anchorState) return [];\n    const out: Array<{ id: string; path: PolygonPath }> = [];\n    for (const id of state.selection) {\n      const pose = anchorState.getPose(id);\n      if (!pose || (pose as { kind?: string }).kind !== 'polygon') continue;\n      out.push({ id, path: pose as PolygonPath });\n    }\n    return out;\n  };\n\n  const point = (\n    id: string,\n    targetId: string,\n    x: number,\n    y: number,\n    scratch: AnchorScratch,\n    hitKind: string,\n  ): AffordanceRegion => ({\n    id,\n    // Anchor coordinates are already world space, pose rotation baked in.\n    // Anchoring to `null` keeps the framework from applying it twice.\n    targetId: null,\n    shape: { kind: 'point', x, y, hitRadiusPx: hitRadius },\n    hitKind,\n    cursor,\n    bind: (): AffordanceBinding => ({ initialScratch: { ...scratch, targetId } }),\n  });\n\n  const anchors: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const editingId = getAnchorState()?.editingId ?? null;\n      const out: AffordanceRegion[] = [];\n      for (const { id, path } of editablePaths(state)) {\n        // `editAnchorsAction` edits whatever path the dep says is in edit\n        // mode, ignoring which one was hit — so once a path IS being edited,\n        // only its own anchors may claim the press.\n        if (editingId !== null && id !== editingId) continue;\n        for (const a of enumerateAnchors(path)) {\n          out.push(point(\n            `${id}:anchor:${a.anchorIndex}`,\n            id, a.x, a.y,\n            { targetId: id, anchorIndex: a.anchorIndex, part: 'anchor' },\n            `anchor:${a.anchorIndex}`,\n          ));\n        }\n      }\n      return out;\n    },\n  };\n\n  const controls: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const anchorState = getAnchorState();\n      const editingId = anchorState?.editingId ?? null;\n      if (editingId === null) return [];\n      const out: AffordanceRegion[] = [];\n      for (const { id, path } of editablePaths(state)) {\n        // Controls are grabbable only on the path actually in edit mode.\n        if (id !== editingId) continue;\n        for (const a of enumerateAnchors(path)) {\n          if (a.controlIn) {\n            out.push(point(\n              `${id}:controlIn:${a.anchorIndex}`,\n              id, a.controlIn.x, a.controlIn.y,\n              { targetId: id, anchorIndex: a.anchorIndex, part: 'controlIn' },\n              `controlIn:${a.anchorIndex}`,\n            ));\n          }\n          if (a.controlOut) {\n            out.push(point(\n              `${id}:controlOut:${a.anchorIndex}`,\n              id, a.controlOut.x, a.controlOut.y,\n              { targetId: id, anchorIndex: a.anchorIndex, part: 'controlOut' },\n              `controlOut:${a.anchorIndex}`,\n            ));\n          }\n        }\n      }\n      return out;\n    },\n  };\n\n  return [anchors, controls];\n}\n"],"mappings":";;AAuCA,IAAaA,IAAwB;AAYrC,SAAgBC,EACd,GACA,IAAoC,CAAC,GACvB;CACd,IAAM,EAAE,eAAY,GAAG,YAAS,cAAcC,GAGxCC,KAAiB,MAAiE;EACtF,IAAMC,IAAcC,EAAe;EACnC,IAAI,CAACD,GAAa,OAAO,CAAC;EAC1B,IAAME,IAAgD,CAAC;EACvD,KAAK,IAAMC,KAAMC,EAAM,WAAW;GAChC,IAAMC,IAAOL,EAAY,QAAQG,CAAE;GACnC,AAAKE,KAASA,EAA2B,SAAS,aAClDH,EAAI,KAAK;IAAE;IAAI,MAAMG;GAAoB,CAAC;EAC5C;EACA,OAAOH;CACT,GAEMI,KACJ,GACA,GACA,GACA,GACA,GACA,OACsB;EACtB;EAGA,UAAU;EACV,OAAO;GAAE,MAAM;GAAS;GAAG;GAAG,aAAaC;EAAU;EACrD;EACA;EACA,aAAgC,EAAE,gBAAgB;GAAE,GAAGC;GAAS;EAAS,EAAE;CAC7E;CA0DA,OAAO,CAAC;EAvDN,IAAIZ;EACJ,QAAQ,GAAO;GACb,IAAMa,IAAYR,EAAe,CAAC,EAAE,aAAa,MAC3CC,IAA0B,CAAC;GACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAI5C,IAAIK,MAAc,QAAQN,MAAOM,GACjC,KAAK,IAAMC,KAAKC,EAAiBC,CAAI,GACnC,EAAI,KAAKN,EACP,GAAGH,EAAG,UAAUO,EAAE,eAClBP,GAAIO,EAAE,GAAGA,EAAE,GACX;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAS,GAC3D,UAAUA,EAAE,aACd,CAAC;GAGL,OAAOR;EACT;CAoCM,GAAS;EAhCf,IAAIN;EACJ,QAAQ,GAAO;GAEb,IAAMa,IADcR,EACF,CAAA,EAAa,aAAa;GAC5C,IAAIQ,MAAc,MAAM,OAAO,CAAC;GAChC,IAAMP,IAA0B,CAAC;GACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAE5C,IAAID,MAAOM,GACX,KAAK,IAAMC,KAAKC,EAAiBC,CAAI,GASnC,AARIF,EAAE,aACJR,EAAI,KAAKI,EACP,GAAGH,EAAG,aAAaO,EAAE,eACrBP,GAAIO,EAAE,UAAU,GAAGA,EAAE,UAAU,GAC/B;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAY,GAC9D,aAAaA,EAAE,aACjB,CAAC,GAECA,EAAE,cACJR,EAAI,KAAKI,EACP,GAAGH,EAAG,cAAcO,EAAE,eACtBP,GAAIO,EAAE,WAAW,GAAGA,EAAE,WAAW,GACjC;IAAE,UAAUP;IAAI,aAAaO,EAAE;IAAa,MAAM;GAAa,GAC/D,cAAcA,EAAE,aAClB,CAAC;GAIP,OAAOR;EACT;CAGe,CAAQ;AAC3B"}

package/dist/affordances/rotationHandle.js

@@ -1,11 +1,12 @@
-import { angleOf as e, transformOf as t } from "./hitAffordanceRegions.js";
+import { angleOf as e } from "../core/geometry/targetFrame.js";
+import { transformOf as t } from "./hitAffordanceRegions.js";
 import { MULTI_RESIZE_TARGET_ID as n } from "../core/selection/selectionTarget.js";
 //#region src/affordances/rotationHandle.ts
 var r = (e) => "fill" in e || "stroke" in e || "insetPx" in e, i = {
-	fill: {
-		fill: "solid",
+	fill: { paint: {
+		kind: "solid",
 		color: "rgba(26, 19, 13, 0.12)"
-	},
+	} },
 	insetPx: 10
 };
 function a(n = {}) {

package/dist/affordances/rotationHandle.js.map

@@ -1 +1 @@
-{"version":3,"file":"rotationHandle.js","names":["isAnnulusForm","paint","DEFAULT_PAINT","createRotationAffordance","opts","annulusPaint","target","pickTarget","state","b","halfW","halfH","regionCursor","cursor","angleOf","transformOf","bind","region","bandPx","handle","id","MULTI_RESIZE_TARGET_ID"],"sources":["../../src/affordances/rotationHandle.ts"],"sourcesContent":["import type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport type { CommandFill, CommandStroke } from '@weasel-js/paint';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport { angleOf, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\n\n/** Options for `createRotationAffordance` — how thick the rotate band is\n *  outside the selection, and how (or whether) it is painted. */\nexport interface RotationAffordanceOptions {\n  /** Minimum screen-space thickness of the rotate-zone band outside the\n   *  selection AABB. The outer ellipse semi-axes are clamped to\n   *  `max(w/√2, w/2 + bandPx/scale)` so the zone stays hoverable at any\n   *  zoom and any selection size. Default 24. */\n  bandPx?: number;\n  /** Paint for the ring. `null` / `false` = invisible. Default is a\n   *  semi-transparent fill of the band, contracted by `insetPx` screen\n   *  pixels on the outer edge so the visible band sits inside the\n   *  hoverable zone with a clear margin. Pass a `Stroke` (or\n   *  `{ fill, stroke, insetPx }`) to override. */\n  paint?:\n    | CommandStroke\n    | { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null\n    | false;\n  /** Cursor while hovering the ring. Defaults to the `rotate` glyph turned\n   *  with the target, falling back to `'grab'` if the browser rejects the\n   *  image. */\n  cursor?: CursorSpec;\n  /** A grab region for a rotate badge painted off the top edge — the one\n   *  the selection overlay's `rotationHandle` draws. `distancePx` is how far\n   *  off the edge it sits and `hitRadiusPx` the half-extent of its square,\n   *  both in screen pixels. Placed by the same `standoff` the painted badge\n   *  is, so the two cannot drift apart. Omitted, only the ring rotates. */\n  handle?: { distancePx: number; hitRadiusPx: number };\n}\n\n/** What a rotation-handle hit hands to the rotate action: what is being\n *  rotated, and the world-space pivot it turns around. */\nexport interface RotationScratch extends CommonAffordanceScratch {\n  /** Id of the rotation target — single selection id, or\n   *  `MULTI_RESIZE_TARGET_ID` for multi-selection. */\n  targetId: string;\n  /** Rotation pivot in world coords — the AABB (or union AABB) center. */\n  fixedPoint: { x: number; y: number };\n}\n\ntype AnnulusPaintForm = { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number };\n\nconst isAnnulusForm = (paint: CommandStroke | AnnulusPaintForm): paint is AnnulusPaintForm =>\n  'fill' in paint || 'stroke' in paint || 'insetPx' in paint;\n\nconst DEFAULT_PAINT: AnnulusPaintForm = {\n  fill: { fill: 'solid', color: 'rgba(26, 19, 13, 0.12)' },\n  insetPx: 10,\n};\n\n/**\n * @experimental\n * Rotation affordance for the active selection. Replaces the legacy\n * \"small dot above the AABB\" handle with an elliptical ring that wraps\n * the selection: the smallest ellipse containing the AABB, minus the AABB\n * itself. Hovering the ring sets the cursor (default the `rotate` glyph)\n * and drag-from-ring triggers `rotateAction` via the same\n * binding path the old point-handle used (id stays\n * `'selection.rotation-handle'`).\n *\n * The ring is target-local — under target rotation the ellipse rotates\n * with the AABB so the hoverable band always wraps the rendered shape.\n *\n * Visibility: gated by chrome-caps' `'selection.rotation-handle'` rule.\n * The ring paints as a faint band by default; `paint: null` leaves the\n * cursor change as the only cue.\n */\nexport function createRotationAffordance(\n  opts: RotationAffordanceOptions = {},\n): Affordance {\n  const { bandPx = 24, paint = DEFAULT_PAINT, cursor, handle } = opts;\n\n  // Normalize `paint` into the AnnulusPaint shape understood by\n  // `composeAffordanceLayer`. Three input forms are accepted: a bare\n  // `Stroke` (legacy outline form), the `{ fill, stroke, insetPx }`\n  // object form, or `null`/`false` for invisible. The object form is what\n  // carries these three keys; `Stroke` carries none of them, and cannot be\n  // told apart by its own `paint` since that is optional.\n  const annulusPaint:\n    | { kind: 'annulus'; fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null = (() => {\n      if (!paint) return null;\n      if (!isAnnulusForm(paint)) {\n        return { kind: 'annulus' as const, stroke: paint };\n      }\n      return {\n        kind: 'annulus' as const,\n        ...(paint.fill ? { fill: paint.fill } : {}),\n        ...(paint.stroke ? { stroke: paint.stroke } : {}),\n        ...(paint.insetPx !== undefined ? { insetPx: paint.insetPx } : {}),\n      };\n    })();\n\n  return {\n    id: 'selection.rotation-handle',\n    regions(state: ChromeState): readonly AffordanceRegion[] {\n      const target = pickTarget(state);\n      if (!target) return [];\n      const b = target.bounds;\n\n      // The natural ring: the smallest ellipse containing the AABB. For a\n      // small or thin selection that band is too tight to hover, so\n      // `minBandPx` asks the framework to widen it to at least `bandPx`\n      // screen pixels outside the rect. The floor is declared in screen units\n      // rather than applied here because `ChromeState` carries no view scale\n      // — the framework applies it at paint and hit time, where the view is\n      // known, so the ring holds its apparent thickness at any zoom.\n      const halfW = b.width / 2;\n      const halfH = b.height / 2;\n\n      // Turned with the target, so the arc follows the selection it rotates.\n      // Resolved per region rather than defaulted in the option list because\n      // the angle is only known once a target is picked.\n      const regionCursor: CursorSpec = cursor ?? {\n        glyph: 'rotate',\n        angle: angleOf(transformOf(state, target.id)),\n        fallback: 'grab',\n      };\n      const bind = (): AffordanceBinding => ({\n        initialScratch: {\n          targetId: target.id,\n          // Pivot. `rotateAction` recomputes its own union pivot for\n          // multi-selection, but the single-target case reads this.\n          fixedPoint: { x: b.x + halfW, y: b.y + halfH },\n        } satisfies RotationScratch,\n      });\n\n      const region: AffordanceRegion = {\n        id: 'selection.rotation-handle',\n        targetId: target.id,\n        shape: {\n          kind: 'annulus',\n          cx: b.x + halfW,\n          cy: b.y + halfH,\n          rx: halfW * Math.SQRT2,\n          ry: halfH * Math.SQRT2,\n          innerX: b.x,\n          innerY: b.y,\n          innerWidth: b.width,\n          innerHeight: b.height,\n          minBandPx: bandPx,\n        },\n        ...(annulusPaint ? { paint: annulusPaint } : {}),\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      if (!handle) return [region];\n      const badge: AffordanceRegion = {\n        id: 'rotation-badge',\n        targetId: target.id,\n        shape: {\n          kind: 'point',\n          x: b.x + halfW,\n          y: b.y,\n          hitRadiusPx: handle.hitRadiusPx,\n          standoff: { px: handle.distancePx, normal: { x: 0, y: -1 } },\n        },\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      return [region, badge];\n    },\n  };\n}\n\nfunction pickTarget(state: ChromeState): { id: string; bounds: Bounds } | null {\n  if (state.selection.length === 1) {\n    const id = state.selection[0];\n    // Skip when the selected node's pose-descriptor declares it can't\n    // carry a rotation. Without this the rotation affordance would expose\n    // a rotate cursor over (e.g.) polygon-Path selections whose\n    // `rotateAction` write is silently dropped at paint time.\n    if (state.canRotate && !state.canRotate(id)) return null;\n    const b = state.boundsOf(id);\n    return b ? { id, bounds: b } : null;\n  }\n  // Multi-selection: anchor the ring to the union AABB. `rotateAction`\n  // ignores the synthetic id and pivots at its own union center\n  // (`useUnionPivot: ids.length > 1` branch in `defaults/rotate.ts`).\n  // Require every selected id to support rotation — a partial multi-rotate\n  // (some ids rotate, others silently no-op) would feel broken.\n  if (state.multiActive && state.unionBounds) {\n    if (state.canRotate) {\n      for (const id of state.selection) {\n        if (!state.canRotate(id)) return null;\n      }\n    }\n    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };\n  }\n  return null;\n}\n"],"mappings":";;;AAiDA,IAAMA,KAAiB,MACrB,UAAUC,KAAS,YAAYA,KAAS,aAAaA,GAEjDC,IAAkC;CACtC,MAAM;EAAE,MAAM;EAAS,OAAO;CAAyB;CACvD,SAAS;AACX;AAmBA,SAAgBC,EACd,IAAkC,CAAC,GACvB;CACZ,IAAM,EAAE,YAAS,IAAI,WAAQD,GAAe,WAAQ,cAAWE,GAQzDC,IAGGJ,IACAD,EAAcC,CAAK,IAGjB;EACL,MAAM;EACN,GAAIA,EAAM,OAAO,EAAE,MAAMA,EAAM,KAAK,IAAI,CAAC;EACzC,GAAIA,EAAM,SAAS,EAAE,QAAQA,EAAM,OAAO,IAAI,CAAC;EAC/C,GAAIA,EAAM,YAAY,KAAA,IAAyC,CAAC,IAA9B,EAAE,SAASA,EAAM,QAAQ;CAC7D,IAPS;EAAE,MAAM;EAAoB,QAAQA;CAAM,IAFhC;CAYvB,OAAO;EACL,IAAI;EACJ,QAAQ,GAAiD;GACvD,IAAMK,IAASC,EAAWC,CAAK;GAC/B,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAIH,EAAO,QASXI,IAAQD,EAAE,QAAQ,GAClBE,IAAQF,EAAE,SAAS,GAKnBG,IAA2BC,KAAU;IACzC,OAAO;IACP,OAAOC,EAAQC,EAAYP,GAAOF,EAAO,EAAE,CAAC;IAC5C,UAAU;GACZ,GACMU,WAAiC,EACrC,gBAAgB;IACd,UAAUV,EAAO;IAGjB,YAAY;KAAE,GAAGG,EAAE,IAAIC;KAAO,GAAGD,EAAE,IAAIE;IAAM;GAC/C,EACF,IAEMM,IAA2B;IAC/B,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,IAAIG,EAAE,IAAIC;KACV,IAAID,EAAE,IAAIE;KACV,IAAID,IAAQ,KAAK;KACjB,IAAIC,IAAQ,KAAK;KACjB,QAAQF,EAAE;KACV,QAAQA,EAAE;KACV,YAAYA,EAAE;KACd,aAAaA,EAAE;KACf,WAAWS;IACb;IACA,GAAIb,IAAe,EAAE,OAAOA,EAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQO;IACR;GACF;GAgBA,OAfKO,IAeE,CAACF,GAAQ;IAbd,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAGG,EAAE,IAAIC;KACT,GAAGD,EAAE;KACL,aAAaU,EAAO;KACpB,UAAU;MAAE,IAAIA,EAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQP;IACR;GAEc,CAAK,IAfD,CAACK,CAAM;EAgB7B;CACF;AACF;AAEA,SAASV,EAAW,GAA2D;CAC7E,IAAIC,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMY,IAAKZ,EAAM,UAAU;EAK3B,IAAIA,EAAM,aAAa,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EACpD,IAAMX,IAAID,EAAM,SAASY,CAAE;EAC3B,OAAOX,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CAMA,IAAID,EAAM,eAAeA,EAAM,aAAa;EAC1C,IAAIA,EAAM,WACH;QAAA,IAAMY,KAAMZ,EAAM,WACrB,IAAI,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EAAA;EAGrC,OAAO;GAAE,IAAIC;GAAwB,QAAQb,EAAM;EAAY;CACjE;CACA,OAAO;AACT"}
+{"version":3,"file":"rotationHandle.js","names":["isAnnulusForm","paint","DEFAULT_PAINT","createRotationAffordance","opts","annulusPaint","target","pickTarget","state","b","halfW","halfH","regionCursor","cursor","angleOf","transformOf","bind","region","bandPx","handle","id","MULTI_RESIZE_TARGET_ID"],"sources":["../../src/affordances/rotationHandle.ts"],"sourcesContent":["import type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport type { CommandStroke, CommandFill } from '@weasel-js/paint';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport { angleOf, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\n\n/** Options for `createRotationAffordance` — how thick the rotate band is\n *  outside the selection, and how (or whether) it is painted. */\nexport interface RotationAffordanceOptions {\n  /** Minimum screen-space thickness of the rotate-zone band outside the selection AABB, so\n   *  the zone stays hoverable at any zoom and any selection size. Default 24. */\n  bandPx?: number;\n  /** Paint for the ring. `null` / `false` = invisible. Default is a semi-transparent fill of\n   *  the band, contracted by `insetPx` screen pixels on the outer edge. Pass a `Stroke` (or\n   *  `{ fill, stroke, insetPx }`) to override. */\n  paint?:\n    | CommandStroke\n    | { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null\n    | false;\n  /** Cursor while hovering the ring. Defaults to the `rotate` glyph turned\n   *  with the target, falling back to `'grab'` if the browser rejects the\n   *  image. */\n  cursor?: CursorSpec;\n  /** A grab region for a rotate badge painted off the top edge — the one\n   *  the selection overlay's `rotationHandle` draws. `distancePx` is how far\n   *  off the edge it sits and `hitRadiusPx` the half-extent of its square,\n   *  both in screen pixels. Placed by the same `standoff` the painted badge\n   *  is, so the two cannot drift apart. Omitted, only the ring rotates. */\n  handle?: { distancePx: number; hitRadiusPx: number };\n}\n\n/** What a rotation-handle hit hands to the rotate action: what is being\n *  rotated, and the world-space pivot it turns around. */\nexport interface RotationScratch extends CommonAffordanceScratch {\n  /** Id of the rotation target — single selection id, or\n   *  `MULTI_RESIZE_TARGET_ID` for multi-selection. */\n  targetId: string;\n  /** Rotation pivot in world coords — the AABB (or union AABB) center. */\n  fixedPoint: { x: number; y: number };\n}\n\ntype AnnulusPaintForm = { fill?: CommandFill; stroke?: CommandStroke; insetPx?: number };\n\nconst isAnnulusForm = (paint: CommandStroke | AnnulusPaintForm): paint is AnnulusPaintForm =>\n  'fill' in paint || 'stroke' in paint || 'insetPx' in paint;\n\nconst DEFAULT_PAINT: AnnulusPaintForm = {\n  fill: { paint: { kind: 'solid', color: 'rgba(26, 19, 13, 0.12)' } },\n  insetPx: 10,\n};\n\n/**\n * @experimental\n * Rotation affordance for the active selection: an elliptical ring that wraps the selection —\n * the smallest ellipse containing the AABB, minus the AABB itself. Hovering the ring sets the\n * cursor (default the `rotate` glyph) and a drag from it triggers `rotateAction`.\n *\n * The ring is target-local — under target rotation the ellipse rotates with the AABB.\n * Visibility is gated by chrome-caps' `'selection.rotation-handle'` rule. `paint: null` leaves\n * the cursor change as the only cue.\n */\nexport function createRotationAffordance(\n  opts: RotationAffordanceOptions = {},\n): Affordance {\n  const { bandPx = 24, paint = DEFAULT_PAINT, cursor, handle } = opts;\n\n  // A bare `Stroke` carries none of the object form's three keys, and cannot be told apart\n  // by its own `paint` since that is optional.\n  const annulusPaint:\n    | { kind: 'annulus'; fill?: CommandFill; stroke?: CommandStroke; insetPx?: number }\n    | null = (() => {\n      if (!paint) return null;\n      if (!isAnnulusForm(paint)) {\n        return { kind: 'annulus' as const, stroke: paint };\n      }\n      return {\n        kind: 'annulus' as const,\n        ...(paint.fill ? { fill: paint.fill } : {}),\n        ...(paint.stroke ? { stroke: paint.stroke } : {}),\n        ...(paint.insetPx !== undefined ? { insetPx: paint.insetPx } : {}),\n      };\n    })();\n\n  return {\n    id: 'selection.rotation-handle',\n    regions(state: ChromeState): readonly AffordanceRegion[] {\n      const target = pickTarget(state);\n      if (!target) return [];\n      const b = target.bounds;\n\n      // The natural ring is the smallest ellipse containing the AABB. `minBandPx` asks the\n      // framework to widen it to at least `bandPx` screen pixels outside the rect; the floor is\n      // declared in screen units because `ChromeState` carries no view scale.\n      const halfW = b.width / 2;\n      const halfH = b.height / 2;\n\n      // Turned with the target, so the arc follows the selection it rotates.\n      const regionCursor: CursorSpec = cursor ?? {\n        glyph: 'rotate',\n        angle: angleOf(transformOf(state, target.id)),\n        fallback: 'grab',\n      };\n      const bind = (): AffordanceBinding => ({\n        initialScratch: {\n          targetId: target.id,\n          // Pivot. `rotateAction` recomputes its own union pivot for\n          // multi-selection, but the single-target case reads this.\n          fixedPoint: { x: b.x + halfW, y: b.y + halfH },\n        } satisfies RotationScratch,\n      });\n\n      const region: AffordanceRegion = {\n        id: 'selection.rotation-handle',\n        targetId: target.id,\n        shape: {\n          kind: 'annulus',\n          cx: b.x + halfW,\n          cy: b.y + halfH,\n          rx: halfW * Math.SQRT2,\n          ry: halfH * Math.SQRT2,\n          innerX: b.x,\n          innerY: b.y,\n          innerWidth: b.width,\n          innerHeight: b.height,\n          minBandPx: bandPx,\n        },\n        ...(annulusPaint ? { paint: annulusPaint } : {}),\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      if (!handle) return [region];\n      const badge: AffordanceRegion = {\n        id: 'rotation-badge',\n        targetId: target.id,\n        shape: {\n          kind: 'point',\n          x: b.x + halfW,\n          y: b.y,\n          hitRadiusPx: handle.hitRadiusPx,\n          standoff: { px: handle.distancePx, normal: { x: 0, y: -1 } },\n        },\n        hitKind: 'rotate-handle',\n        cursor: regionCursor,\n        bind,\n      };\n      return [region, badge];\n    },\n  };\n}\n\nfunction pickTarget(state: ChromeState): { id: string; bounds: Bounds } | null {\n  if (state.selection.length === 1) {\n    const id = state.selection[0];\n    // Skip when the selected node's pose-descriptor declares it can't carry a rotation;\n    // otherwise the ring would offer a rotate cursor over a node whose write is dropped.\n    if (state.canRotate && !state.canRotate(id)) return null;\n    const b = state.boundsOf(id);\n    return b ? { id, bounds: b } : null;\n  }\n  // Multi-selection: anchor the ring to the union AABB; `rotateAction` ignores the synthetic\n  // id and pivots at its own union center. Every selected id must support rotation — a\n  // partial multi-rotate would feel broken.\n  if (state.multiActive && state.unionBounds) {\n    if (state.canRotate) {\n      for (const id of state.selection) {\n        if (!state.canRotate(id)) return null;\n      }\n    }\n    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };\n  }\n  return null;\n}\n"],"mappings":";;;;AA6CA,IAAMA,KAAiB,MACrB,UAAUC,KAAS,YAAYA,KAAS,aAAaA,GAEjDC,IAAkC;CACtC,MAAM,EAAE,OAAO;EAAE,MAAM;EAAS,OAAO;CAAyB,EAAE;CAClE,SAAS;AACX;AAYA,SAAgBC,EACd,IAAkC,CAAC,GACvB;CACZ,IAAM,EAAE,YAAS,IAAI,WAAQD,GAAe,WAAQ,cAAWE,GAIzDC,IAGGJ,IACAD,EAAcC,CAAK,IAGjB;EACL,MAAM;EACN,GAAIA,EAAM,OAAO,EAAE,MAAMA,EAAM,KAAK,IAAI,CAAC;EACzC,GAAIA,EAAM,SAAS,EAAE,QAAQA,EAAM,OAAO,IAAI,CAAC;EAC/C,GAAIA,EAAM,YAAY,KAAA,IAAyC,CAAC,IAA9B,EAAE,SAASA,EAAM,QAAQ;CAC7D,IAPS;EAAE,MAAM;EAAoB,QAAQA;CAAM,IAFhC;CAYvB,OAAO;EACL,IAAI;EACJ,QAAQ,GAAiD;GACvD,IAAMK,IAASC,EAAWC,CAAK;GAC/B,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAIH,EAAO,QAKXI,IAAQD,EAAE,QAAQ,GAClBE,IAAQF,EAAE,SAAS,GAGnBG,IAA2BC,KAAU;IACzC,OAAO;IACP,OAAOC,EAAQC,EAAYP,GAAOF,EAAO,EAAE,CAAC;IAC5C,UAAU;GACZ,GACMU,WAAiC,EACrC,gBAAgB;IACd,UAAUV,EAAO;IAGjB,YAAY;KAAE,GAAGG,EAAE,IAAIC;KAAO,GAAGD,EAAE,IAAIE;IAAM;GAC/C,EACF,IAEMM,IAA2B;IAC/B,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,IAAIG,EAAE,IAAIC;KACV,IAAID,EAAE,IAAIE;KACV,IAAID,IAAQ,KAAK;KACjB,IAAIC,IAAQ,KAAK;KACjB,QAAQF,EAAE;KACV,QAAQA,EAAE;KACV,YAAYA,EAAE;KACd,aAAaA,EAAE;KACf,WAAWS;IACb;IACA,GAAIb,IAAe,EAAE,OAAOA,EAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQO;IACR;GACF;GAgBA,OAfKO,IAeE,CAACF,GAAQ;IAbd,IAAI;IACJ,UAAUX,EAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAGG,EAAE,IAAIC;KACT,GAAGD,EAAE;KACL,aAAaU,EAAO;KACpB,UAAU;MAAE,IAAIA,EAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQP;IACR;GAEc,CAAK,IAfD,CAACK,CAAM;EAgB7B;CACF;AACF;AAEA,SAASV,EAAW,GAA2D;CAC7E,IAAIC,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMY,IAAKZ,EAAM,UAAU;EAG3B,IAAIA,EAAM,aAAa,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EACpD,IAAMX,IAAID,EAAM,SAASY,CAAE;EAC3B,OAAOX,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CAIA,IAAID,EAAM,eAAeA,EAAM,aAAa;EAC1C,IAAIA,EAAM,WACH;QAAA,IAAMY,KAAMZ,EAAM,WACrB,IAAI,CAACA,EAAM,UAAUY,CAAE,GAAG,OAAO;EAAA;EAGrC,OAAO;GAAE,IAAIC;GAAwB,QAAQb,EAAM;EAAY;CACjE;CACA,OAAO;AACT"}

package/dist/animation/behaviors/coast.js

@@ -0,0 +1,21 @@
+//#region src/animation/behaviors/coast.ts
+var e = 0, t = () => `momentum:${e++}`, n = (e, t) => e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+function r(e, t, n) {
+	if (!e) return {
+		nx: t,
+		ny: n,
+		hitX: !1,
+		hitY: !1
+	};
+	let r = Math.min(Math.max(t, e.x), e.x + e.width), i = Math.min(Math.max(n, e.y), e.y + e.height);
+	return {
+		nx: r,
+		ny: i,
+		hitX: r !== t,
+		hitY: i !== n
+	};
+}
+//#endregion
+export { r as clampCorner, t as coastKey, n as sameBounds };
+
+//# sourceMappingURL=coast.js.map

package/dist/animation/behaviors/coast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coast.js","names":["nextCoast","coastKey","sameBounds","a","b","clampCorner","bounds","x","y","nx","ny"],"sources":["../../../src/animation/behaviors/coast.ts"],"sourcesContent":["import type { GestureContext } from 'interactions/gestures/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { Animator } from '@weasel-js/animator';\n\n/** One flick still traveling: the nodes it carries, and how a new drag of one stops it. */\nexport interface Coast {\n  ids: readonly string[];\n  stop(): void;\n}\n\n/** What a coast is started with. */\nexport interface CoastArgs<TPose> {\n  animator: Animator;\n  ctx: GestureContext<TPose>;\n  /** Release velocity in world units a second. */\n  vx: number;\n  vy: number;\n  friction: number;\n  bounds: { x: number; y: number; width: number; height: number } | undefined;\n  boundary: 'stop' | 'continue';\n  d: PoseDescriptor<TPose>;\n  /** The behavior's running coasts. A coast adds itself and takes itself out as it ends. */\n  coasts: Set<Coast>;\n}\n\nlet nextCoast = 0;\n\n/** A cancel key no other coast holds. */\nexport const coastKey = (): string => `momentum:${nextCoast++}`;\n\n/** Whether two bounds are the same box. */\nexport const sameBounds = (a: Bounds, b: Bounds): boolean =>\n  a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n\n/** A top-left corner held inside `bounds`, and which axes that moved. */\nexport function clampCorner(\n  bounds: CoastArgs<unknown>['bounds'],\n  x: number,\n  y: number,\n): { nx: number; ny: number; hitX: boolean; hitY: boolean } {\n  if (!bounds) return { nx: x, ny: y, hitX: false, hitY: false };\n  const nx = Math.min(Math.max(x, bounds.x), bounds.x + bounds.width);\n  const ny = Math.min(Math.max(y, bounds.y), bounds.y + bounds.height);\n  return { nx, ny, hitX: nx !== x, hitY: ny !== y };\n}\n"],"mappings":";AA0BA,IAAIA,IAAY,GAGHC,UAAyB,YAAY,OAGrCC,KAAc,GAAW,MACpCC,EAAE,MAAMC,EAAE,KAAKD,EAAE,MAAMC,EAAE,KAAKD,EAAE,UAAUC,EAAE,SAASD,EAAE,WAAWC,EAAE;AAGtE,SAAgBC,EACd,GACA,GACA,GAC0D;CAC1D,IAAI,CAACC,GAAQ,OAAO;EAAE,IAAIC;EAAG,IAAIC;EAAG,MAAM;EAAO,MAAM;CAAM;CAC7D,IAAMC,IAAK,KAAK,IAAI,KAAK,IAAIF,GAAGD,EAAO,CAAC,GAAGA,EAAO,IAAIA,EAAO,KAAK,GAC5DI,IAAK,KAAK,IAAI,KAAK,IAAIF,GAAGF,EAAO,CAAC,GAAGA,EAAO,IAAIA,EAAO,MAAM;CACnE,OAAO;EAAE;EAAI;EAAI,MAAMG,MAAOF;EAAG,MAAMG,MAAOF;CAAE;AAClD"}

package/dist/animation/behaviors/coastByWrite.js

@@ -0,0 +1,107 @@
+import { translatePoseViaDescriptor as e } from "../../core/geometry/poseDescriptor.js";
+import { createTransformOp as t } from "../../core/ops/transform.js";
+import { clampCorner as n, coastKey as r, sameBounds as i } from "./coast.js";
+//#region src/animation/behaviors/coastByWrite.ts
+function a(a) {
+	let { animator: o, ctx: s, d: c, bounds: l, coasts: u } = a, d = s.adapter, f = new Map(s.current), p = {
+		x: 0,
+		y: 0
+	}, m = (e) => {
+		if (d.previewPoses) d.previewPoses(e);
+		else for (let [t, n] of e) n !== null && d.setPose(t, n);
+	}, h = new Set(s.draggedIds), g = /* @__PURE__ */ new Map();
+	for (let e of h) d.getNode(e) && g.set(e, c.getBounds(d.getPose(e)));
+	let _ = (e) => {
+		let t = g.get(e);
+		return t !== void 0 && d.getNode(e) !== void 0 && i(c.getBounds(d.getPose(e)), t);
+	}, v = /* @__PURE__ */ new Map(), y = r(), b = {
+		ids: s.draggedIds.slice(),
+		stop: () => {
+			if (!o.isActive(y)) {
+				u.delete(b);
+				return;
+			}
+			x.cancel(), S();
+		}
+	};
+	u.add(b), m(new Map([...h].flatMap((e) => {
+		let t = f.get(e);
+		return t === void 0 ? [] : [[e, t]];
+	})));
+	let x = o.decay({
+		from: {
+			x: 0,
+			y: 0
+		},
+		velocity: {
+			x: a.vx,
+			y: a.vy
+		},
+		friction: a.friction,
+		cancelKey: y,
+		add: (e, t) => ({
+			x: e.x + t.x,
+			y: e.y + t.y
+		}),
+		scale: (e, t) => ({
+			x: e.x * t,
+			y: e.y * t
+		}),
+		magnitude: (e) => Math.hypot(e.x, e.y),
+		onTick: (t) => {
+			p = t;
+			let r = l !== void 0, i = /* @__PURE__ */ new Map();
+			for (let a of [...h]) {
+				if (!_(a)) {
+					h.delete(a), i.set(a, null);
+					continue;
+				}
+				let o = f.get(a);
+				if (!o) continue;
+				let s = c.getBounds(o), { nx: u, ny: d, hitX: p, hitY: m } = n(l, s.x + t.x, s.y + t.y);
+				!p && !m && (r = !1), v.set(a, {
+					x: u,
+					y: d
+				}), i.set(a, e(o, u - s.x, d - s.y, c));
+			}
+			m(i);
+			for (let e of h) g.set(e, c.getBounds(d.getPose(e)));
+			if (h.size === 0) {
+				u.delete(b), x.cancel();
+				return;
+			}
+			a.boundary === "stop" && r && b.stop();
+		},
+		onDone: () => {
+			S();
+		}
+	});
+	function S() {
+		if (!u.delete(b)) return;
+		let n = [], r = /* @__PURE__ */ new Map();
+		for (let i of h) {
+			if (r.set(i, null), !_(i)) continue;
+			let a = f.get(i);
+			if (!a) continue;
+			let o = c.getBounds(a), l = v.get(i) ?? {
+				x: o.x + p.x,
+				y: o.y + p.y
+			}, u = e(a, l.x - o.x, l.y - o.y, c), d = s.origin.get(i) ?? a;
+			n.push(t({
+				id: i,
+				from: d,
+				to: u,
+				label: "flick"
+			}));
+		}
+		if (n.length > 0) {
+			if (d.applyOps) d.applyOps(n, "flick");
+			else if (d.previewPoses) for (let e of n) e.apply(d);
+		}
+		d.previewPoses?.(r);
+	}
+}
+//#endregion
+export { a as coastByWrite };
+
+//# sourceMappingURL=coastByWrite.js.map

package/dist/animation/behaviors/coastByWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coastByWrite.js","names":["coastByWrite","adapter","ctx","startPoses","lastValue","show","poses","id","pose","riding","lastSeen","d","stillOurs","seen","sameBounds","finalPositions","cancelKey","coastKey","coast","animator","decayHandle","commitFlick","coasts","start","p","q","v","k","delta","allHit","bounds","frame","o","clampCorner","hitX","hitY","nx","ny","translatePoseViaDescriptor","ops","shown","fp","finalPose","from","createTransformOp","op"],"sources":["../../../src/animation/behaviors/coastByWrite.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport type { Op } from 'core/ops/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { translatePoseViaDescriptor } from 'core/geometry/poseDescriptor';\nimport { clampCorner, coastKey, sameBounds, type Coast, type CoastArgs } from './coast';\n\ninterface Delta { x: number; y: number }\n\n/**\n * A coast over an adapter with no pose targets: one decay of the flick's travel, written to\n * every node it carries each frame, through `previewPoses` where the adapter has it and\n * `setPose` where it does not. Nothing else animating a node adds to it.\n */\nexport function coastByWrite<TPose>(a: CoastArgs<TPose>): void {\n  const { animator, ctx, d, bounds, coasts } = a;\n  const adapter = ctx.adapter;\n  const startPoses = new Map<string, TPose>(ctx.current);\n  let lastValue: Delta = { x: 0, y: 0 };\n  const show = (poses: Map<string, TPose | null>): void => {\n    if (adapter.previewPoses) adapter.previewPoses(poses);\n    else for (const [id, pose] of poses) if (pose !== null) adapter.setPose(id, pose);\n  };\n  // What the scene held for each node right after the coast last wrote it.\n  // A node that is gone, or reads back as anything else, has another\n  // writer now, an undo or a delete, and leaves the coast unrecorded.\n  const riding = new Set(ctx.draggedIds);\n  const lastSeen = new Map<string, Bounds>();\n  for (const id of riding) {\n    if (adapter.getNode(id)) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n  }\n  const stillOurs = (id: string): boolean => {\n    const seen = lastSeen.get(id);\n    return seen !== undefined && adapter.getNode(id) !== undefined\n      && sameBounds(d.getBounds(adapter.getPose(id)), seen);\n  };\n  // Where each node was last put, which under bounds is not its start plus the decay's travel.\n  const finalPositions = new Map<string, Delta>();\n  const cancelKey = coastKey();\n  const coast: Coast = {\n    ids: ctx.draggedIds.slice(),\n    stop: (): void => {\n      // Canceled from outside (cancelAll, unmount), it stopped long ago and somewhere else.\n      if (!animator.isActive(cancelKey)) {\n        coasts.delete(coast);\n        return;\n      }\n      decayHandle.cancel();\n      commitFlick();\n    },\n  };\n  coasts.add(coast);\n  // Held from the release itself, so no frame paints the pre-drag pose\n  // between the drag's preview going away and the first coast frame.\n  show(new Map([...riding].flatMap((id) => {\n    const start = startPoses.get(id);\n    return start === undefined ? [] : [[id, start] as const];\n  })));\n  const decayHandle = animator.decay<Delta>({\n    from: { x: 0, y: 0 },\n    velocity: { x: a.vx, y: a.vy },\n    friction: a.friction,\n    cancelKey,\n    add: (p, q) => ({ x: p.x + q.x, y: p.y + q.y }),\n    scale: (v, k) => ({ x: v.x * k, y: v.y * k }),\n    magnitude: (v) => Math.hypot(v.x, v.y),\n    onTick: (delta) => {\n      lastValue = delta;\n      let allHit = bounds !== undefined;\n      const frame = new Map<string, TPose | null>();\n      for (const id of [...riding]) {\n        if (!stillOurs(id)) {\n          riding.delete(id);\n          frame.set(id, null);\n          continue;\n        }\n        const start = startPoses.get(id);\n        if (!start) continue;\n        const o = d.getBounds(start);\n        const { nx, ny, hitX, hitY } = clampCorner(bounds, o.x + delta.x, o.y + delta.y);\n        if (!hitX && !hitY) allHit = false;\n        finalPositions.set(id, { x: nx, y: ny });\n        frame.set(id, translatePoseViaDescriptor(start, nx - o.x, ny - o.y, d));\n      }\n      show(frame);\n      for (const id of riding) lastSeen.set(id, d.getBounds(adapter.getPose(id)));\n      if (riding.size === 0) {\n        coasts.delete(coast);\n        decayHandle.cancel();\n        return;\n      }\n      // Under 'stop', once every node is at the boundary the coast ends\n      // there instead of drifting along the edge as friction wears off.\n      if (a.boundary === 'stop' && allHit) coast.stop();\n    },\n    onDone: () => {\n      commitFlick();\n    },\n  });\n\n  function commitFlick(): void {\n    if (!coasts.delete(coast)) return;\n    const ops: Op[] = [];\n    const shown = new Map<string, TPose | null>();\n    for (const id of riding) {\n      shown.set(id, null);\n      if (!stillOurs(id)) continue;\n      const start = startPoses.get(id);\n      if (!start) continue;\n      const o = d.getBounds(start);\n      const fp = finalPositions.get(id) ?? { x: o.x + lastValue.x, y: o.y + lastValue.y };\n      const finalPose = translatePoseViaDescriptor(start, fp.x - o.x, fp.y - o.y, d);\n      const from = ctx.origin.get(id) ?? start;\n      ops.push(createTransformOp<TPose>({ id, from, to: finalPose, label: 'flick' }));\n    }\n    // The document first, so the preview never gives way to the pre-drag pose.\n    if (ops.length > 0) {\n      if (adapter.applyOps) adapter.applyOps(ops, 'flick');\n      else if (adapter.previewPoses) for (const op of ops) op.apply(adapter);\n    }\n    adapter.previewPoses?.(shown);\n  }\n}\n"],"mappings":"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"}