@weasel-js/core 1.10.1 → 1.11.1

package/dist/features/selection/overlay.js

@@ -1,434 +1,394 @@
-import { viewToTransform as e } from "../../core/viewport/view.js";
-import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
-import { HANDLE_BASE_PX as n } from "../../core/device/targets.js";
-import { unionAABB as r } from "../../core/geometry/unionBounds.js";
-import { framedBounds as i, visualBoundsViaDescriptor as a } from "../../core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as o } from "../../core/geometry/autoPoseDescriptor.js";
-import { angleOf as s, localToWorld as c, targetCorners as l, targetTransformOf as u } from "../../core/geometry/targetFrame.js";
-import { MULTI_RESIZE_TARGET_ID as d } from "../../core/selection/selectionTarget.js";
-import { DEFAULT_ROTATION_HANDLE_DISTANCE as f, rotationHandle as p } from "../../interactions/actions/rotate/handle.js";
-import { mat3 as m } from "@weasel-js/renderer";
-import { PATH_L as h, PATH_M as g, PATH_Z as _, screenAngleOf as v } from "@weasel-js/geom";
-import { alignedStrokeRect as y } from "@weasel-js/paint";
-import { resolveStrokeWidth as b } from "@weasel-js/stroke";
+import { viewToTransform } from "../../core/viewport/view.js";
+import { worldToScreen } from "../../core/viewport/viewTransform.js";
+import { AUTO_POSE_DESCRIPTOR } from "../../core/geometry/autoPoseDescriptor.js";
+import { targetCorners, targetTransformOf } from "../../core/geometry/targetFrame.js";
+import { MULTI_RESIZE_TARGET_ID } from "../../core/selection/selectionTarget.js";
+import { composeSelectionPose, containerAwareBoundsResolver } from "./selectionPose.js";
+import { DEFAULT_ROTATION_HANDLE_DISTANCE, rotationHandle } from "../../interactions/actions/rotate/handle.js";
+import { handleCommandsFor, rectPathFor, resolveHandles } from "./handleCommands.js";
+import { mat3 } from "@weasel-js/renderer";
+import { PATH_L, PATH_M, PATH_Z } from "@weasel-js/geom";
+import { alignedStrokeRect } from "@weasel-js/paint";
+import { resolveStrokeWidth } from "@weasel-js/stroke";
+
 //#region src/features/selection/overlay.ts
-function x(n, r) {
-	let i = e(r), [a, o] = t(n.x, n.y, i);
+/** Project world AABB into screen-space AABB using the active view. */
+function projectBounds(b, view) {
+	const t = viewToTransform(view);
+	const [sx, sy] = worldToScreen(b.x, b.y, t);
 	return {
-		...n,
-		x: a,
-		y: o,
-		width: n.width * r.scale.x,
-		height: n.height * r.scale.y
-	};
-}
-function S(e, t, n) {
-	if (!n(e)) return [e];
-	let r = [], i = (e) => {
-		let a = t(e);
-		if (a.length === 0) {
-			n(e) || r.push(e);
-			return;
-		}
-		for (let e of a) i(e);
-	};
-	return i(e), r;
-}
-function C(e) {
-	let { moveOverlay: t, resizeOverlay: n, getStoredPose: i, getChildren: s, isContainer: c } = e, l = e.poseDescriptor ?? o, u = (e) => s && c ? S(e, s, c) : [e], d = (e) => {
-		let r = t?.poses.get(e);
-		return r === void 0 ? n && n.id === e ? n.currentPose : i(e) : r;
-	};
-	return (e) => {
-		if (c?.(e)) {
-			let o = u(e);
-			if (o.length === 0) return null;
-			let s = n && n.id === e ? n.leafPoses : void 0, c = [];
-			for (let e of o) {
-				let n = t?.poses.get(e);
-				if (n !== void 0) {
-					c.push(a(n, l));
-					continue;
-				}
-				let r = s?.get(e);
-				if (r !== void 0) {
-					c.push(a(r, l));
-					continue;
-				}
-				c.push(a(i(e), l));
-			}
-			let d = r(c);
-			return d === null ? null : l.fromBounds(d, i(o[0]));
-		}
-		return d(e);
+		...b,
+		x: sx,
+		y: sy,
+		width: b.width * view.scale.x,
+		height: b.height * view.scale.y
 	};
 }
-function w(e, t, n, o) {
-	let s = (e) => i(e, t);
-	return n === void 0 || o === void 0 ? (t) => {
-		let n = e(t);
-		return n === null ? null : s(n);
-	} : (i) => {
-		if (!o(i)) {
-			let t = e(i);
-			return t === null ? null : s(t);
-		}
-		let c = S(i, n, o);
-		if (c.length === 0) return null;
-		let l = [];
-		for (let n of c) {
-			let r = e(n);
-			r !== null && l.push(a(r, t));
-		}
-		return l.length === 0 ? null : r(l);
-	};
-}
-var T = {
+var DEFAULT_OUTLINE = {
 	paint: {
 		kind: "solid",
 		color: "#f0e0a8"
 	},
 	width: 2,
 	pad: 1
-}, E = { paint: {
-	kind: "solid",
-	color: "#d4c4a8"
-} }, D = {
-	paint: {
-		kind: "solid",
-		color: "#1a130d"
-	},
-	width: 1
-}, O = n;
-function k(e) {
-	return [
-		{
-			x: e.x,
-			y: e.y
-		},
-		{
-			x: e.x + e.width,
-			y: e.y
-		},
-		{
-			x: e.x,
-			y: e.y + e.height
-		},
-		{
-			x: e.x + e.width,
-			y: e.y + e.height
-		}
-	];
-}
-function A(e) {
-	return e ? {
-		stroke: {
-			paint: e.paint,
-			width: e.width ?? T.width,
-			dash: e.dash,
-			cap: e.cap,
-			join: e.join,
-			align: e.align
-		},
-		pad: e.pad ?? T.pad
-	} : {
+};
+function resolveOutlineStroke(opts) {
+	if (!opts) return {
 		stroke: {
-			paint: T.paint,
-			width: T.width
+			paint: DEFAULT_OUTLINE.paint,
+			width: DEFAULT_OUTLINE.width
 		},
-		pad: T.pad
+		pad: DEFAULT_OUTLINE.pad
 	};
-}
-function j(e) {
-	return {
-		size: e?.size ?? O,
-		fill: e?.fill ?? E,
-		outline: e?.outline ?? D
-	};
-}
-function M(e, t, n) {
-	let r = Math.cos(n), i = Math.sin(n), a = e - r * e + i * t, o = t - i * e - r * t;
-	return new Float32Array([
-		r,
-		i,
-		0,
-		-i,
-		r,
-		0,
-		a,
-		o,
-		1
-	]);
-}
-function N(e, t, n, r) {
 	return {
-		kind: "rect",
-		x: e,
-		y: t,
-		width: n,
-		height: r
+		stroke: {
+			paint: opts.paint,
+			width: opts.width ?? DEFAULT_OUTLINE.width,
+			dash: opts.dash,
+			cap: opts.cap,
+			join: opts.join,
+			align: opts.align
+		},
+		pad: opts.pad ?? DEFAULT_OUTLINE.pad
 	};
 }
-function P(e, t, n, r, i) {
-	let a = [], o = n.align ?? "center", s = b(n.width ?? 1, 1);
-	for (let c of e) {
-		let e = t(c);
-		if (!e) continue;
-		let l = x(e, i), d = {
-			x: l.x - r,
-			y: l.y - r,
-			width: l.width + r * 2,
-			height: l.height + r * 2
-		}, f = u(e);
-		if (f.identity) {
-			let e = y(d, o, s);
-			a.push({
+/** GL helper: emit an outline command for one bounds entry. */
+function outlineCommandsFor(ids, resolveBounds, stroke, pad, view) {
+	const out = [];
+	const align = stroke.align ?? "center";
+	const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+	for (const id of ids) {
+		const worldB = resolveBounds(id);
+		if (!worldB) continue;
+		const b = projectBounds(worldB, view);
+		const padded = {
+			x: b.x - pad,
+			y: b.y - pad,
+			width: b.width + pad * 2,
+			height: b.height + pad * 2
+		};
+		const xf = targetTransformOf(worldB);
+		if (xf.identity) {
+			const r = alignedStrokeRect(padded, align, width);
+			out.push({
 				kind: "path",
-				path: N(e.x, e.y, e.width, e.height),
-				stroke: n
+				path: rectPathFor(r.x, r.y, r.width, r.height),
+				stroke
 			});
 			continue;
 		}
-		let p = F(e, f, i, r + (o === "outer" ? s / 2 : o === "inner" ? -s / 2 : 0));
-		a.push({
+		const q = screenCorners(worldB, xf, view, pad + (align === "outer" ? width / 2 : align === "inner" ? -width / 2 : 0));
+		out.push({
 			kind: "path",
 			path: {
 				kind: "polygon",
 				commands: new Uint8Array([
-					g,
-					h,
-					h,
-					h,
-					_
+					PATH_M,
+					PATH_L,
+					PATH_L,
+					PATH_L,
+					PATH_Z
 				]),
 				coords: new Float32Array([
-					p[0].x,
-					p[0].y,
-					p[1].x,
-					p[1].y,
-					p[2].x,
-					p[2].y,
-					p[3].x,
-					p[3].y
+					q[0].x,
+					q[0].y,
+					q[1].x,
+					q[1].y,
+					q[2].x,
+					q[2].y,
+					q[3].x,
+					q[3].y
 				]),
 				fillRule: "nonzero"
 			},
 			stroke: {
-				...n,
+				...stroke,
 				align: "center"
 			}
 		});
 	}
-	return a;
+	return out;
 }
-function F(n, r, i, a) {
-	let o = e(i), s = l(n, r).map((e) => {
-		let [n, r] = t(e.x, e.y, o);
+/**
+* A framed target's corners on screen, TL/TR/BR/BL, each pushed `pad` screen
+* pixels out from both edges that meet there.
+*/
+function screenCorners(worldB, xf, view, pad) {
+	const t = viewToTransform(view);
+	const q = targetCorners(worldB, xf).map((w) => {
+		const [x, y] = worldToScreen(w.x, w.y, t);
 		return {
-			x: n,
-			y: r
+			x,
+			y
 		};
 	});
-	if (a === 0) return s;
-	let [c, u] = t(n.x + n.width / 2, n.y + n.height / 2, o), d = (e, t) => {
-		let n = -(t.y - e.y), r = t.x - e.x, i = Math.hypot(n, r) || 1;
-		n /= i, r /= i;
-		let a = (e.x + t.x) / 2 - c, o = (e.y + t.y) / 2 - u;
-		return n * a + r * o < 0 ? {
-			x: -n,
-			y: -r
+	if (pad === 0) return q;
+	const [ccx, ccy] = worldToScreen(worldB.x + worldB.width / 2, worldB.y + worldB.height / 2, t);
+	const normal = (a, b) => {
+		let nx = -(b.y - a.y), ny = b.x - a.x;
+		const l = Math.hypot(nx, ny) || 1;
+		nx /= l;
+		ny /= l;
+		const mx = (a.x + b.x) / 2 - ccx, my = (a.y + b.y) / 2 - ccy;
+		return nx * mx + ny * my < 0 ? {
+			x: -nx,
+			y: -ny
 		} : {
-			x: n,
-			y: r
+			x: nx,
+			y: ny
 		};
 	};
-	return s.map((e, t) => {
-		let n = d(s[(t + 3) % 4], e), r = d(e, s[(t + 1) % 4]), i = a / (1 + n.x * r.x + n.y * r.y);
+	return q.map((c, i) => {
+		const n1 = normal(q[(i + 3) % 4], c);
+		const n2 = normal(c, q[(i + 1) % 4]);
+		const k = pad / (1 + n1.x * n2.x + n1.y * n2.y);
 		return {
-			x: e.x + (n.x + r.x) * i,
-			y: e.y + (n.y + r.y) * i
+			x: c.x + (n1.x + n2.x) * k,
+			y: c.y + (n1.y + n2.y) * k
 		};
 	});
 }
-function I(n, r, i, a, o) {
-	let l = [], d = i.size / 2, f = i.outline.align ?? "center", p = b(i.outline.width ?? 1, 1);
-	for (let m of n) {
-		let n = r(m);
-		if (!n) continue;
-		let h = u(n), g = e(o), _ = v(s(h), o.scale);
-		for (let e of a(n)) {
-			let n = c(h, e.x, e.y), [r, a] = t(n.x, n.y, g), o = {
-				x: r,
-				y: a
-			}, s = {
-				x: o.x - d,
-				y: o.y - d,
-				width: i.size,
-				height: i.size
-			}, u = y(s, f, p), m = {
-				kind: "path",
-				path: N(s.x, s.y, s.width, s.height),
-				fill: i.fill
-			}, v = {
-				kind: "path",
-				path: N(u.x, u.y, u.width, u.height),
-				stroke: i.outline
-			};
-			_ === 0 ? l.push(m, v) : l.push({
-				kind: "group",
-				transform: M(o.x, o.y, _),
-				children: [m, v]
-			});
-		}
-	}
-	return l;
-}
-function L(n, r, i, a) {
-	let o = p(n, i, a.scale), s = o.angle, c = e(a), [l, u] = t(o.cx, o.cy, c), d = r.size, f = d, _ = Math.PI * 240 / 360 / 2, v = b(r.outline.width ?? 1, 1) * 1.5, y = {
-		paint: r.fill.paint,
-		width: v,
+/** GL helper: emit a curved double-headed arrow, the rotate badge above the
+*  rect. The arc opens *toward* the object (apex on top, mouth pointing
+*  down), with an arrowhead at each endpoint pointing along the tangent. */
+function rotationHandleCommands(worldB, handles, distance, view) {
+	const hWorld = rotationHandle(worldB, distance, view.scale);
+	const rotation = hWorld.angle;
+	const t = viewToTransform(view);
+	const [scx, scy] = worldToScreen(hWorld.cx, hWorld.cy, t);
+	const size = handles.size;
+	const arcRadius = size;
+	const ARC_HALF_ANGLE = Math.PI * 240 / 360 / 2;
+	const N_SEGS = 18;
+	const arcWidth = resolveStrokeWidth(handles.outline.width ?? 1, 1) * 1.5;
+	const stroke = {
+		paint: handles.fill.paint,
+		width: arcWidth,
 		cap: "round",
 		join: "round"
-	}, x = [g], S = [], C = [];
-	for (let e = 0; e <= 18; e++) {
-		let t = _ - e / 18 * _ * 2;
-		S.push(f * Math.sin(t)), C.push(-f * Math.cos(t)), e > 0 && x.push(h);
+	};
+	const cmds = [PATH_M];
+	const xs = [];
+	const ys = [];
+	for (let i = 0; i <= N_SEGS; i++) {
+		const angle = ARC_HALF_ANGLE - i / N_SEGS * ARC_HALF_ANGLE * 2;
+		xs.push(arcRadius * Math.sin(angle));
+		ys.push(-arcRadius * Math.cos(angle));
+		if (i > 0) cmds.push(PATH_L);
 	}
-	let w = [];
-	for (let e = 0; e < S.length; e++) w.push(S[e], C[e]);
-	let T = {
+	const arcCoords = [];
+	for (let i = 0; i < xs.length; i++) arcCoords.push(xs[i], ys[i]);
+	const arcPath = {
 		kind: "polygon",
-		commands: new Uint8Array(x),
-		coords: new Float32Array(w),
+		commands: new Uint8Array(cmds),
+		coords: new Float32Array(arcCoords),
 		fillRule: "nonzero"
-	}, E = d * .6, D = d * .4, O = (e, t, n, r) => {
-		let i = Math.hypot(n, r) || 1, a = n / i, o = r / i, s = -o, c = a, l = e + a * E, u = t + o * E, d = e + D / 2 * s, f = t + D / 2 * c, p = e - D / 2 * s, m = t - D / 2 * c;
+	};
+	const headLen = size * .6;
+	const headWidth = size * .4;
+	const arrowHead = (endX, endY, tx, ty) => {
+		const len = Math.hypot(tx, ty) || 1;
+		const ux = tx / len;
+		const uy = ty / len;
+		const px = -uy;
+		const py = ux;
+		const tipX = endX + ux * headLen;
+		const tipY = endY + uy * headLen;
+		const baseLeftX = endX + px * (headWidth / 2);
+		const baseLeftY = endY + py * (headWidth / 2);
+		const baseRightX = endX - px * (headWidth / 2);
+		const baseRightY = endY - py * (headWidth / 2);
 		return {
 			kind: "polygon",
 			commands: new Uint8Array([
-				g,
-				h,
-				h,
-				h
+				PATH_M,
+				PATH_L,
+				PATH_L,
+				PATH_L
 			]),
 			coords: new Float32Array([
-				l,
-				u,
-				d,
-				f,
-				p,
-				m,
-				l,
-				u
+				tipX,
+				tipY,
+				baseLeftX,
+				baseLeftY,
+				baseRightX,
+				baseRightY,
+				tipX,
+				tipY
 			]),
 			fillRule: "nonzero"
 		};
-	}, k = _, A = f * Math.sin(k), j = -f * Math.cos(k), M = Math.cos(k), N = Math.sin(k), P = -_, F = f * Math.sin(P), I = -f * Math.cos(P), L = -Math.cos(P), R = -Math.sin(P), z = O(A, j, M, N), B = O(F, I, L, R), V = m.translated(m.identity(), l, u);
-	if (s !== 0) {
-		let e = Math.cos(s), t = Math.sin(s), n = new Float32Array([
-			e,
-			t,
+	};
+	const angleA = ARC_HALF_ANGLE;
+	const endAX = arcRadius * Math.sin(angleA);
+	const endAY = -arcRadius * Math.cos(angleA);
+	const tangentAX = Math.cos(angleA);
+	const tangentAY = Math.sin(angleA);
+	const angleB = -ARC_HALF_ANGLE;
+	const endBX = arcRadius * Math.sin(angleB);
+	const endBY = -arcRadius * Math.cos(angleB);
+	const tangentBX = -Math.cos(angleB);
+	const tangentBY = -Math.sin(angleB);
+	const headA = arrowHead(endAX, endAY, tangentAX, tangentAY);
+	const headB = arrowHead(endBX, endBY, tangentBX, tangentBY);
+	let transform = mat3.translated(mat3.identity(), scx, scy);
+	if (rotation !== 0) {
+		const c = Math.cos(rotation);
+		const s = Math.sin(rotation);
+		const rot = new Float32Array([
+			c,
+			s,
 			0,
-			-t,
-			e,
+			-s,
+			c,
 			0,
 			0,
 			0,
 			1
 		]);
-		V = m.multiply(V, n);
+		transform = mat3.multiply(transform, rot);
 	}
 	return [{
 		kind: "group",
-		transform: V,
+		transform,
 		children: [
 			{
 				kind: "path",
-				path: T,
-				stroke: y
+				path: arcPath,
+				stroke
 			},
 			{
 				kind: "path",
-				path: z,
-				fill: r.fill
+				path: headA,
+				fill: handles.fill
 			},
 			{
 				kind: "path",
-				path: B,
-				fill: r.fill
+				path: headB,
+				fill: handles.fill
 			}
 		]
 	}];
 }
-function R(e, t) {
-	let { stroke: n, pad: r } = A(e.outline), i = t.handles && e.handles !== !1 ? j(e.handles || void 0) : null, a = e.handlesOf ?? k, s = e.poseDescriptor ?? o, c = e.getPose, l = c ? w(c, s, e.getChildren, e.isContainer) : null, u = t.handles ? z(e)?.distancePx ?? null : null;
+function buildSelectionLayer(opts, passes) {
+	const { stroke, pad } = resolveOutlineStroke(opts.outline);
+	const handles = passes.handles && opts.handles !== false ? resolveHandles(opts.handles || void 0) : null;
+	const { handlesOf, resizeHandles } = opts;
+	const d = opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+	const getPose = opts.getPose;
+	const poseBounds = getPose ? containerAwareBoundsResolver(getPose, d, opts.getChildren, opts.isContainer, opts.scene) : null;
+	const rotationHandleDistance = passes.handles ? rotationBadgeOf(opts)?.distancePx ?? null : null;
 	return {
-		id: t.id,
-		label: t.label,
+		id: passes.id,
+		label: passes.label,
 		space: "screen",
-		draw: (o, s) => {
-			let c = G(o), f = e.getSelection ? e.getSelection() : W(c);
-			if (f.length === 0) return [];
-			let p = e.getSuppressedIds?.(), m = p && p.size > 0 ? f.filter((e) => !p.has(e)) : f;
-			if (m.length === 0) return [];
-			let h = U(o), g = t.outline && (!h || h("selection.outline")), _ = !h || h("selection.resize-handles"), v = !h || h("selection.rotation-handle"), y = l ?? ((e) => c?.boundsOf(e) ?? null), b = (e) => e === d && c?.unionBounds != null ? c.unionBounds : y(e), x = [];
-			if (g) {
-				let t = e.getOutlineIds ? e.getOutlineIds() : e.getSelection ? m : c?.selection ?? m, i = p && p.size > 0 ? t.filter((e) => !p.has(e)) : t;
-				for (let e of P(i, b, n, r, s)) x.push(e);
+		draw: (data, view) => {
+			const chromeState = asChromeState(data);
+			const allIds = opts.getSelection ? opts.getSelection() : chromeSelectionIds(chromeState);
+			if (allIds.length === 0) return [];
+			const suppressed = opts.getSuppressedIds?.();
+			const ids = suppressed && suppressed.size > 0 ? allIds.filter((id) => !suppressed.has(id)) : allIds;
+			if (ids.length === 0) return [];
+			const isVisible = asIsVisible(data);
+			const showOutline = passes.outline && (isVisible ? isVisible("selection.outline") : true);
+			const showHandles = isVisible ? isVisible("selection.resize-handles") : true;
+			const showRotation = isVisible ? isVisible("selection.rotation-handle") : true;
+			const resolveBounds = poseBounds ? (id) => poseBounds(id, view.scale) : (id) => chromeState?.boundsOf(id) ?? null;
+			const resolveTargetBounds = (id) => {
+				if (id === MULTI_RESIZE_TARGET_ID && chromeState?.unionBounds != null) return chromeState.unionBounds;
+				return resolveBounds(id);
+			};
+			const out = [];
+			if (showOutline) {
+				const outlineIdsRaw = opts.getOutlineIds ? opts.getOutlineIds() : opts.getSelection ? ids : chromeState?.selection ?? ids;
+				const outlineIds = suppressed && suppressed.size > 0 ? outlineIdsRaw.filter((id) => !suppressed.has(id)) : outlineIdsRaw;
+				for (const cmd of outlineCommandsFor(outlineIds, resolveTargetBounds, stroke, pad, view)) out.push(cmd);
 			}
-			if (!i) return x;
-			if (_) for (let e of I(m, b, i, a, s)) x.push(e);
-			if (v && u !== null) for (let e of m) {
-				let t = b(e);
-				if (t) for (let e of L(t, i, u, s)) x.push(e);
+			if (!handles) return out;
+			if (showHandles) for (const cmd of handleCommandsFor(ids, resolveTargetBounds, handles, handlesOf, resizeHandles, view)) out.push(cmd);
+			if (showRotation && rotationHandleDistance !== null) for (const id of ids) {
+				const b = resolveTargetBounds(id);
+				if (!b) continue;
+				for (const cmd of rotationHandleCommands(b, handles, rotationHandleDistance, view)) out.push(cmd);
 			}
-			return x;
+			return out;
 		}
 	};
 }
-function z(e) {
-	let t = e.rotationHandle;
-	return !t || e.handles === !1 ? null : {
-		distancePx: t === !0 ? f : t.distance ?? f,
-		sizePx: j(e.handles || void 0).size
+/** Where the overlay paints its rotate badge and how big it is, in screen
+*  pixels, or `null` when it paints none. The badge's grab region and its
+*  slops halo read this too, so all three agree on it. */
+function rotationBadgeOf(opts) {
+	const r = opts.rotationHandle;
+	if (!r || opts.handles === false) return null;
+	return {
+		distancePx: r === true ? DEFAULT_ROTATION_HANDLE_DISTANCE : r.distance ?? DEFAULT_ROTATION_HANDLE_DISTANCE,
+		sizePx: resolveHandles(opts.handles || void 0).size
 	};
 }
-function B(e) {
-	return R(e, {
+/**
+* `RenderLayer` that draws selection outlines only. Stack alongside
+* `createSelectionHandlesLayer` (or use `createSelectionOverlayLayer`, which
+* runs both passes in one layer) when both are wanted.
+*/
+function createSelectionOutlineLayer(opts) {
+	return buildSelectionLayer(opts, {
 		id: "selection-outline",
 		label: "Selection outline",
-		outline: !0,
-		handles: !1
+		outline: true,
+		handles: false
 	});
 }
-function V(e) {
-	return R(e, {
+/**
+* `RenderLayer` that draws selection handles only. Stack on top of
+* `createSelectionOutlineLayer` (handles render on top of the outline).
+*/
+function createSelectionHandlesLayer(opts) {
+	return buildSelectionLayer(opts, {
 		id: "selection-handles",
 		label: "Selection handles",
-		outline: !1,
-		handles: !0
+		outline: false,
+		handles: true
 	});
 }
-function H(e) {
-	return R(e, {
+/**
+* Draws outlines then handles in a single layer. Exactly equivalent to
+* stacking `createSelectionOutlineLayer` and `createSelectionHandlesLayer` —
+* all three run the same body. Pass `handles: false` to render outlines only.
+*/
+function createSelectionOverlayLayer(opts) {
+	return buildSelectionLayer(opts, {
 		id: "selection-overlay",
 		label: "Selection",
-		outline: !0,
-		handles: !0
+		outline: true,
+		handles: true
 	});
 }
-function U(e) {
-	let t = e;
-	return typeof t?.getIsVisible == "function" ? t.getIsVisible() : null;
+/** Pull a chrome-caps visibility predicate off the draw `data` envelope.
+*  Returns `null` when the caller passed bare data (no `getIsVisible`
+*  thunk) — the layer then renders unconditionally. */
+function asIsVisible(data) {
+	const maybe = data;
+	if (typeof maybe?.getIsVisible === "function") return maybe.getIsVisible();
+	return null;
 }
-function W(e) {
-	return e ? e.multiActive ? [d] : e.selection : [];
+/** The ids the handle pass works against when the layer takes its selection
+*  from the envelope: the synthetic union id for a multi-selection, the
+*  selection itself otherwise. */
+function chromeSelectionIds(state) {
+	if (!state) return [];
+	if (state.multiActive) return [MULTI_RESIZE_TARGET_ID];
+	return state.selection;
 }
-function G(e) {
-	let t = e;
-	return typeof t?.getChromeState == "function" ? t.getChromeState() : null;
+/** Pull live `ChromeState` off the draw `data` envelope. Returns `null` for
+*  callers that pass plain data with no `getChromeState` thunk — the layer
+*  then resolves the multi-union via the supplied `getPose` resolver. */
+function asChromeState(data) {
+	const maybe = data;
+	if (typeof maybe?.getChromeState === "function") return maybe.getChromeState();
+	return null;
 }
-//#endregion
-export { C as composeSelectionPose, V as createSelectionHandlesLayer, B as createSelectionOutlineLayer, H as createSelectionOverlayLayer, z as rotationBadgeOf };
 
+//#endregion
+export { composeSelectionPose, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, rotationBadgeOf };
 //# sourceMappingURL=overlay.js.map