@weasel-js/core 1.10.1 → 1.11.0

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","at","cursor","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","strokeHitTest","multiply","scale","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 { multiply, scale, scaleDelta, screenAngleOf, standoff, strokeHitTest } 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';\nimport type { CursorSpec } from '@weasel-js/cursor';\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`. */\n  region: AffordanceRegion;\n  /** The region's cursor at the hit point. */\n  cursor?: CursorSpec;\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      const { cursor } = best.region;\n      const at = typeof cursor === 'function' ? cursor({ x: wx, y: wy }, view) : cursor;\n      return {\n        affordanceId: a.id,\n        regionId: best.region.id,\n        region: best.region,\n        ...(at !== undefined ? { cursor: at } : {}),\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  if (s.kind === 'outline') return 0;\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 === 'outline') {\n    const s = region.shape;\n    return strokeHitTest(s.path, local.x, local.y, 0, {\n      slop: { px: s.hitRadiusPx, transform: multiply(scale(view.scale.x, view.scale.y), xf.toWorld) },\n    });\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, 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":[],"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 { multiply, scale, scaleDelta, screenAngleOf, standoff, strokeHitTest } 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';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport { edgeHandlesFit } from 'interactions/actions/resize/cornerHandles';\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`. */\n  region: AffordanceRegion;\n  /** The region's cursor at the hit point. */\n  cursor?: CursorSpec;\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      if (isVisible && region.chromeId && !isVisible(region.chromeId)) continue;\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      const { cursor } = best.region;\n      const at = typeof cursor === 'function' ? cursor({ x: wx, y: wy }, view) : cursor;\n      return {\n        affordanceId: a.id,\n        regionId: best.region.id,\n        region: best.region,\n        ...(at !== undefined ? { cursor: at } : {}),\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  if (s.kind === 'outline') return 0;\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/** Whether a point region is live in `view`: false for an edge handle whose\n *  body is too small on screen to have room for one (`edgeOf`). A region that\n *  is not live is neither hit nor painted. */\nexport function pointRegionLive(shape: PointShape, xf: TargetTransform, view: View): boolean {\n  return !shape.edgeOf || edgeHandlesFit(shape.edgeOf, xf, view.scale, shape.hitRadiusPx);\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    if (!pointRegionLive(region.shape, xf, view)) return false;\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 === 'outline') {\n    const s = region.shape;\n    return strokeHitTest(s.path, local.x, local.y, 0, {\n      slop: { px: s.hitRadiusPx, transform: multiply(scale(view.scale.x, view.scale.y), xf.toWorld) },\n    });\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, 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":";;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,qBACd,aACA,IACA,IACA,OACA,MACA,WAC4B;CAC5B,KAAK,IAAI,IAAI,YAAY,SAAS,GAAG,KAAK,GAAG,KAAK;EAChD,MAAM,IAAI,YAAY;EACtB,IAAI,aAAa,CAAC,UAAU,EAAE,EAAE,GAAG;EACnC,MAAM,UAAU,EAAE,QAAQ,KAAK;EAC/B,IAAI,OAAwD;EAC5D,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;GACvC,MAAM,SAAS,QAAQ;GACvB,IAAI,aAAa,OAAO,YAAY,CAAC,UAAU,OAAO,QAAQ,GAAG;GACjE,MAAM,KAAK,YAAY,OAAO,OAAO,QAAQ;GAC7C,IAAI,CAAC,UAAU,QAAQ,IAAI,IAAI,IAAI,IAAI,GAAG;GAC1C,MAAM,KAAK,gBAAgB,QAAQ,IAAI,IAAI,IAAI,IAAI;GAGnD,IAAI,SAAS,QAAQ,MAAM,KAAK,IAAI,OAAO;IAAE;IAAQ;GAAG;EAC1D;EACA,IAAI,MAAM;GACR,MAAM,EAAE,WAAW,KAAK;GACxB,MAAM,KAAK,OAAO,WAAW,aAAa,OAAO;IAAE,GAAG;IAAI,GAAG;GAAG,GAAG,IAAI,IAAI;GAC3E,OAAO;IACL,cAAc,EAAE;IAChB,UAAU,KAAK,OAAO;IACtB,QAAQ,KAAK;IACb,GAAI,OAAO,SAAY,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzC,SAAS,KAAK,OAAO,KAAK;GAC5B;EACF;CACF;CACA,OAAO;AACT;;;AAIA,SAAS,gBACP,QACA,IACA,IACA,IACA,MACQ;CACR,MAAM,IAAI,OAAO;CACjB,IAAI,EAAE,SAAS,WAAW,OAAO;CACjC,MAAM,IAAI,EAAE,SAAS,UACjB,kBAAkB,GAAG,IAAI,IAAI,IAC7B,EAAE,SAAS,YACT,aAAa,IAAI,EAAE,IAAI,EAAE,EAAE,IAC3B,aAAa,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAG,EAAE,IAAI,EAAE,SAAS,CAAC;CAC5D,MAAM,KAAK,EAAE,IAAI;CACjB,MAAM,KAAK,EAAE,IAAI;CACjB,OAAO,KAAK,KAAK,KAAK;AACxB;;AAOA,SAAgB,YAAY,OAAoB,UAA0C;CACxF,IAAI,aAAa,MAAM,OAAO;CAC9B,OAAO,kBAAkB,MAAM,SAAS,QAAQ,CAAC;AACnD;;;;;AAUA,SAAgB,iBACd,OACA,IACA,MACiG;CACjG,MAAM,IAAI,kBAAkB,OAAO,IAAI,IAAI;CAC3C,MAAM,QAAQ,MAAM,SAAS,cAAc,QAAQ,EAAE,GAAG,KAAK,KAAK,IAAI;CACtE,MAAM,OAAO,MAAM;CACnB,MAAM,IAAsB,CAAC,CAAC,MAAM,IAAI;CACxC,MAAM,IAAsB,CAAC,CAAC,MAAM,IAAI;CACxC,MAAM,OAAO,MAAM;CACnB,IAAI,MAAM;EAER,MAAM,QAAQ,WAAW,mBAAmB,MAAM,KAAK,OAAO,EAAE;EAGhE,MAAM,CAAC,GAAG,GAAG,GAAG,KAAK,GAAG;EACxB,MAAM,OAAO,KAAK,QAAQ,IAAI,KAAK,KAAK,KAAK,MAAM,IAAI,KAAK,MAAM,KAAK,IAAI,IAAI,IAAI,EAAE;EACrF,IAAI,KAAK,QAAQ,MAAM,GAAG,EAAE,KAAK,QAAQ,IAAI,IAAI,IAAI,KAAK;EAC1D,IAAI,KAAK,SAAS,MAAM,GAAG,EAAE,OAAO,IAAI,IAAI,KAAK;CACnD;CACA,OAAO;EAAE,GAAG,EAAE;EAAG,GAAG,EAAE;EAAG;EAAO;EAAM;EAAG;CAAE;AAC7C;;;;AAKA,SAAgB,gBAAgB,OAAmB,IAAqB,MAAqB;CAC3F,OAAO,CAAC,MAAM,UAAU,eAAe,MAAM,QAAQ,IAAI,KAAK,OAAO,MAAM,WAAW;AACxF;;;AAIA,IAAM,mBAAmB;;;AAIzB,SAAgB,sBACd,OACA,IACA,MACA,UAC4B;CAC5B,MAAM,IAAI,iBAAiB,OAAO,IAAI,IAAI;CAC1C,MAAM,CAAC,IAAI,MAAM,SAAS,EAAE,GAAG,EAAE,CAAC;CAClC,MAAM,IAAI,KAAK,IAAI,EAAE,KAAK,GAAG,KAAK,KAAK,IAAI,EAAE,KAAK;CAClD,OAAO;EAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;EAAG,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;EAAG,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;EAAG,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,QAAQ;EAC/F,GAAG,KAAK,IAAI,IAAI,KAAK;EACrB,GAAG,KAAK,KAAK,IAAI,IAAI;CACvB,EAAE;AACJ;;AAGA,SAAgB,kBACd,OACA,IACA,MAC0B;CAC1B,MAAM,IAAI,aAAa,IAAI,MAAM,GAAG,MAAM,CAAC;CAC3C,IAAI,CAAC,MAAM,UAAU,OAAO;CAC5B,OAAO,SAAS,GAAG,cAAc,IAAI,MAAM,SAAS,MAAM,GAAG,MAAM,SAAS,IAAI,KAAK,KAAK;AAC5F;;;;;;AAOA,SAAgB,gBACd,OACA,MAGA,KAAsB,iBACM;CAC5B,MAAM,SAAS,MAAM,aAAa;CAClC,IAAI,WAAW,GAAG,OAAO;EAAE,IAAI,MAAM;EAAI,IAAI,MAAM;CAAG;CACtD,MAAM,OAAO,WAAW,QAAQ,KAAK,OAAO,EAAE;CAC9C,OAAO;EACL,IAAI,KAAK,IAAI,MAAM,IAAI,MAAM,aAAa,IAAI,KAAK,CAAC;EACpD,IAAI,KAAK,IAAI,MAAM,IAAI,MAAM,cAAc,IAAI,KAAK,CAAC;CACvD;AACF;AAIA,SAAS,UACP,QACA,IACA,IACA,IACA,MACS;CACT,IAAI,OAAO,MAAM,SAAS,SAAS;EAMjC,IAAI,CAAC,gBAAgB,OAAO,OAAO,IAAI,IAAI,GAAG,OAAO;EACrD,MAAM,IAAI,iBAAiB,OAAO,OAAO,IAAI,IAAI;EACjD,MAAM,IAAI,WAAW,KAAK,EAAE,GAAG,KAAK,EAAE,GAAG,KAAK,KAAK;EACnD,MAAM,IAAI,KAAK,IAAI,EAAE,KAAK,GAAG,KAAK,KAAK,IAAI,EAAE,KAAK;EAClD,MAAM,IAAI,IAAI,EAAE,IAAI,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,IAAI,EAAE;EACpD,OAAO,KAAK,EAAE,EAAE,MAAM,KAAK,EAAE,EAAE,MAAM,KAAK,EAAE,EAAE,MAAM,KAAK,EAAE,EAAE;CAC/D;CACA,MAAM,QAAQ,aAAa,IAAI,IAAI,EAAE;CACrC,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,OAAO,MAAM,SAAS,WAAW;EACnC,MAAM,IAAI,OAAO;EACjB,OAAO,cAAc,EAAE,MAAM,MAAM,GAAG,MAAM,GAAG,GAAG,EAChD,MAAM;GAAE,IAAI,EAAE;GAAa,WAAW,SAAS,MAAM,KAAK,MAAM,GAAG,KAAK,MAAM,CAAC,GAAG,GAAG,OAAO;EAAE,EAChG,CAAC;CACH;CACA,IAAI,OAAO,MAAM,SAAS,WAAW;EACnC,MAAM,IAAI,OAAO;EAKjB,IAFE,MAAM,KAAK,EAAE,UAAU,MAAM,KAAK,EAAE,SAAS,EAAE,cAC/C,MAAM,KAAK,EAAE,UAAU,MAAM,KAAK,EAAE,SAAS,EAAE,aAChC,OAAO;EAExB,MAAM,EAAE,IAAI,OAAO,gBAAgB,GAAG,MAAM,EAAE;EAC9C,IAAI,MAAM,KAAK,MAAM,GAAG,OAAO;EAC/B,MAAM,MAAM,MAAM,IAAI,EAAE,MAAM;EAC9B,MAAM,MAAM,MAAM,IAAI,EAAE,MAAM;EAC9B,OAAO,KAAK,KAAK,KAAK,MAAM;CAC9B;CAEA,MAAM,IAAI,OAAO;CACjB,OAAO,MAAM,KAAK,EAAE,KAAK,MAAM,KAAK,EAAE,IAAI,EAAE,SACrC,MAAM,KAAK,EAAE,KAAK,MAAM,KAAK,EAAE,IAAI,EAAE;AAC9C"}

package/dist/affordances/pathAnchors.js

@@ -1,88 +1,163 @@
-import { enumerateAnchors as e } from "../interactions/actions/edit-anchors/geometry.js";
+import { enumerateAnchors } from "../interactions/actions/edit-anchors/geometry.js";
+import { pathToAnchors } from "@weasel-js/geom";
+
 //#region src/affordances/pathAnchors.ts
-var t = "path-edit.anchors";
-function n(n, r = {}) {
-	let { hitRadius: i = 8, cursor: a = "pointer" } = r, o = (e) => {
-		let t = n();
-		if (!t) return [];
-		let r = [];
-		for (let n of e.selection) {
-			let e = t.getPose(n);
-			e && e.kind === "polygon" && r.push({
-				id: n,
-				path: e
+/** Chrome-caps id gating the anchor, control, and segment affordances. */
+var PATH_ANCHOR_CHROME_ID = "path-edit.anchors";
+/**
+* Segment, extension-part, anchor, and control affordances for the selected
+* paths, bottom → top.
+*
+* Three affordances rather than one, so that a control handle beats an anchor
+* regardless of which is nearer, the way controls draw on top, and both beat
+* the segment they sit on. Within each, nearest wins. A press on the edited
+* path's outline is a `segment` hit, which the segment bend binds to and a
+* selection move turns down. Anchors, controls, and segments share one id:
+* chrome-caps gates anchor editing as a single piece of chrome. A part a
+* path-edit extension adds (`PathEditExtension.parts`) may name a chrome id of
+* its own as well, so it can be shown apart from the anchors.
+*
+* Order matters — spread this into an affordance list in the returned order.
+*/
+function createPathAnchorAffordances(getAnchorState, opts = {}) {
+	const { hitRadius = 8, cursor = "pointer" } = opts;
+	/** Selected polygon paths, paired with their node id. */
+	const editablePaths = (state) => {
+		const anchorState = getAnchorState();
+		if (!anchorState) return [];
+		const out = [];
+		for (const id of state.selection) {
+			const pose = anchorState.getPose(id);
+			if (!pose || pose.kind !== "polygon") continue;
+			out.push({
+				id,
+				path: pose
 			});
 		}
-		return r;
-	}, s = (e, t, n, r, o, s) => ({
-		id: e,
+		return out;
+	};
+	const point = (id, targetId, x, y, scratch, hitKind) => ({
+		id,
 		targetId: null,
 		shape: {
 			kind: "point",
-			x: n,
-			y: r,
-			hitRadiusPx: i
+			x,
+			y,
+			hitRadiusPx: hitRadius
 		},
-		hitKind: s,
-		cursor: a,
+		hitKind,
+		...getAnchorState()?.tool ? {} : { cursor },
 		bind: () => ({ initialScratch: {
-			...o,
-			targetId: t
+			...scratch,
+			targetId
 		} })
 	});
+	const anchors = {
+		id: PATH_ANCHOR_CHROME_ID,
+		regions(state) {
+			const editingId = getAnchorState()?.editingId ?? null;
+			const out = [];
+			for (const { id, path } of editablePaths(state)) {
+				if (editingId !== null && id !== editingId) continue;
+				for (const a of enumerateAnchors(path)) out.push(point(`${id}:anchor:${a.anchorIndex}`, id, a.x, a.y, {
+					targetId: id,
+					anchorIndex: a.anchorIndex,
+					part: "anchor"
+				}, `anchor:${a.anchorIndex}`));
+			}
+			return out;
+		}
+	};
+	const controls = {
+		id: PATH_ANCHOR_CHROME_ID,
+		regions(state) {
+			const editingId = getAnchorState()?.editingId ?? null;
+			if (editingId === null) return [];
+			const out = [];
+			for (const { id, path } of editablePaths(state)) {
+				if (id !== editingId) continue;
+				for (const a of enumerateAnchors(path)) {
+					if (a.controlIn) out.push(point(`${id}:controlIn:${a.anchorIndex}`, id, a.controlIn.x, a.controlIn.y, {
+						targetId: id,
+						anchorIndex: a.anchorIndex,
+						part: "controlIn"
+					}, `controlIn:${a.anchorIndex}`));
+					if (a.controlOut) out.push(point(`${id}:controlOut:${a.anchorIndex}`, id, a.controlOut.x, a.controlOut.y, {
+						targetId: id,
+						anchorIndex: a.anchorIndex,
+						part: "controlOut"
+					}, `controlOut:${a.anchorIndex}`));
+				}
+			}
+			return out;
+		}
+	};
 	return [
 		{
-			id: t,
-			regions(e) {
-				let t = n()?.editingId ?? null;
-				if (t === null) return [];
-				let r = o(e).find(({ id: e }) => e === t);
-				return r ? [{
-					id: `${t}:segment`,
+			id: PATH_ANCHOR_CHROME_ID,
+			regions(state) {
+				const editingId = getAnchorState()?.editingId ?? null;
+				if (editingId === null) return [];
+				const edited = editablePaths(state).find(({ id }) => id === editingId);
+				if (!edited) return [];
+				const outline = getAnchorState()?.getOutline?.(editingId);
+				return [{
+					id: `${editingId}:segment`,
 					targetId: null,
 					shape: {
 						kind: "outline",
-						path: r.path,
-						hitRadiusPx: i
+						path: outline?.kind === "polygon" ? outline : edited.path,
+						hitRadiusPx: hitRadius
 					},
 					hitKind: "segment",
-					bind: () => ({ initialScratch: { targetId: t } })
-				}] : [];
+					bind: () => ({ initialScratch: { targetId: editingId } })
+				}];
 			}
 		},
-		{
-			id: t,
-			regions(t) {
-				let r = n()?.editingId ?? null, i = [];
-				for (let { id: n, path: a } of o(t)) if (r === null || n === r) for (let t of e(a)) i.push(s(`${n}:anchor:${t.anchorIndex}`, n, t.x, t.y, {
-					targetId: n,
-					anchorIndex: t.anchorIndex,
-					part: "anchor"
-				}, `anchor:${t.anchorIndex}`));
-				return i;
-			}
-		},
-		{
-			id: t,
-			regions(t) {
-				let r = n()?.editingId ?? null;
-				if (r === null) return [];
-				let i = [];
-				for (let { id: n, path: a } of o(t)) if (n === r) for (let t of e(a)) t.controlIn && i.push(s(`${n}:controlIn:${t.anchorIndex}`, n, t.controlIn.x, t.controlIn.y, {
-					targetId: n,
-					anchorIndex: t.anchorIndex,
-					part: "controlIn"
-				}, `controlIn:${t.anchorIndex}`)), t.controlOut && i.push(s(`${n}:controlOut:${t.anchorIndex}`, n, t.controlOut.x, t.controlOut.y, {
-					targetId: n,
-					anchorIndex: t.anchorIndex,
-					part: "controlOut"
-				}, `controlOut:${t.anchorIndex}`));
-				return i;
-			}
-		}
+		extensionParts(getAnchorState, hitRadius, cursor),
+		anchors,
+		controls
 	];
 }
-//#endregion
-export { t as PATH_ANCHOR_CHROME_ID, n as createPathAnchorAffordances };
+/** The parts path-edit extensions add to the path in edit mode while it is
+*  selected, each pressed as its own `hitKind`. */
+function extensionParts(getAnchorState, hitRadius, cursor) {
+	return {
+		id: PATH_ANCHOR_CHROME_ID,
+		regions(state) {
+			const anchorState = getAnchorState();
+			const editingId = anchorState?.editingId ?? null;
+			const extensions = anchorState?.extensions?.filter((e) => e.parts) ?? [];
+			if (editingId === null || extensions.length === 0) return [];
+			if (!state.selection.includes(editingId)) return [];
+			const pose = anchorState.getPose(editingId);
+			const node = anchorState.getNode?.(editingId);
+			if (!node || !pose || pose.kind !== "polygon") return [];
+			const target = {
+				id: editingId,
+				node,
+				path: pose,
+				anchors: pathToAnchors(pose)
+			};
+			return extensions.flatMap((ext) => ext.parts(target).map((part) => ({
+				id: `${editingId}:${part.hitKind}`,
+				targetId: null,
+				shape: {
+					kind: "point",
+					x: part.x,
+					y: part.y,
+					hitRadiusPx: part.hitRadiusPx ?? hitRadius,
+					...part.standoff ? { standoff: part.standoff } : {}
+				},
+				hitKind: part.hitKind,
+				...part.chromeId ? { chromeId: part.chromeId } : {},
+				cursor,
+				bind: () => ({ initialScratch: { targetId: editingId } })
+			})));
+		}
+	};
+}
 
+//#endregion
+export { PATH_ANCHOR_CHROME_ID, createPathAnchorAffordances };
 //# sourceMappingURL=pathAnchors.js.map

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","edited","a","enumerateAnchors","path"],"sources":["../../src/affordances/pathAnchors.ts"],"sourcesContent":["/** Path anchor, control-handle, and segment 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 every returned affordance. */\nexport const PATH_ANCHOR_CHROME_ID = 'path-edit.anchors';\n\n/**\n * Segment, anchor, and control affordances for the selected paths, bottom →\n * top.\n *\n * Three affordances rather than one, so that a control handle beats an anchor\n * regardless of which is nearer, the way controls draw on top, and both beat\n * the segment they sit on. Within each, nearest wins. A press on the edited\n * path's outline is a `segment` hit, which the segment bend binds to and a\n * selection move turns down. They deliberately share one id: chrome-caps\n * 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  const segments: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const editingId = getAnchorState()?.editingId ?? null;\n      if (editingId === null) return [];\n      const edited = editablePaths(state).find(({ id }) => id === editingId);\n      if (!edited) return [];\n      return [{\n        id: `${editingId}:segment`,\n        targetId: null,\n        shape: { kind: 'outline', path: edited.path, hitRadiusPx: hitRadius },\n        hitKind: 'segment',\n        bind: (): AffordanceBinding => ({ initialScratch: { targetId: editingId } }),\n      }];\n    },\n  };\n\n  return [segments, anchors, controls];\n}\n"],"mappings":";;AAuCA,IAAaA,IAAwB;AAerC,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;CA2EA,OAAO;EAAC;GAhBN,IAAIZ;GACJ,QAAQ,GAAO;IACb,IAAMa,IAAYR,EAAe,CAAC,EAAE,aAAa;IACjD,IAAIQ,MAAc,MAAM,OAAO,CAAC;IAChC,IAAMC,IAASX,EAAcK,CAAK,CAAC,CAAC,MAAM,EAAE,YAASD,MAAOM,CAAS;IAErE,OADKC,IACE,CAAC;KACN,IAAI,GAAGD,EAAU;KACjB,UAAU;KACV,OAAO;MAAE,MAAM;MAAW,MAAMC,EAAO;MAAM,aAAaH;KAAU;KACpE,SAAS;KACT,aAAgC,EAAE,gBAAgB,EAAE,UAAUE,EAAU,EAAE;IAC5E,CAAC,IAPmB,CAAC;GAQvB;EAGM;EAAU;GAxEhB,IAAIb;GACJ,QAAQ,GAAO;IACb,IAAMa,IAAYR,EAAe,CAAC,EAAE,aAAa,MAC3CC,IAA0B,CAAC;IACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAI5C,IAAIK,MAAc,QAAQN,MAAOM,GACjC,KAAK,IAAME,KAAKC,EAAiBC,CAAI,GACnC,EAAI,KAAKP,EACP,GAAGH,EAAG,UAAUQ,EAAE,eAClBR,GAAIQ,EAAE,GAAGA,EAAE,GACX;KAAE,UAAUR;KAAI,aAAaQ,EAAE;KAAa,MAAM;IAAS,GAC3D,UAAUA,EAAE,aACd,CAAC;IAGL,OAAOT;GACT;EAqDgB;EAAS;GAjDzB,IAAIN;GACJ,QAAQ,GAAO;IAEb,IAAMa,IADcR,EACF,CAAA,EAAa,aAAa;IAC5C,IAAIQ,MAAc,MAAM,OAAO,CAAC;IAChC,IAAMP,IAA0B,CAAC;IACjC,KAAK,IAAM,EAAE,OAAI,aAAUH,EAAcK,CAAK,GAE5C,IAAID,MAAOM,GACX,KAAK,IAAME,KAAKC,EAAiBC,CAAI,GASnC,AARIF,EAAE,aACJT,EAAI,KAAKI,EACP,GAAGH,EAAG,aAAaQ,EAAE,eACrBR,GAAIQ,EAAE,UAAU,GAAGA,EAAE,UAAU,GAC/B;KAAE,UAAUR;KAAI,aAAaQ,EAAE;KAAa,MAAM;IAAY,GAC9D,aAAaA,EAAE,aACjB,CAAC,GAECA,EAAE,cACJT,EAAI,KAAKI,EACP,GAAGH,EAAG,cAAcQ,EAAE,eACtBR,GAAIQ,EAAE,WAAW,GAAGA,EAAE,WAAW,GACjC;KAAE,UAAUR;KAAI,aAAaQ,EAAE;KAAa,MAAM;IAAa,GAC/D,cAAcA,EAAE,aAClB,CAAC;IAIP,OAAOT;GACT;EAoByB;CAAQ;AACrC"}
+{"version":3,"file":"pathAnchors.js","names":[],"sources":["../../src/affordances/pathAnchors.ts"],"sourcesContent":["/** Path anchor, control-handle, and segment affordances, and the parts path-edit extensions add. */\n\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport { pathToAnchors, type AnchorSet, type PolygonPath } from '@weasel-js/geom';\nimport { enumerateAnchors } from 'interactions/actions/edit-anchors/geometry';\nimport type { PathEditExtension } from 'features/paths/pathEditExtension';\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  /** The committed pose and data of a node, which extensions' parts read. */\n  getNode?(id: string): { pose: unknown; data: unknown } | null;\n  /** The path-edit extensions whose parts are pressed, in order. */\n  extensions?: readonly PathEditExtension[];\n  /** The active path-edit tool, if any. While one is set, anchors and controls\n   *  carry no cursor of their own, so the tool's action shows its own. */\n  tool?: string | null;\n  /** The path whose outline counts as a segment press, when it is not\n   *  `getPose`'s: a path drawn from a form, edited through the form's edit\n   *  path. */\n  getOutline?(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, with no path-edit tool\n   *  active. 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 the anchor, control, and segment affordances. */\nexport const PATH_ANCHOR_CHROME_ID = 'path-edit.anchors';\n\n/**\n * Segment, extension-part, anchor, and control affordances for the selected\n * paths, bottom → top.\n *\n * Three affordances rather than one, so that a control handle beats an anchor\n * regardless of which is nearer, the way controls draw on top, and both beat\n * the segment they sit on. Within each, nearest wins. A press on the edited\n * path's outline is a `segment` hit, which the segment bend binds to and a\n * selection move turns down. Anchors, controls, and segments share one id:\n * chrome-caps gates anchor editing as a single piece of chrome. A part a\n * path-edit extension adds (`PathEditExtension.parts`) may name a chrome id of\n * its own as well, so it can be shown apart from the anchors.\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    ...(getAnchorState()?.tool ? {} : { 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  const segments: Affordance = {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const editingId = getAnchorState()?.editingId ?? null;\n      if (editingId === null) return [];\n      const edited = editablePaths(state).find(({ id }) => id === editingId);\n      if (!edited) return [];\n      const outline = getAnchorState()?.getOutline?.(editingId) as PolygonPath | null | undefined;\n      return [{\n        id: `${editingId}:segment`,\n        targetId: null,\n        shape: { kind: 'outline', path: outline?.kind === 'polygon' ? outline : edited.path, hitRadiusPx: hitRadius },\n        hitKind: 'segment',\n        bind: (): AffordanceBinding => ({ initialScratch: { targetId: editingId } }),\n      }];\n    },\n  };\n\n  return [segments, extensionParts(getAnchorState, hitRadius, cursor), anchors, controls];\n}\n\n/** The parts path-edit extensions add to the path in edit mode while it is\n *  selected, each pressed as its own `hitKind`. */\nfunction extensionParts(\n  getAnchorState: () => AnchorState | null,\n  hitRadius: number,\n  cursor: CursorSpec,\n): Affordance {\n  return {\n    id: PATH_ANCHOR_CHROME_ID,\n    regions(state) {\n      const anchorState = getAnchorState();\n      const editingId = anchorState?.editingId ?? null;\n      const extensions = anchorState?.extensions?.filter((e) => e.parts) ?? [];\n      if (editingId === null || extensions.length === 0) return [];\n      if (!(state.selection as readonly string[]).includes(editingId)) return [];\n      const pose = anchorState!.getPose(editingId);\n      const node = anchorState!.getNode?.(editingId);\n      if (!node || !pose || (pose as { kind?: string }).kind !== 'polygon') return [];\n      const target = {\n        id: editingId, node, path: pose as PolygonPath, anchors: pathToAnchors(pose as PolygonPath) as AnchorSet,\n      };\n      return extensions.flatMap((ext) => ext.parts!(target).map((part): AffordanceRegion => ({\n        id: `${editingId}:${part.hitKind}`,\n        targetId: null,\n        shape: {\n          kind: 'point', x: part.x, y: part.y, hitRadiusPx: part.hitRadiusPx ?? hitRadius,\n          ...(part.standoff ? { standoff: part.standoff } : {}),\n        },\n        hitKind: part.hitKind,\n        ...(part.chromeId ? { chromeId: part.chromeId } : {}),\n        cursor,\n        bind: (): AffordanceBinding => ({ initialScratch: { targetId: editingId } }),\n      })));\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/affordances/rotateCursor.js

@@ -1,12 +1,18 @@
 //#region src/affordances/rotateCursor.ts
-function e(e, t, n) {
+/**
+* The `rotate` glyph for a pointer at world point `at` turning something
+* about world point `pivot`, seen through a view of `scale`. The glyph's arc
+* is drawn over the top of its box, so its up points from the pivot to the
+* pointer and the opening faces what is being turned.
+*/
+function rotateCursorAt(pivot, at, scale) {
 	return {
 		glyph: "rotate",
-		angle: Math.atan2((t.x - e.x) * n.x, -(t.y - e.y) * n.y),
+		angle: Math.atan2((at.x - pivot.x) * scale.x, -(at.y - pivot.y) * scale.y),
 		fallback: "grab"
 	};
 }
-//#endregion
-export { e as rotateCursorAt };
 
+//#endregion
+export { rotateCursorAt };
 //# sourceMappingURL=rotateCursor.js.map

package/dist/affordances/rotateCursor.js.map

@@ -1 +1 @@
-{"version":3,"file":"rotateCursor.js","names":["rotateCursorAt","at","pivot","scale"],"sources":["../../src/affordances/rotateCursor.ts"],"sourcesContent":["import type { CursorSpec } from '@weasel-js/cursor';\nimport type { Scale2 } from '@weasel-js/geom';\n\n/**\n * The `rotate` glyph for a pointer at world point `at` turning something\n * about world point `pivot`, seen through a view of `scale`. The glyph's arc\n * is drawn over the top of its box, so its up points from the pivot to the\n * pointer and the opening faces what is being turned.\n */\nexport function rotateCursorAt(\n  pivot: { x: number; y: number },\n  at: { x: number; y: number },\n  scale: Scale2,\n): CursorSpec {\n  return {\n    glyph: 'rotate',\n    angle: Math.atan2((at.x - pivot.x) * scale.x, -(at.y - pivot.y) * scale.y),\n    fallback: 'grab',\n  };\n}\n"],"mappings":";AASA,SAAgBA,EACd,GACA,GACA,GACY;CACZ,OAAO;EACL,OAAO;EACP,OAAO,KAAK,OAAOC,EAAG,IAAIC,EAAM,KAAKC,EAAM,GAAG,EAAEF,EAAG,IAAIC,EAAM,KAAKC,EAAM,CAAC;EACzE,UAAU;CACZ;AACF"}
+{"version":3,"file":"rotateCursor.js","names":[],"sources":["../../src/affordances/rotateCursor.ts"],"sourcesContent":["import type { CursorSpec } from '@weasel-js/cursor';\nimport type { Scale2 } from '@weasel-js/geom';\n\n/**\n * The `rotate` glyph for a pointer at world point `at` turning something\n * about world point `pivot`, seen through a view of `scale`. The glyph's arc\n * is drawn over the top of its box, so its up points from the pivot to the\n * pointer and the opening faces what is being turned.\n */\nexport function rotateCursorAt(\n  pivot: { x: number; y: number },\n  at: { x: number; y: number },\n  scale: Scale2,\n): CursorSpec {\n  return {\n    glyph: 'rotate',\n    angle: Math.atan2((at.x - pivot.x) * scale.x, -(at.y - pivot.y) * scale.y),\n    fallback: 'grab',\n  };\n}\n"],"mappings":";;;;;;;AASA,SAAgB,eACd,OACA,IACA,OACY;CACZ,OAAO;EACL,OAAO;EACP,OAAO,KAAK,OAAO,GAAG,IAAI,MAAM,KAAK,MAAM,GAAG,EAAE,GAAG,IAAI,MAAM,KAAK,MAAM,CAAC;EACzE,UAAU;CACZ;AACF"}

package/dist/affordances/rotationHandle.js

@@ -1,66 +1,89 @@
-import { localToWorld 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";
-import { rotateCursorAt as r } from "./rotateCursor.js";
+import { localToWorld } from "../core/geometry/targetFrame.js";
+import { transformOf } from "./hitAffordanceRegions.js";
+import { MULTI_RESIZE_TARGET_ID } from "../core/selection/selectionTarget.js";
+import { rotateCursorAt } from "./rotateCursor.js";
+
 //#region src/affordances/rotationHandle.ts
-var i = (e) => "fill" in e || "stroke" in e || "insetPx" in e, a = {
+var isAnnulusForm = (paint) => "fill" in paint || "stroke" in paint || "insetPx" in paint;
+var DEFAULT_PAINT = {
 	fill: { paint: {
 		kind: "solid",
 		color: "rgba(26, 19, 13, 0.12)"
 	} },
 	insetPx: 10
 };
-function o(n = {}) {
-	let { bandPx: o = 24, paint: c = a, cursor: l, handle: u } = n, d = c ? i(c) ? {
-		kind: "annulus",
-		...c.fill ? { fill: c.fill } : {},
-		...c.stroke ? { stroke: c.stroke } : {},
-		...c.insetPx === void 0 ? {} : { insetPx: c.insetPx }
-	} : {
-		kind: "annulus",
-		stroke: c
-	} : null;
+/**
+* Rotation affordance for the active selection: an elliptical ring that wraps the selection —
+* the smallest ellipse containing the AABB, minus the AABB itself. Hovering the ring sets the
+* cursor (default the `rotate` glyph) and a drag from it triggers `rotateAction`.
+*
+* The ring is target-local — under target rotation the ellipse rotates with the AABB.
+* Visibility is gated by chrome-caps' `'selection.rotation-handle'` rule. `paint: null` leaves
+* the cursor change as the only cue.
+*/
+function createRotationAffordance(opts = {}) {
+	const { bandPx = 24, paint = DEFAULT_PAINT, cursor, handle } = opts;
+	const annulusPaint = (() => {
+		if (!paint) return null;
+		if (!isAnnulusForm(paint)) return {
+			kind: "annulus",
+			stroke: paint
+		};
+		return {
+			kind: "annulus",
+			...paint.fill ? { fill: paint.fill } : {},
+			...paint.stroke ? { stroke: paint.stroke } : {},
+			...paint.insetPx !== void 0 ? { insetPx: paint.insetPx } : {}
+		};
+	})();
 	return {
 		id: "selection.rotation-handle",
-		regions(n) {
-			let i = s(n);
-			if (!i) return [];
-			let a = i.bounds, c = a.width / 2, f = a.height / 2, p = e(t(n, i.id), a.x + c, a.y + f), m = l ?? ((e, t) => r(p, e, t.scale)), h = () => ({ initialScratch: {
-				targetId: i.id,
+		regions(state) {
+			const target = pickTarget(state);
+			if (!target) return [];
+			const b = target.bounds;
+			const halfW = b.width / 2;
+			const halfH = b.height / 2;
+			const pivot = localToWorld(transformOf(state, target.id), b.x + halfW, b.y + halfH);
+			const regionCursor = cursor ?? ((at, view) => rotateCursorAt(pivot, at, view.scale));
+			const bind = () => ({ initialScratch: {
+				targetId: target.id,
 				fixedPoint: {
-					x: a.x + c,
-					y: a.y + f
+					x: b.x + halfW,
+					y: b.y + halfH
 				}
-			} }), g = {
+			} });
+			const region = {
 				id: "selection.rotation-handle",
-				targetId: i.id,
+				targetId: target.id,
 				shape: {
 					kind: "annulus",
-					cx: a.x + c,
-					cy: a.y + f,
-					rx: c * Math.SQRT2,
-					ry: f * Math.SQRT2,
-					innerX: a.x,
-					innerY: a.y,
-					innerWidth: a.width,
-					innerHeight: a.height,
-					minBandPx: o
+					cx: b.x + halfW,
+					cy: b.y + halfH,
+					rx: halfW * Math.SQRT2,
+					ry: halfH * Math.SQRT2,
+					innerX: b.x,
+					innerY: b.y,
+					innerWidth: b.width,
+					innerHeight: b.height,
+					minBandPx: bandPx
 				},
-				...d ? { paint: d } : {},
+				...annulusPaint ? { paint: annulusPaint } : {},
 				hitKind: "rotate-handle",
-				cursor: m,
-				bind: h
+				cursor: regionCursor,
+				bind
 			};
-			return u ? [g, {
+			if (!handle) return [region];
+			return [region, {
 				id: "rotation-badge",
-				targetId: i.id,
+				targetId: target.id,
 				shape: {
 					kind: "point",
-					x: a.x + c,
-					y: a.y,
-					hitRadiusPx: u.hitRadiusPx,
+					x: b.x + halfW,
+					y: b.y,
+					hitRadiusPx: handle.hitRadiusPx,
 					standoff: {
-						px: u.distancePx,
+						px: handle.distancePx,
 						normal: {
 							x: 0,
 							y: -1
@@ -68,34 +91,34 @@ function o(n = {}) {
 					}
 				},
 				hitKind: "rotate-handle",
-				cursor: m,
-				bind: h
-			}] : [g];
+				cursor: regionCursor,
+				bind
+			}];
 		}
 	};
 }
-function s(e) {
-	if (e.selection.length === 1) {
-		let t = e.selection[0];
-		if (e.canRotate && !e.canRotate(t)) return null;
-		let n = e.boundsOf(t);
-		return n ? {
-			id: t,
-			bounds: n
+function pickTarget(state) {
+	if (state.selection.length === 1) {
+		const id = state.selection[0];
+		if (state.canRotate && !state.canRotate(id)) return null;
+		const b = state.boundsOf(id);
+		return b ? {
+			id,
+			bounds: b
 		} : null;
 	}
-	if (e.multiActive && e.unionBounds) {
-		if (e.canRotate) {
-			for (let t of e.selection) if (!e.canRotate(t)) return null;
+	if (state.multiActive && state.unionBounds) {
+		if (state.canRotate) {
+			for (const id of state.selection) if (!state.canRotate(id)) return null;
 		}
 		return {
-			id: n,
-			bounds: e.unionBounds
+			id: MULTI_RESIZE_TARGET_ID,
+			bounds: state.unionBounds
 		};
 	}
 	return null;
 }
-//#endregion
-export { o as createRotationAffordance };
 
+//#endregion
+export { createRotationAffordance };
 //# sourceMappingURL=rotationHandle.js.map

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","pivot","localToWorld","transformOf","regionCursor","cursor","rotateCursorAt","at","view","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 { localToWorld, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport { rotateCursorAt } from './rotateCursor';\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   *  square to the line from the pivot to the pointer, falling back to\n   *  `'grab'` if the browser rejects the 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      const pivot = localToWorld(transformOf(state, target.id), b.x + halfW, b.y + halfH);\n      const regionCursor: AffordanceRegion['cursor'] = cursor\n        ?? ((at, view) => rotateCursorAt(pivot, at, view.scale));\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":";;;;;AA8CA,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,GAEnBG,IAAQC,EAAaC,EAAYN,GAAOF,EAAO,EAAE,GAAGG,EAAE,IAAIC,GAAOD,EAAE,IAAIE,CAAK,GAC5EI,IAA2CC,OAC1C,GAAI,MAASC,EAAeL,GAAOM,GAAIC,EAAK,KAAK,IAClDC,WAAiC,EACrC,gBAAgB;IACd,UAAUd,EAAO;IAGjB,YAAY;KAAE,GAAGG,EAAE,IAAIC;KAAO,GAAGD,EAAE,IAAIE;IAAM;GAC/C,EACF,IAEMU,IAA2B;IAC/B,IAAI;IACJ,UAAUf,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,WAAWa;IACb;IACA,GAAIjB,IAAe,EAAE,OAAOA,EAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQU;IACR;GACF;GAgBA,OAfKQ,IAeE,CAACF,GAAQ;IAbd,IAAI;IACJ,UAAUf,EAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAGG,EAAE,IAAIC;KACT,GAAGD,EAAE;KACL,aAAac,EAAO;KACpB,UAAU;MAAE,IAAIA,EAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQR;IACR;GAEc,CAAK,IAfD,CAACM,CAAM;EAgB7B;CACF;AACF;AAEA,SAASd,EAAW,GAA2D;CAC7E,IAAIC,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMgB,IAAKhB,EAAM,UAAU;EAG3B,IAAIA,EAAM,aAAa,CAACA,EAAM,UAAUgB,CAAE,GAAG,OAAO;EACpD,IAAMf,IAAID,EAAM,SAASgB,CAAE;EAC3B,OAAOf,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CAIA,IAAID,EAAM,eAAeA,EAAM,aAAa;EAC1C,IAAIA,EAAM,WACH;QAAA,IAAMgB,KAAMhB,EAAM,WACrB,IAAI,CAACA,EAAM,UAAUgB,CAAE,GAAG,OAAO;EAAA;EAGrC,OAAO;GAAE,IAAIC;GAAwB,QAAQjB,EAAM;EAAY;CACjE;CACA,OAAO;AACT"}
+{"version":3,"file":"rotationHandle.js","names":[],"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 { localToWorld, transformOf } from './hitAffordanceRegions';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport { rotateCursorAt } from './rotateCursor';\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   *  square to the line from the pivot to the pointer, falling back to\n   *  `'grab'` if the browser rejects the 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 * 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      const pivot = localToWorld(transformOf(state, target.id), b.x + halfW, b.y + halfH);\n      const regionCursor: AffordanceRegion['cursor'] = cursor\n        ?? ((at, view) => rotateCursorAt(pivot, at, view.scale));\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":";;;;;;AA8CA,IAAM,iBAAiB,UACrB,UAAU,SAAS,YAAY,SAAS,aAAa;AAEvD,IAAM,gBAAkC;CACtC,MAAM,EAAE,OAAO;EAAE,MAAM;EAAS,OAAO;CAAyB,EAAE;CAClE,SAAS;AACX;;;;;;;;;;AAWA,SAAgB,yBACd,OAAkC,CAAC,GACvB;CACZ,MAAM,EAAE,SAAS,IAAI,QAAQ,eAAe,QAAQ,WAAW;CAI/D,MAAM,sBAEY;EACd,IAAI,CAAC,OAAO,OAAO;EACnB,IAAI,CAAC,cAAc,KAAK,GACtB,OAAO;GAAE,MAAM;GAAoB,QAAQ;EAAM;EAEnD,OAAO;GACL,MAAM;GACN,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,KAAK,IAAI,CAAC;GACzC,GAAI,MAAM,SAAS,EAAE,QAAQ,MAAM,OAAO,IAAI,CAAC;GAC/C,GAAI,MAAM,YAAY,SAAY,EAAE,SAAS,MAAM,QAAQ,IAAI,CAAC;EAClE;CACF,EAAA,CAAG;CAEL,OAAO;EACL,IAAI;EACJ,QAAQ,OAAiD;GACvD,MAAM,SAAS,WAAW,KAAK;GAC/B,IAAI,CAAC,QAAQ,OAAO,CAAC;GACrB,MAAM,IAAI,OAAO;GAKjB,MAAM,QAAQ,EAAE,QAAQ;GACxB,MAAM,QAAQ,EAAE,SAAS;GAEzB,MAAM,QAAQ,aAAa,YAAY,OAAO,OAAO,EAAE,GAAG,EAAE,IAAI,OAAO,EAAE,IAAI,KAAK;GAClF,MAAM,eAA2C,YAC1C,IAAI,SAAS,eAAe,OAAO,IAAI,KAAK,KAAK;GACxD,MAAM,cAAiC,EACrC,gBAAgB;IACd,UAAU,OAAO;IAGjB,YAAY;KAAE,GAAG,EAAE,IAAI;KAAO,GAAG,EAAE,IAAI;IAAM;GAC/C,EACF;GAEA,MAAM,SAA2B;IAC/B,IAAI;IACJ,UAAU,OAAO;IACjB,OAAO;KACL,MAAM;KACN,IAAI,EAAE,IAAI;KACV,IAAI,EAAE,IAAI;KACV,IAAI,QAAQ,KAAK;KACjB,IAAI,QAAQ,KAAK;KACjB,QAAQ,EAAE;KACV,QAAQ,EAAE;KACV,YAAY,EAAE;KACd,aAAa,EAAE;KACf,WAAW;IACb;IACA,GAAI,eAAe,EAAE,OAAO,aAAa,IAAI,CAAC;IAC9C,SAAS;IACT,QAAQ;IACR;GACF;GACA,IAAI,CAAC,QAAQ,OAAO,CAAC,MAAM;GAe3B,OAAO,CAAC,QAAQ;IAbd,IAAI;IACJ,UAAU,OAAO;IACjB,OAAO;KACL,MAAM;KACN,GAAG,EAAE,IAAI;KACT,GAAG,EAAE;KACL,aAAa,OAAO;KACpB,UAAU;MAAE,IAAI,OAAO;MAAY,QAAQ;OAAE,GAAG;OAAG,GAAG;MAAG;KAAE;IAC7D;IACA,SAAS;IACT,QAAQ;IACR;GAEc,CAAK;EACvB;CACF;AACF;AAEA,SAAS,WAAW,OAA2D;CAC7E,IAAI,MAAM,UAAU,WAAW,GAAG;EAChC,MAAM,KAAK,MAAM,UAAU;EAG3B,IAAI,MAAM,aAAa,CAAC,MAAM,UAAU,EAAE,GAAG,OAAO;EACpD,MAAM,IAAI,MAAM,SAAS,EAAE;EAC3B,OAAO,IAAI;GAAE;GAAI,QAAQ;EAAE,IAAI;CACjC;CAIA,IAAI,MAAM,eAAe,MAAM,aAAa;EAC1C,IAAI,MAAM,WACR;QAAK,MAAM,MAAM,MAAM,WACrB,IAAI,CAAC,MAAM,UAAU,EAAE,GAAG,OAAO;EACnC;EAEF,OAAO;GAAE,IAAI;GAAwB,QAAQ,MAAM;EAAY;CACjE;CACA,OAAO;AACT"}