@weasel-js/core 1.6.1 → 1.7.1

package/README.md

@@ -28,12 +28,30 @@ npm install @weasel-js/core react
 
 `useScene` holds the scene: a tree of leaf and container nodes, each carrying your data and a pose. Every change to it is an **op**, which is what makes it undoable. `<SceneCanvas>` renders a scene and routes input to it.
 
+A bare `<SceneCanvas>` only renders. It keeps a selection that nothing sets from input, and it routes any bindings you add, but it has no tools, no standard actions, no keys and no selection chrome. Behavior comes from presets named in `features`, each independent of the others:
+
+| Preset | Turns on |
+|---|---|
+| `view` | wheel pan and zoom, pinch, the zoom keys, the hand tool (H, or hold Space). Passing `viewport` implies it. |
+| `pick` | the select tool, active from the start: click to pick, drag on empty to marquee, click on empty to clear; the selection outline |
+| `move` | drag a body to move it, Alt-drag to clone — under any tool that leaves the drag unclaimed |
+| `transform` | resize and rotation handles |
+| `edit` | undo/redo, delete, duplicate, group/ungroup, nudge, select-all, Escape, cut/copy/paste, fill and stroke, and their keys |
+| `arrange` | align, distribute, reorder, flip |
+| `paths` | pathfinder operations, path editing and anchor editing |
+| `ingest` | dropped and pasted content |
+| `draw` | all of the above |
+
+`defaultTools` adds built-in tools on top, and each brings the actions it binds: `defaultTools={['rect']}` brings `insert`.
+
 Interactions are **actions** — descriptors registered into an actions registry — reached by **gesture bindings**. A tool is a list of `{ spec, actionId }` pairs and nothing more; the kit's own select, shape and viewport tools are built that way.
 
 ```tsx
-import { SceneCanvas, useScene, useSelection, gridSnapStrategy, type RectPose } from '@weasel-js/core';
+import { SceneCanvas, BUILTIN_TOOL_IDS, useScene, useSelection, type RectPose } from '@weasel-js/core';
+import { createGridLayer, gridSnapStrategy } from '@weasel-js/guides';
 
 const W = 800, H = 600;
+const grid = createGridLayer({ spacing: 20, bounds: () => ({ x: 0, y: 0, width: W, height: H }) });
 
 export function Editor() {
   const scene = useScene({ systemLayers: [{ id: 'default' }], initial: [] });
@@ -48,12 +66,10 @@ export function Editor() {
       height={H}
       scene={scene}
       selection={selection}
-      selectionMode="multi"
-      toolBundle="exhaustive"
+      features={['draw']}
+      defaultTools={BUILTIN_TOOL_IDS}
       selectTool={{ snap: gridSnapStrategy<RectPose>(20) }}
-      layers={{
-        grid: { spacing: 20, bounds: () => ({ x: 0, y: 0, width: W, height: H }) },
-      }}
+      layers={{ grid: { layer: grid } }}
     />
   );
 }
@@ -71,7 +87,7 @@ Lower-level surfaces take a narrow **adapter** instead of a scene — a few meth
 
 An `Action` is a named operation — `delete`, `duplicate`, `group`, `insert`, `viewport.dragPan` — paired with the input that triggers it. `<ActionsProvider>` holds the registered descriptors, and the gesture dispatcher matches live input against each one's `defaultBinding` and the active tool's bindings. Keystrokes and pointer gestures take the same path, so a keyboard shortcut and a drag are two bindings on one action rather than two mechanisms.
 
-`<SceneCanvas>` mounts a provider when none is above it and registers the kit-standard actions: escape, select-all, delete, duplicate, group and ungroup, undo and redo, flip, nudge, reorder, align, distribute, the pathfinder booleans, path-anchor editing, fill and stroke, clipboard, and the pointer-driven move, resize, rotate, insert, clone, area-select and lasso.
+`<SceneCanvas>` mounts a provider when none is above it and registers the kit-standard actions its `features` presets name — under `draw`, all of them: escape, select-all, delete, duplicate, group and ungroup, undo and redo, flip, nudge, reorder, align, distribute, the pathfinder booleans, path-anchor editing, fill and stroke, clipboard, and the pointer-driven move, resize, rotate, clone, area-select and lasso. `FEATURE_ACTION_IDS` lists which preset registers which. `insert` comes with the shape tools that bind it.
 
 ```tsx
 <SceneCanvas
@@ -79,6 +95,7 @@ An `Action` is a named operation — `delete`, `duplicate`, `group`, `insert`, `
   height={H}
   scene={scene}
   selection={selection}
+  features={['draw']}
   actions={{
     duplicate: null,                  // drop the default
     'app.publish': {                  // add your own
@@ -95,7 +112,7 @@ An `Action` is a named operation — `delete`, `duplicate`, `group`, `insert`, `
 />
 ```
 
-The `actions` prop takes `null` to unregister every default, or a record keyed by action id. Each value is `null` to drop that one id, a partial `Action` to merge onto the default of the same id, or a complete `Action` to register a new one.
+The `actions` prop applies on top of what the presets registered. It takes `null` to unregister every default, or a record keyed by action id. Each value is `null` to drop that one id, a partial `Action` to merge onto the default of the same id, or a complete `Action` to register a new one.
 
 An action does its work through `invoker`, not a bare callback. `{ timing: 'immediate' }` runs once; `{ timing: 'ongoing' }` returns a handle so a drag can preview while it moves and commit at the end. The deps an invoker reads (`selection`, `scene`, `applyOps`, …) are declared in `requires` and resolved at invocation time, which is what lets a consumer swap one — see `useDepSource`. To fire an action yourself, wrap the canvas in your own `<ActionsProvider>` and call `trigger(id, params)` on the registry `useActionsRegistry()` returns.
 
@@ -148,7 +165,7 @@ Core's main entry carries the everyday surface. A few narrower ones have their o
 | Import | Holds |
 |---|---|
 | `@weasel-js/core/renderer` | the renderer, `registerProgram`, `registerTexture`, draw commands |
-| `@weasel-js/core/move`, `/resize`, `/insert`, `/clone`, `/clipboard` | helpers for building on those actions, e.g. `snapToGrid`, `clampMinSize` |
+| `@weasel-js/core/move`, `/resize`, `/clone`, `/clipboard` | helpers for building on those actions, e.g. `snapBackOrDelete`, `clampMinSize` |
 | `@weasel-js/core/patterns-builtin` | the built-in fill patterns |
 | `@weasel-js/core/routing` | route grammar and introspection: parsing, the route registry, conflict checks |
 
@@ -162,6 +179,7 @@ Every package is published under `@weasel-js` and released together at one versi
 | `geom` | pure 2D geometry — affine, box, curve, polyline; polygon booleans under `./booleans` |
 | `gestures` | the gesture taxonomy, route grammars and matchers; no React, no DOM |
 | `history` | undo/redo with scoped sub-histories; no React, no DOM |
+| `react` | generic React hooks the other packages share: `useLatest`, `useStableByContent` |
 | `paint` | fills, strokes, gradients and dashes as plain data |
 | `text` | styled runs, kerned layout, wrapping and measurement |
 | `bidi` | the Unicode Bidirectional Algorithm (UAX #9) |
@@ -169,6 +187,7 @@ Every package is published under `@weasel-js` and released together at one versi
 | `svg` | SVG import and export |
 | `modes` | app-level modality: capability tags, mode definitions, a mode registry |
 | `diagram` | node-link diagrams: ports on any node's perimeter, flowchart-style bodies |
+| `guides` | placement aids: grids, guide lines, alignment and snapping to them, container layout strategies |
 | `hud` | WebGL-rendered widgets composited into a canvas |
 | `cursor` | tool cursors as authored glyphs, baked to CSS or painted when too large |
 | `loupe` | a magnifier model: where it's aimed, how far it magnifies, what's under it |

package/dist/WeaselProvider.js

@@ -0,0 +1,15 @@
+import { PointerContextProvider as e } from "./features/pointer/PointerContext.js";
+import { SelectionContextProvider as t, SelectionContextProviderIfRoot as n } from "./features/selection/SelectionContext.js";
+import { PointerProviderIfRoot as r } from "./canvas/SceneCanvas/PointerProviderIfRoot.js";
+import { ActionsProviderIfRoot as i } from "./canvas/SceneCanvas/ActionsProviderIfRoot.js";
+import { DepRegistryProviderIfRoot as a } from "./canvas/SceneCanvas/DepRegistryProviderIfRoot.js";
+import { ActionsProvider as o, ActiveToolContextProvider as s, ActiveToolContextProviderIfRoot as c, DepRegistryProvider as l } from "@weasel-js/routing/react";
+import { jsx as u } from "react/jsx-runtime";
+//#region src/WeaselProvider.tsx
+function d({ children: d, isolate: f = !1 }) {
+	return /* @__PURE__ */ u(f ? l : a, { children: /* @__PURE__ */ u(f ? o : i, { children: /* @__PURE__ */ u(f ? s : c, { children: /* @__PURE__ */ u(f ? t : n, { children: /* @__PURE__ */ u(f ? e : r, { children: d }) }) }) }) });
+}
+//#endregion
+export { d as WeaselProvider };
+
+//# sourceMappingURL=WeaselProvider.js.map

package/dist/WeaselProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeaselProvider.js","names":["WeaselProvider","isolate","DepRegistryProvider","DepRegistryProviderIfRoot","ActionsProvider","ActionsProviderIfRoot","ActiveToolContextProvider","ActiveToolContextProviderIfRoot","SelectionContextProvider","SelectionContextProviderIfRoot","PointerContextProvider","PointerProviderIfRoot"],"sources":["../src/WeaselProvider.tsx"],"sourcesContent":["/**\n * `<WeaselProvider>` — top-level convenience that mounts all five kit-root\n * contexts in a single wrap. By default each underlying provider uses its\n * `IfRoot` variant, so `<WeaselProvider>` is safely nestable: when a parent\n * `<WeaselProvider>` (or any of the individual providers) is already in\n * scope, the inner one renders its children unwrapped and defers to the\n * parent registry. `isolate` opts out of that.\n *\n * Use this at the harness / app root above any `useTools(...)` call so the\n * resulting `ToolsApi` is bound to the same `ActiveToolContext` the\n * surrounding `<SceneCanvas>` reads — otherwise keybinding-driven tool\n * switches update local state in the outer `useTools` but the dispatcher\n * (which reads the context) sees a stale active tool.\n *\n * Provider nesting order matches the order `<SceneCanvas>` mounts them\n * internally so swapping a manual SceneCanvas-wrapping setup for\n * `<WeaselProvider>` doesn't change effect ordering.\n */\nimport type { ComponentType, ReactNode } from 'react';\nimport { DepRegistryProviderIfRoot } from './canvas/SceneCanvas/DepRegistryProviderIfRoot';\nimport { ActionsProviderIfRoot } from './canvas/SceneCanvas/ActionsProviderIfRoot';\nimport { PointerProviderIfRoot } from './canvas/SceneCanvas/PointerProviderIfRoot';\nimport { ActiveToolContextProvider, ActiveToolContextProviderIfRoot } from '@weasel-js/routing/react';\nimport {\n  SelectionContextProvider,\n  SelectionContextProviderIfRoot,\n} from './features/selection/SelectionContext';\nimport { DepRegistryProvider } from '@weasel-js/routing/react';\nimport { ActionsProvider } from '@weasel-js/routing/react';\nimport { PointerContextProvider } from './features/pointer/PointerContext';\n\ntype Wrapper = ComponentType<{ children: ReactNode }>;\n\n/** Props for {@link WeaselProvider}. */\nexport interface WeaselProviderProps {\n  children: ReactNode;\n  /**\n   * Mount every provider unconditionally rather than deferring to one already\n   * in scope.\n   *\n   * An actions registry holds one dispatcher, so a second `<SceneCanvas>`\n   * joining a scope displaces the first and takes its input away. Two canvases\n   * on one page each want their own scope; wrap each in an isolated provider.\n   * The cost is that they share nothing — a toolbar outside both can drive\n   * neither.\n   */\n  isolate?: boolean;\n}\n\n/**\n * Mounts every kit-wide provider at once — deps, actions, active tool,\n * selection and pointer — each only if one is not already in scope, or\n * unconditionally under `isolate`.\n *\n * `<SceneCanvas>` does this for itself, so this is for the case where kit\n * state has to be shared by things outside a canvas: a toolbar, a property\n * panel, or two canvases that should agree on the selection.\n */\nexport function WeaselProvider({ children, isolate = false }: WeaselProviderProps) {\n  const Deps: Wrapper = isolate ? DepRegistryProvider : DepRegistryProviderIfRoot;\n  const Actions: Wrapper = isolate ? ActionsProvider : ActionsProviderIfRoot;\n  const ActiveTool: Wrapper = isolate\n    ? ActiveToolContextProvider\n    : ActiveToolContextProviderIfRoot;\n  const Selection: Wrapper = isolate\n    ? SelectionContextProvider\n    : SelectionContextProviderIfRoot;\n  const Pointer: Wrapper = isolate ? PointerContextProvider : PointerProviderIfRoot;\n  return (\n    <Deps>\n      <Actions>\n        <ActiveTool>\n          <Selection>\n            <Pointer>\n              {children}\n            </Pointer>\n          </Selection>\n        </ActiveTool>\n      </Actions>\n    </Deps>\n  );\n}\n"],"mappings":";;;;;;;;AA0DA,SAAgBA,EAAe,EAAE,aAAU,aAAU,MAA8B;CAUjF,OACE,kBAVoBC,IAAUC,IAAsBC,GAUpD,EAAA,UACE,kBAVqBF,IAAUG,IAAkBC,GAUjD,EAAA,UACE,kBAVsBJ,IACxBK,IACAC,GAQE,EAAA,UACE,kBARmBN,IACvBO,IACAC,GAMI,EAAA,UACE,kBANeR,IAAUS,IAAyBC,GAMlD,EACG,YACM,CAAA,EACA,CAAA,EACD,CAAA,EACL,CAAA,EACL,CAAA;AAEV"}

package/dist/affordances/composeAffordanceLayer.js

@@ -0,0 +1,224 @@
+import { viewToTransform as e } from "../core/viewport/view.js";
+import { worldToScreen as t } from "../core/viewport/viewTransform.js";
+import { pxExtent as n } from "../core/viewport/pxExtent.js";
+import { angleOf as r, annulusSemiAxes as i, hitAffordanceRegions as a, localToWorld as o, pointRegionAnchor as s, pointRegionFrame as c, pointRegionScreenQuad as l, transformOf as u } from "./hitAffordanceRegions.js";
+import { PATH_L as d, PATH_M as f, PATH_Z as p } from "@weasel-js/geom";
+//#region src/affordances/composeAffordanceLayer.ts
+function m(t, n, r) {
+	return {
+		id: t,
+		label: n,
+		space: "screen",
+		draw: (t, n, i) => {
+			let a = h(t), o = g(t), s = _(t), c = [], l = e(n);
+			for (let e of r) if (!s || s(e.id)) {
+				for (let t of e.regions(a)) {
+					let r = u(a, t.targetId);
+					t.paint && y(t, r, n, a, l, c), o && v(o, e.id, t, r, n);
+				}
+				if (e.decorate) for (let t of e.decorate(a, n)) c.push(t);
+			}
+			return c;
+		},
+		hitTest: (e, t, n, i, o, s) => {
+			let c = h(n);
+			if (!c) return null;
+			let l = a(r, e, t, c, i, s ?? _(n) ?? void 0);
+			if (!l) return null;
+			let { cursor: u, strength: d, claimedKinds: f } = l.region;
+			return {
+				...l.binding,
+				...u === void 0 ? {} : { cursor: u },
+				...d === void 0 ? {} : { strength: d },
+				...f === void 0 ? {} : { claimedKinds: f }
+			};
+		}
+	};
+}
+function h(e) {
+	let t = e;
+	return typeof t?.getChromeState == "function" ? t.getChromeState() : e;
+}
+function g(e) {
+	let t = e;
+	return typeof t?.getDebug == "function" ? t.getDebug() : null;
+}
+function _(e) {
+	let t = e;
+	return typeof t?.getIsVisible == "function" ? t.getIsVisible() : null;
+}
+function v(e, t, n, a, s) {
+	if (n.shape.kind === "point") {
+		let r = c(n.shape, a, s), i = l(n.shape, a, s, (e, t) => [e, t]);
+		e.recordHitbox(t, "handle", {
+			kind: "polygon",
+			points: i.map((e) => ({
+				x: r.x + (e.x - r.x) / s.scale.x,
+				y: r.y + (e.y - r.y) / s.scale.y
+			}))
+		});
+		return;
+	}
+	if (n.shape.kind === "annulus") {
+		let c = n.shape, { rx: l, ry: u } = i(c, s, r(a)), d = [
+			o(a, c.cx + l, c.cy),
+			o(a, c.cx - l, c.cy),
+			o(a, c.cx, c.cy + u),
+			o(a, c.cx, c.cy - u)
+		], f = Math.min(...d.map((e) => e.x)), p = Math.min(...d.map((e) => e.y)), m = Math.max(...d.map((e) => e.x)), h = Math.max(...d.map((e) => e.y));
+		e.recordHitbox(t, "handle", {
+			kind: "rect",
+			x: f,
+			y: p,
+			width: m - f,
+			height: h - p,
+			...a.identity ? {} : { rotation: Math.atan2(a.sin, a.cos) }
+		});
+		return;
+	}
+	let u = n.shape, d = o(a, u.x + u.width / 2, u.y + u.height / 2);
+	e.recordHitbox(t, "handle", {
+		kind: "rect",
+		x: d.x - u.width / 2,
+		y: d.y - u.height / 2,
+		width: u.width,
+		height: u.height,
+		...a.identity ? {} : { rotation: Math.atan2(a.sin, a.cos) }
+	});
+}
+function y(e, a, o, s, l, u) {
+	let m = e.paint;
+	if (m.kind === "square") {
+		if (e.shape.kind !== "point") return;
+		let n = c(e.shape, a, o), [r, i] = t(n.x, n.y, l), s = m.sizePx / 2, h = m.fill ? { fill: m.fill } : {}, g = m.stroke ? { stroke: m.stroke } : {};
+		if (n.angle === 0) {
+			u.push({
+				kind: "path",
+				path: {
+					kind: "rect",
+					x: r - s,
+					y: i - s,
+					width: m.sizePx,
+					height: m.sizePx
+				},
+				...h,
+				...g
+			});
+			return;
+		}
+		let _ = Math.cos(n.angle) * s, v = Math.sin(n.angle) * s, y = /* @__PURE__ */ new Float32Array(8);
+		[
+			[-1, -1],
+			[1, -1],
+			[1, 1],
+			[-1, 1]
+		].forEach(([e, t], n) => {
+			y[n * 2] = r + _ * e - v * t, y[n * 2 + 1] = i + v * e + _ * t;
+		}), u.push({
+			kind: "path",
+			path: {
+				kind: "polygon",
+				commands: new Uint8Array([
+					f,
+					d,
+					d,
+					d,
+					p
+				]),
+				coords: y,
+				fillRule: "nonzero"
+			},
+			...h,
+			...g
+		});
+		return;
+	}
+	if (m.kind === "annulus") {
+		if (e.shape.kind !== "annulus") return;
+		let t = e.shape, s = n(m.insetPx ?? 0, o.scale, r(a)), c = b(t, i(t, o, r(a)), s, a, l, m.fill, m.stroke);
+		c && u.push(c);
+		return;
+	}
+	if (m.kind === "custom") {
+		let t = {
+			world: x(e, a, o),
+			local: e.shape,
+			view: o,
+			state: s
+		};
+		for (let e of m.draw(t)) u.push(e);
+		return;
+	}
+}
+function b(e, n, r, i, a, s, c) {
+	let l = n.rx - r.x, u = n.ry - r.y;
+	if (l <= 0 || u <= 0) return null;
+	let m = e.cx, h = e.cy, g = e.innerWidth / 2 + r.x, _ = e.innerHeight / 2 + r.y, v = _ < u, y = g < l;
+	if (!v && !y) return null;
+	let b = v ? l * Math.sqrt(1 - (_ / u) ** 2) : 0, x = y ? u * Math.sqrt(1 - (g / l) ** 2) : 0, S = [], C = [];
+	function w(e, t) {
+		S.push(f), C.push({
+			x: m + l * Math.cos(e),
+			y: h + u * Math.sin(e)
+		});
+		for (let n = 1; n <= 24; n++) {
+			let r = e + (t - e) * (n / 24);
+			S.push(d), C.push({
+				x: m + l * Math.cos(r),
+				y: h + u * Math.sin(r)
+			});
+		}
+		S.push(p);
+	}
+	v && (w(Math.atan2(-_ / u, b / l), Math.atan2(-_ / u, -b / l)), w(Math.atan2(_ / u, b / l), Math.atan2(_ / u, -b / l))), y && (w(Math.atan2(-x / u, g / l), Math.atan2(x / u, g / l)), w(Math.atan2(-x / u, -g / l), Math.atan2(x / u, -g / l) - 2 * Math.PI));
+	let T = new Float32Array(C.length * 2);
+	for (let e = 0; e < C.length; e++) {
+		let n = o(i, C[e].x, C[e].y), [r, s] = t(n.x, n.y, a);
+		T[e * 2] = r, T[e * 2 + 1] = s;
+	}
+	return {
+		kind: "path",
+		path: {
+			kind: "polygon",
+			commands: new Uint8Array(S),
+			coords: T,
+			fillRule: "nonzero"
+		},
+		...s ? { fill: s } : {},
+		...c ? { stroke: c } : {}
+	};
+}
+function x(e, t, n) {
+	if (e.shape.kind === "point") {
+		let r = s(e.shape, t, n);
+		return {
+			x: r.x,
+			y: r.y
+		};
+	}
+	if (e.shape.kind === "annulus") {
+		let a = e.shape, { rx: s, ry: c } = i(a, n, r(t)), l = [
+			o(t, a.cx + s, a.cy),
+			o(t, a.cx - s, a.cy),
+			o(t, a.cx, a.cy + c),
+			o(t, a.cx, a.cy - c)
+		], u = Math.min(...l.map((e) => e.x)), d = Math.min(...l.map((e) => e.y)), f = Math.max(...l.map((e) => e.x)), p = Math.max(...l.map((e) => e.y));
+		return {
+			x: u,
+			y: d,
+			width: f - u,
+			height: p - d
+		};
+	}
+	let a = e.shape, c = o(t, a.x, a.y), l = o(t, a.x + a.width, a.y), u = o(t, a.x, a.y + a.height), d = o(t, a.x + a.width, a.y + a.height), f = Math.min(c.x, l.x, u.x, d.x), p = Math.min(c.y, l.y, u.y, d.y), m = Math.max(c.x, l.x, u.x, d.x), h = Math.max(c.y, l.y, u.y, d.y);
+	return {
+		x: f,
+		y: p,
+		width: m - f,
+		height: h - p
+	};
+}
+//#endregion
+export { m as composeAffordanceLayer };
+
+//# sourceMappingURL=composeAffordanceLayer.js.map

package/dist/affordances/composeAffordanceLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeAffordanceLayer.js","names":["composeAffordanceLayer","state","asChromeState","data","debug","asDebugSink","isVisible","asIsVisible","out","t","viewToTransform","view","a","affordances","region","xf","transformOf","paintRegion","recordRegionHitbox","cmd","hit","hitAffordanceRegions","wx","wy","cursor","strength","claimedKinds","maybe","f","pointRegionFrame","quad","pointRegionScreenQuad","x","y","affordanceId","q","s","annulusSemiAxes","angleOf","pts","localToWorld","rx","ry","minX","p","minY","maxX","maxY","r","w","paint","sx","sy","worldToScreen","viewT","half","fill","stroke","c","sn","coords","u","v","i","PATH_M","PATH_L","PATH_Z","insetLocal","pxExtent","annulusCommand","ctx","worldOf","semiAxes","cx","shape","cy","rectHW","rectHH","haveTopBottom","haveLeftRight","xT","yR","cmds","localPts","appendPetal","t0","t1","pointRegionAnchor","b"],"sources":["../../src/affordances/composeAffordanceLayer.ts"],"sourcesContent":["import type { RenderLayer } from 'core/layers/render';\nimport type { DrawCommand } from '../renderer';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { pxExtent } from 'core/viewport/pxExtent';\nimport type { DebugSink } from '../debug/types';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport { PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';\nimport {\n  angleOf,\n  annulusSemiAxes,\n  hitAffordanceRegions,\n  localToWorld,\n  pointRegionAnchor,\n  pointRegionFrame,\n  pointRegionScreenQuad,\n  transformOf,\n  type TargetTransform,\n} from './hitAffordanceRegions';\nimport type {\n  Affordance,\n  AffordanceRegion,\n  CustomPaintContext,\n  LayerHit,\n} from './types';\n\n/**\n * @experimental\n * Bundle a list of Affordances into a single RenderLayer.\n *\n * Each affordance declares interactive regions in target-local coordinates;\n * this layer composes each target's bounds transform (rotation around the\n * AABB center, when present) once per region for both paint and hit-test.\n *\n * FillStyle order matches array order (first → last = bottom → top). Hit-test\n * walks regions in reverse (top → bottom) and returns the first non-null\n * binding.\n *\n * `decorate(state, view)` runs *after* a given affordance's regions for\n * paint only — useful for leader lines and other purely-visual chrome that\n * don't fit the region model.\n */\nexport function composeAffordanceLayer(\n  id: string,\n  label: string,\n  affordances: readonly Affordance[],\n): RenderLayer<ChromeState> & {\n  hitTest(\n    wx: number,\n    wy: number,\n    state: unknown,\n    view: View,\n    dims: { width: number; height: number },\n    isVisible?: (id: string) => boolean,\n  ): LayerHit | null;\n} {\n  return {\n    id,\n    label,\n    space: 'screen',\n    draw: (data, view, _dims): DrawCommand[] => {\n      const state = asChromeState(data);\n      const debug = asDebugSink(data);\n      const isVisible = asIsVisible(data);\n      const out: DrawCommand[] = [];\n      const t = viewToTransform(view);\n      for (const a of affordances) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(state)) {\n          const xf = transformOf(state, region.targetId);\n          if (region.paint) paintRegion(region, xf, view, state, t, out);\n          if (debug) recordRegionHitbox(debug, a.id, region, xf, view);\n        }\n        if (a.decorate) {\n          for (const cmd of a.decorate(state, view)) out.push(cmd);\n        }\n      }\n      return out;\n    },\n    // The walk itself lives in `hitAffordanceRegions` so this layer and\n    // `buildAffordanceAt` share one implementation rather than two that can\n    // drift. This wrapper lifts the region's declared cursor and claim onto\n    // the binding, the way `buildAffordanceAt` lifts them onto `AffordanceHit`.\n    hitTest: (wx, wy, data, view, _dims, isVisible): LayerHit | null => {\n      const state = asChromeState(data);\n      if (!state) return null;\n      const hit = hitAffordanceRegions(\n        affordances, wx, wy, state, view, isVisible ?? asIsVisible(data) ?? undefined,\n      );\n      if (!hit) return null;\n      const { cursor, strength, claimedKinds } = hit.region;\n      return {\n        ...hit.binding,\n        ...(cursor !== undefined ? { cursor } : {}),\n        ...(strength !== undefined ? { strength } : {}),\n        ...(claimedKinds !== undefined ? { claimedKinds } : {}),\n      };\n    },\n  };\n}\n\n// ─── Data unwrappers ────────────────────────────────────────────────────────\n\n// `draw` is called by Canvas with `CanvasHelpers` and by tests with a bare\n// `ChromeState`. Tests stay terse this way, and production gets the live\n// debug sink via the same channel.\nfunction asChromeState(data: unknown): ChromeState {\n  const maybe = data as { getChromeState?: () => ChromeState };\n  if (typeof maybe?.getChromeState === 'function') return maybe.getChromeState();\n  return data as ChromeState;\n}\n\nfunction asDebugSink(data: unknown): DebugSink | null {\n  const maybe = data as { getDebug?: () => DebugSink | null };\n  if (typeof maybe?.getDebug === 'function') return maybe.getDebug();\n  return null;\n}\n\n/** Pull a chrome-caps visibility predicate off the data envelope when\n *  present. When absent (legacy callers / tests passing bare state),\n *  every affordance renders — preserves pre-chrome-caps behavior. */\nfunction asIsVisible(data: unknown): ((id: string) => boolean) | null {\n  const maybe = data as { getIsVisible?: () => (id: string) => boolean };\n  if (typeof maybe?.getIsVisible === 'function') return maybe.getIsVisible();\n  return null;\n}\n\nfunction recordRegionHitbox(\n  debug: DebugSink,\n  affordanceId: string,\n  region: AffordanceRegion,\n  xf: TargetTransform,\n  view: View,\n): void {\n  if (region.shape.kind === 'point') {\n    // The hit square is a square on *screen* — turned with the target when the\n    // region asks — so in world it is a parallelogram, recorded as one.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const quad = pointRegionScreenQuad(region.shape, xf, view, (x, y) => [x, y]);\n    debug.recordHitbox(affordanceId, 'handle', {\n      kind: 'polygon',\n      points: quad.map((q) => ({\n        x: f.x + (q.x - f.x) / view.scale.x,\n        y: f.y + (q.y - f.y) / view.scale.y,\n      })),\n    });\n    return;\n  }\n  if (region.shape.kind === 'annulus') {\n    // Approximate the annulus visualization as the outer ellipse's AABB.\n    // The DebugSink's hitbox primitives don't model ring shapes; the\n    // always-visible dev paint (`paint.kind === 'annulus'`) draws the\n    // actual ring. Consumers that want a precise debug overlay can match\n    // against the affordance id and render the annulus themselves.\n    const s = region.shape;\n    const { rx, ry } = annulusSemiAxes(s, view, angleOf(xf));\n    const pts = [\n      localToWorld(xf, s.cx + rx, s.cy),\n      localToWorld(xf, s.cx - rx, s.cy),\n      localToWorld(xf, s.cx, s.cy + ry),\n      localToWorld(xf, s.cx, s.cy - ry),\n    ];\n    const minX = Math.min(...pts.map((p) => p.x));\n    const minY = Math.min(...pts.map((p) => p.y));\n    const maxX = Math.max(...pts.map((p) => p.x));\n    const maxY = Math.max(...pts.map((p) => p.y));\n    debug.recordHitbox(affordanceId, 'handle', {\n      kind: 'rect',\n      x: minX,\n      y: minY,\n      width: maxX - minX,\n      height: maxY - minY,\n      ...(xf.identity ? {} : { rotation: Math.atan2(xf.sin, xf.cos) }),\n    });\n    return;\n  }\n  // rect: axis-aligned in local frame; apply target rotation around the\n  // AABB pivot when present.\n  const r = region.shape;\n  const w = localToWorld(xf, r.x + r.width / 2, r.y + r.height / 2);\n  debug.recordHitbox(affordanceId, 'handle', {\n    kind: 'rect',\n    x: w.x - r.width / 2,\n    y: w.y - r.height / 2,\n    width: r.width,\n    height: r.height,\n    ...(xf.identity ? {} : { rotation: Math.atan2(xf.sin, xf.cos) }),\n  });\n}\n\n// ─── FillStyle ──────────────────────────────────────────────────────────────────\n\nfunction paintRegion(\n  region: AffordanceRegion,\n  xf: TargetTransform,\n  view: View,\n  state: ChromeState,\n  viewT: ReturnType<typeof viewToTransform>,\n  out: DrawCommand[],\n): void {\n  const paint = region.paint!;\n  if (paint.kind === 'square') {\n    if (region.shape.kind !== 'point') {\n      // 'square' only makes sense over a point shape. Silently skip — a\n      // future paint variant can cover rect outlines.\n      return;\n    }\n    // Same frame the hit-test reads, at the paint's own size.\n    const f = pointRegionFrame(region.shape, xf, view);\n    const [sx, sy] = worldToScreen(f.x, f.y, viewT);\n    const half = paint.sizePx / 2;\n    const fill = paint.fill ? { fill: paint.fill } : {};\n    const stroke = paint.stroke ? { stroke: paint.stroke } : {};\n    if (f.angle === 0) {\n      out.push({\n        kind: 'path',\n        path: { kind: 'rect', x: sx - half, y: sy - half, width: paint.sizePx, height: paint.sizePx },\n        ...fill, ...stroke,\n      });\n      return;\n    }\n    const c = Math.cos(f.angle) * half, sn = Math.sin(f.angle) * half;\n    const coords = new Float32Array(8);\n    [[-1, -1], [1, -1], [1, 1], [-1, 1]].forEach(([u, v], i) => {\n      coords[i * 2] = sx + c * u - sn * v;\n      coords[i * 2 + 1] = sy + sn * u + c * v;\n    });\n    out.push({\n      kind: 'path',\n      path: { kind: 'polygon', commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]), coords, fillRule: 'nonzero' },\n      ...fill, ...stroke,\n    });\n    return;\n  }\n  if (paint.kind === 'annulus') {\n    if (region.shape.kind !== 'annulus') return; // type mismatch — silent skip\n    const s = region.shape;\n    // Convert the screen-px inset to target-local units so it visually\n    // matches at any zoom. `localToWorld` is rotation+translation (no\n    // scale), so target-local units equal world units for ring math.\n    const insetLocal = pxExtent(paint.insetPx ?? 0, view.scale, angleOf(xf));\n    // Same `minBandPx` clamp the hit-test applies, so the ring you can see is\n    // the ring you can grab.\n    const cmd = annulusCommand(s, annulusSemiAxes(s, view, angleOf(xf)), insetLocal, xf, viewT, paint.fill, paint.stroke);\n    if (cmd) out.push(cmd);\n    return;\n  }\n  if (paint.kind === 'custom') {\n    const ctx: CustomPaintContext = {\n      world: worldOf(region, xf, view),\n      local: region.shape,\n      view,\n      state,\n    };\n    for (const cmd of paint.draw(ctx)) out.push(cmd);\n    return;\n  }\n}\n\n/** Build a screen-space DrawCommand for an annulus region: the area\n *  inside the (contracted) outer ellipse but outside the (expanded)\n *  inner rect. Renders as four disjoint petal subpaths — one per rect\n *  edge — so the visible fill is true `ellipse \\ rect`. A naive\n *  ellipse + rect even-odd path would also fill the rect's corner\n *  triangles where they poke past the contracted ellipse. Returns null\n *  when the band collapses on both axes. */\nfunction annulusCommand(\n  shape: Extract<AffordanceRegion['shape'], { kind: 'annulus' }>,\n  semiAxes: { rx: number; ry: number },\n  insetLocal: { x: number; y: number },\n  xf: TargetTransform,\n  viewT: ReturnType<typeof viewToTransform>,\n  fill: FillStyle | undefined,\n  stroke: Stroke | undefined,\n): DrawCommand | null {\n  const rx = semiAxes.rx - insetLocal.x;\n  const ry = semiAxes.ry - insetLocal.y;\n  if (rx <= 0 || ry <= 0) return null;\n  const cx = shape.cx;\n  const cy = shape.cy;\n  // Expanded inner rect (still in target-local coords).\n  const rectHW = shape.innerWidth / 2 + insetLocal.x;\n  const rectHH = shape.innerHeight / 2 + insetLocal.y;\n  // Each petal exists only when the corresponding rect edge actually\n  // intersects the ellipse interior — otherwise the rect already\n  // extends past the ellipse on that axis and there's no band to show.\n  const haveTopBottom = rectHH < ry;\n  const haveLeftRight = rectHW < rx;\n  if (!haveTopBottom && !haveLeftRight) return null;\n  const xT = haveTopBottom ? rx * Math.sqrt(1 - (rectHH / ry) ** 2) : 0;\n  const yR = haveLeftRight ? ry * Math.sqrt(1 - (rectHW / rx) ** 2) : 0;\n\n  // Sampling density per petal arc — line segments are visually clean\n  // for the rotate-band band thickness and avoid the cubic-Bézier\n  // sub-arc bookkeeping. 24 is smooth at typical zooms.\n  const SAMPLES = 24;\n  const cmds: number[] = [];\n  const localPts: { x: number; y: number }[] = [];\n\n  function appendPetal(t0: number, t1: number): void {\n    cmds.push(PATH_M);\n    localPts.push({ x: cx + rx * Math.cos(t0), y: cy + ry * Math.sin(t0) });\n    for (let i = 1; i <= SAMPLES; i++) {\n      const t = t0 + (t1 - t0) * (i / SAMPLES);\n      cmds.push(PATH_L);\n      localPts.push({ x: cx + rx * Math.cos(t), y: cy + ry * Math.sin(t) });\n    }\n    // PATH_Z closes back to the move-to point along the rect edge — both\n    // endpoints share the rect-edge coord by construction, so the\n    // closing segment IS the chord.\n    cmds.push(PATH_Z);\n  }\n\n  if (haveTopBottom) {\n    // Top petal: y < cy. Arc from right endpoint over t = -π/2 to left.\n    appendPetal(\n      Math.atan2(-rectHH / ry, xT / rx),   // in (-π/2, 0)\n      Math.atan2(-rectHH / ry, -xT / rx),  // in (-π, -π/2), decreasing through -π/2\n    );\n    // Bottom petal: y > cy. Arc through t = +π/2.\n    appendPetal(\n      Math.atan2(rectHH / ry, xT / rx),    // in (0, π/2)\n      Math.atan2(rectHH / ry, -xT / rx),   // in (π/2, π), increasing through π/2\n    );\n  }\n  if (haveLeftRight) {\n    // Right petal: x > cx. Arc through t = 0.\n    appendPetal(\n      Math.atan2(-yR / ry, rectHW / rx),   // in (-π/2, 0)\n      Math.atan2(yR / ry, rectHW / rx),    // in (0, π/2)\n    );\n    // Left petal: x < cx. Arc through t = ±π. Shift the end angle by\n    // -2π so the parametric trace passes through the leftmost point\n    // monotonically instead of crossing the right side.\n    appendPetal(\n      Math.atan2(-yR / ry, -rectHW / rx),                  // in (-π, -π/2)\n      Math.atan2(yR / ry, -rectHW / rx) - 2 * Math.PI,     // in (-3π/2, -π), decreasing through -π\n    );\n  }\n\n  const coords = new Float32Array(localPts.length * 2);\n  for (let i = 0; i < localPts.length; i++) {\n    const w = localToWorld(xf, localPts[i].x, localPts[i].y);\n    const [sx, sy] = worldToScreen(w.x, w.y, viewT);\n    coords[i * 2] = sx;\n    coords[i * 2 + 1] = sy;\n  }\n  return {\n    kind: 'path',\n    path: { kind: 'polygon', commands: new Uint8Array(cmds), coords, fillRule: 'nonzero' },\n    ...(fill ? { fill } : {}),\n    ...(stroke ? { stroke } : {}),\n  };\n}\n\nfunction worldOf(region: AffordanceRegion, xf: TargetTransform, view: View): CustomPaintContext['world'] {\n  if (region.shape.kind === 'point') {\n    const w = pointRegionAnchor(region.shape, xf, view);\n    return { x: w.x, y: w.y };\n  }\n  if (region.shape.kind === 'annulus') {\n    // Outer ellipse bounding box, in world coords. Map the four cardinal\n    // extrema through the target transform and AABB the result. (Rotated\n    // ellipses are still ellipses; their AABB needs all four points.)\n    const s = region.shape;\n    const { rx, ry } = annulusSemiAxes(s, view, angleOf(xf));\n    const pts = [\n      localToWorld(xf, s.cx + rx, s.cy),\n      localToWorld(xf, s.cx - rx, s.cy),\n      localToWorld(xf, s.cx, s.cy + ry),\n      localToWorld(xf, s.cx, s.cy - ry),\n    ];\n    const minX = Math.min(...pts.map((p) => p.x));\n    const minY = Math.min(...pts.map((p) => p.y));\n    const maxX = Math.max(...pts.map((p) => p.x));\n    const maxY = Math.max(...pts.map((p) => p.y));\n    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n  }\n  // Rect: map the rect's origin and far corner; width/height under rotation\n  // describe the AABB of the rotated rect, which is what custom-paint\n  // consumers most often want. Affordances needing exact rotated geometry\n  // can read `local` + reapply rotation themselves via `view`/`state`.\n  const r = region.shape;\n  const a = localToWorld(xf, r.x, r.y);\n  const b = localToWorld(xf, r.x + r.width, r.y);\n  const c = localToWorld(xf, r.x, r.y + r.height);\n  const d = localToWorld(xf, r.x + r.width, r.y + r.height);\n  const minX = Math.min(a.x, b.x, c.x, d.x);\n  const minY = Math.min(a.y, b.y, c.y, d.y);\n  const maxX = Math.max(a.x, b.x, c.x, d.x);\n  const maxY = Math.max(a.y, b.y, c.y, d.y);\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n// Hit-testing lives in `hitAffordanceRegions.ts` — see `hitRegion` there.\n"],"mappings":"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"}

package/dist/affordances/cornerResize.js

@@ -0,0 +1,69 @@
+import { HANDLE_BASE_PX as e } from "../core/device/targets.js";
+import { CORNER_ANCHORS as t, cornerPoint as n, fixedCornerOf as r } from "../interactions/actions/resize/cornerHandles.js";
+import { MULTI_RESIZE_TARGET_ID as i } from "../core/selection/selectionTarget.js";
+import { angleOf as a, localToWorld as o, transformOf as s } from "./hitAffordanceRegions.js";
+//#region src/affordances/cornerResize.ts
+var c = "#d4c4a8", l = "#1a130d";
+function u(i = {}) {
+	let { handleHitRadius: u = e, handleSize: f = e, fill: p = c, stroke: m = l } = i, h = {
+		kind: "square",
+		sizePx: f,
+		fill: { color: p },
+		stroke: {
+			paint: { color: m },
+			width: 1
+		}
+	};
+	return {
+		id: "selection.resize-handles",
+		regions(e) {
+			let i = d(e);
+			if (!i) return [];
+			let c = i.bounds, l = s(e, i.id);
+			return t.map((e) => {
+				let t = n(c, e), s = r(c, e.anchor), d = o(l, s.x, s.y);
+				return {
+					id: `corner-${e.tag}`,
+					targetId: i.id,
+					shape: {
+						kind: "point",
+						x: t.x,
+						y: t.y,
+						hitRadiusPx: u,
+						turned: !0
+					},
+					paint: h,
+					hitKind: e.kind,
+					cursor: {
+						glyph: "resize",
+						angle: (e.anchor.x === e.anchor.y ? Math.PI / 4 : -Math.PI / 4) + a(l),
+						fallback: e.anchor.x === e.anchor.y ? "nwse-resize" : "nesw-resize"
+					},
+					bind: () => ({ initialScratch: {
+						anchor: e.anchor,
+						targetId: i.id,
+						fixedPoint: d
+					} })
+				};
+			});
+		}
+	};
+}
+function d(e) {
+	if (e.multiActive && e.unionBounds) return {
+		id: i,
+		bounds: e.unionBounds
+	};
+	if (e.selection.length === 1) {
+		let t = e.selection[0], n = e.boundsOf(t);
+		return n ? {
+			id: t,
+			bounds: n
+		} : null;
+	}
+	return null;
+}
+//#endregion
+export { u as createCornerResizeAffordance };
+
+//# sourceMappingURL=cornerResize.js.map

package/dist/affordances/cornerResize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cornerResize.js","names":["DEFAULT_FILL","DEFAULT_STROKE","createCornerResizeAffordance","HANDLE_BASE_PX","opts","paint","handleSize","fill","stroke","target","pickRenderTarget","state","b","xf","transformOf","CORNER_ANCHORS","corner","cornerPoint","c","fixedLocal","fixedCornerOf","fixedPoint","localToWorld","handleHitRadius","angleOf","MULTI_RESIZE_TARGET_ID","id"],"sources":["../../src/affordances/cornerResize.ts"],"sourcesContent":["import type { Affordance, AffordanceBinding, AffordanceRegion, CommonAffordanceScratch } from './types';\nimport type { ChromeState, Bounds } from 'core/selection/chromeState';\nimport type { ResizeAnchor } from 'interactions/gestures/types';\nimport { CORNER_ANCHORS, cornerPoint, fixedCornerOf } from 'interactions/actions/resize/cornerHandles';\nimport { MULTI_RESIZE_TARGET_ID } from 'core/selection/selectionTarget';\nimport { angleOf, localToWorld, transformOf } from './hitAffordanceRegions';\nimport { HANDLE_BASE_PX } from 'core/device/targets';\n\n/** Options for `createCornerResizeAffordance` — the size and appearance of\n *  the corner handles. */\nexport interface CornerResizeAffordanceOptions {\n  /** Hit radius (screen-px) for the corner handles. Default 8. */\n  handleHitRadius?: number;\n  /** Visual handle size (screen-px). Default 8. */\n  handleSize?: number;\n  fill?: string;\n  stroke?: string;\n}\n\n/** What a corner-resize hit hands to the resize action: which corner stays\n *  put, what is being resized, and the world-space pivot to scale from. */\nexport interface CornerResizeScratch extends CommonAffordanceScratch {\n  /** Resize anchor identifying the OPPOSITE corner (the one that stays\n   *  fixed). Matches the kit's existing ResizeAnchor convention. */\n  anchor: ResizeAnchor;\n  /** Id of the resize target. In multi-mode this is `MULTI_RESIZE_TARGET_ID`. */\n  targetId: string;\n  /** The fixed corner in **world** coords, with the target's rotation already\n   *  applied. `resizeAction` scales from this point, and it has no access to\n   *  the target transform, so the affordance resolves it here. */\n  fixedPoint: { x: number; y: number };\n}\n\nconst DEFAULT_FILL = '#d4c4a8';\nconst DEFAULT_STROKE = '#1a130d';\n\n/**\n * @experimental\n * Corner-handle affordance for resizing the active selection (single\n * member in single-mode; the union AABB in multi-mode).\n *\n * Declares four point regions in the target's local frame; the framework\n * applies the target's bounds rotation for both paint and hit-test. The\n * drag channel returned here is a no-op stub that claims — consuming\n * tools (`useResizeTool`) wrap each region's `bind()` to substitute a\n * drag channel that drives `useResize`.\n */\nexport function createCornerResizeAffordance(\n  opts: CornerResizeAffordanceOptions = {},\n): Affordance {\n  const {\n    handleHitRadius = HANDLE_BASE_PX,\n    handleSize = HANDLE_BASE_PX,\n    fill = DEFAULT_FILL,\n    stroke = DEFAULT_STROKE,\n  } = opts;\n\n  const paint = {\n    kind: 'square' as const,\n    sizePx: handleSize,\n    fill: { color: fill },\n    stroke: { paint: { color: stroke }, width: 1 },\n  };\n\n  return {\n    id: 'selection.resize-handles',\n    regions(state: ChromeState): readonly AffordanceRegion[] {\n      const target = pickRenderTarget(state);\n      if (!target) return [];\n      const b = target.bounds;\n      // The transform the framework applies to these regions. Needed here too,\n      // because `fixedPoint` leaves the local frame — it travels to\n      // `resizeAction`, which works in world coords.\n      const xf = transformOf(state, target.id);\n      return CORNER_ANCHORS.map((c) => {\n        const corner = cornerPoint(b, c);\n        const fixedLocal = fixedCornerOf(b, c.anchor);\n        const fixedPoint = localToWorld(xf, fixedLocal.x, fixedLocal.y);\n        return {\n          id: `corner-${c.tag}`,\n          targetId: target.id,\n          shape: { kind: 'point' as const, x: corner.x, y: corner.y, hitRadiusPx: handleHitRadius, turned: true },\n          paint,\n          hitKind: c.kind,\n          // Diagonal by fixed-corner parity: a matched-axis anchor (min-min /\n          // max-max fixed) means the dragged corner sits on the ↘ diagonal;\n          // mixed axes sit on the ↗ diagonal. The glyph is horizontal at angle\n          // 0, so the diagonal is a half-quarter-turn either way, plus the\n          // target's own rotation. The keyword is the fallback rather than the\n          // answer: CSS has four of them, which cannot express a target\n          // rotated to anything but a multiple of 45°.\n          cursor: {\n            glyph: 'resize',\n            angle: (c.anchor.x === c.anchor.y ? Math.PI / 4 : -Math.PI / 4) + angleOf(xf),\n            fallback: c.anchor.x === c.anchor.y ? 'nwse-resize' : 'nesw-resize',\n          },\n          bind: (): AffordanceBinding => ({\n            initialScratch: {\n              anchor: c.anchor,\n              targetId: target.id,\n              fixedPoint,\n            } satisfies CornerResizeScratch,\n          }),\n        } satisfies AffordanceRegion;\n      });\n    },\n  };\n}\n\nfunction pickRenderTarget(state: ChromeState): { id: string; bounds: Bounds } | null {\n  if (state.multiActive && state.unionBounds) {\n    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };\n  }\n  if (state.selection.length === 1) {\n    const id = state.selection[0];\n    const b = state.boundsOf(id);\n    return b ? { id, bounds: b } : null;\n  }\n  return null;\n}\n"],"mappings":";;;;;AAiCA,IAAMA,IAAe,WACfC,IAAiB;AAavB,SAAgBC,EACd,IAAsC,CAAC,GAC3B;CACZ,IAAM,EACJ,qBAAkBC,GAClB,gBAAaA,GACb,UAAOH,GACP,YAASC,MACPG,GAEEC,IAAQ;EACZ,MAAM;EACN,QAAQC;EACR,MAAM,EAAE,OAAOC,EAAK;EACpB,QAAQ;GAAE,OAAO,EAAE,OAAOC,EAAO;GAAG,OAAO;EAAE;CAC/C;CAEA,OAAO;EACL,IAAI;EACJ,QAAQ,GAAiD;GACvD,IAAMC,IAASC,EAAiBC,CAAK;GACrC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAIH,EAAO,QAIXI,IAAKC,EAAYH,GAAOF,EAAO,EAAE;GACvC,OAAOM,EAAe,KAAK,MAAM;IAC/B,IAAMC,IAASC,EAAYL,GAAGM,CAAC,GACzBC,IAAaC,EAAcR,GAAGM,EAAE,MAAM,GACtCG,IAAaC,EAAaT,GAAIM,EAAW,GAAGA,EAAW,CAAC;IAC9D,OAAO;KACL,IAAI,UAAUD,EAAE;KAChB,UAAUT,EAAO;KACjB,OAAO;MAAE,MAAM;MAAkB,GAAGO,EAAO;MAAG,GAAGA,EAAO;MAAG,aAAaO;MAAiB,QAAQ;KAAK;KACtG;KACA,SAASL,EAAE;KAQX,QAAQ;MACN,OAAO;MACP,QAAQA,EAAE,OAAO,MAAMA,EAAE,OAAO,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,KAAK,KAAKM,EAAQX,CAAE;MAC5E,UAAUK,EAAE,OAAO,MAAMA,EAAE,OAAO,IAAI,gBAAgB;KACxD;KACA,aAAgC,EAC9B,gBAAgB;MACd,QAAQA,EAAE;MACV,UAAUT,EAAO;MACjB;KACF,EACF;IACF;GACF,CAAC;EACH;CACF;AACF;AAEA,SAASC,EAAiB,GAA2D;CACnF,IAAIC,EAAM,eAAeA,EAAM,aAC7B,OAAO;EAAE,IAAIc;EAAwB,QAAQd,EAAM;CAAY;CAEjE,IAAIA,EAAM,UAAU,WAAW,GAAG;EAChC,IAAMe,IAAKf,EAAM,UAAU,IACrBC,IAAID,EAAM,SAASe,CAAE;EAC3B,OAAOd,IAAI;GAAE;GAAI,QAAQA;EAAE,IAAI;CACjC;CACA,OAAO;AACT"}

package/dist/affordances/hitAffordanceRegions.js

@@ -0,0 +1,138 @@
+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";
+//#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 (!g(a, t, n, s, i)) continue;
+			let l = o(a, t, n, s, i);
+			(d === null || l <= d.d2) && (d = {
+				region: a,
+				d2: l
+			});
+		}
+		if (d) return {
+			affordanceId: l.id,
+			regionId: d.region.id,
+			region: d.region,
+			binding: d.region.bind()
+		};
+	}
+	return null;
+}
+function o(e, t, n, r, i) {
+	let a = e.shape, o = a.kind === "point" ? m(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;
+}
+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 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, t, n) {
+	let i = m(e, t, n), a = e.turned ? r(l(t), n.scale) : 0;
+	return {
+		x: i.x,
+		y: i.y,
+		angle: a,
+		half: e.hitRadiusPx
+	};
+}
+function p(e, t, n, r) {
+	let i = f(e, t, n), [a, o] = r(i.x, i.y), s = Math.cos(i.angle) * i.half, c = Math.sin(i.angle) * i.half;
+	return [
+		[-1, -1],
+		[1, -1],
+		[1, 1],
+		[-1, 1]
+	].map(([e, t]) => ({
+		x: a + s * e - c * t,
+		y: o + c * e + s * t
+	}));
+}
+function m(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 h(e, n, r = 0) {
+	let i = e.minBandPx ?? 0;
+	if (i === 0) return {
+		rx: e.rx,
+		ry: e.ry
+	};
+	let a = t(i, n.scale, r);
+	return {
+		rx: Math.max(e.rx, e.innerWidth / 2 + a.x),
+		ry: Math.max(e.ry, e.innerHeight / 2 + a.y)
+	};
+}
+function g(e, t, r, i, a) {
+	let o = d(i, t, r);
+	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 Math.abs(u) <= o.half && Math.abs(d) <= o.half;
+	}
+	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 } = h(t, a, l(i));
+		if (n <= 0 || r <= 0) return !1;
+		let s = (o.x - t.cx) / n, c = (o.y - t.cy) / r;
+		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;
+}
+//#endregion
+export { l as angleOf, h as annulusSemiAxes, a as hitAffordanceRegions, u as localToWorld, m as pointRegionAnchor, f as pointRegionFrame, p as pointRegionScreenQuad, c as transformOf };
+
+//# sourceMappingURL=hitAffordanceRegions.js.map