@weasel-js/core 1.7.0 → 1.7.1

package/dist/features/meshPaint/surface.js

@@ -0,0 +1,110 @@
+//#region src/features/meshPaint/surface.ts
+function e(e, t) {
+	return e.points[(t & 3) * 3];
+}
+function t(e) {
+	return e.points.length >= 16;
+}
+function n(e) {
+	return e.points.length === 12 || e.points.length === 16;
+}
+function r(e, t, n, r, i) {
+	let a = 1 - i, o = a * a * a, s = 3 * a * a * i, c = 3 * a * i * i, l = i * i * i;
+	return {
+		x: o * e.x + s * t.x + c * n.x + l * r.x,
+		y: o * e.y + s * t.y + c * n.y + l * r.y
+	};
+}
+function i(e, t) {
+	let n = e.points, r = (t & 3) * 3;
+	return [
+		n[r],
+		n[r + 1],
+		n[r + 2],
+		n[(t + 1 & 3) * 3]
+	];
+}
+function a(e, n, r) {
+	return t(e) ? l(e, n, r) : o(e, n, r);
+}
+function o(t, n, a) {
+	let [o, s, c, l] = i(t, 0), [u, d, f, p] = i(t, 1), [m, h, g, _] = i(t, 2), [v, y, b, x] = i(t, 3), S = r(o, s, c, l, n), C = r(m, h, g, _, 1 - n), w = r(u, d, f, p, a), T = r(v, y, b, x, 1 - a), E = e(t, 0), D = e(t, 1), O = e(t, 2), k = e(t, 3), A = (e, t) => (1 - a) * e + a * t, j = (e, t) => (1 - n) * e + n * t, M = (e, t, r, i) => (1 - n) * (1 - a) * e + n * (1 - a) * t + n * a * r + (1 - n) * a * i;
+	return {
+		x: A(S.x, C.x) + j(T.x, w.x) - M(E.x, D.x, O.x, k.x),
+		y: A(S.y, C.y) + j(T.y, w.y) - M(E.y, D.y, O.y, k.y)
+	};
+}
+function s(e) {
+	let t = e.points;
+	return [
+		[
+			t[0],
+			t[11],
+			t[10],
+			t[9]
+		],
+		[
+			t[1],
+			t[12],
+			t[13],
+			t[8]
+		],
+		[
+			t[2],
+			t[15],
+			t[14],
+			t[7]
+		],
+		[
+			t[3],
+			t[4],
+			t[5],
+			t[6]
+		]
+	];
+}
+var c = (e) => {
+	let t = 1 - e;
+	return [
+		t * t * t,
+		3 * t * t * e,
+		3 * t * e * e,
+		e * e * e
+	];
+};
+function l(e, t, n) {
+	let r = s(e), i = c(t), a = c(n), o = 0, l = 0;
+	for (let e = 0; e < 4; e++) for (let t = 0; t < 4; t++) {
+		let n = i[e] * a[t];
+		o += n * r[e][t].x, l += n * r[e][t].y;
+	}
+	return {
+		x: o,
+		y: l
+	};
+}
+function u(e, t) {
+	return [
+		(1 - e) * (1 - t),
+		e * (1 - t),
+		e * t,
+		(1 - e) * t
+	];
+}
+function d(e, t = 8) {
+	let n = Infinity, r = Infinity, i = -Infinity, o = -Infinity;
+	for (let s = 0; s <= t; s++) for (let c = 0; c <= t; c++) {
+		let l = a(e, s / t, c / t);
+		l.x < n && (n = l.x), l.y < r && (r = l.y), l.x > i && (i = l.x), l.y > o && (o = l.y);
+	}
+	return {
+		x: n,
+		y: r,
+		width: i - n,
+		height: o - r
+	};
+}
+//#endregion
+export { u as cornerWeights, a as evalPatch, t as isTensorPatch, n as isValidPatch, d as patchBounds, e as patchCorner };
+
+//# sourceMappingURL=surface.js.map

package/dist/features/meshPaint/surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.js","names":["patchCorner","patch","i","isTensorPatch","isValidPatch","bezier","s","t","a","b","d","p0","p1","p2","p3","edge","p","evalPatch","evalTensor","u","v","evalCoons","b0","b1","b2","b3","r0","r1","r2","r3","t0","t1","t2","t3","l0","l1","l2","l3","bottom","top","right","left","c0","c1","c2","c3","ruledU","ruledV","corner","k0","k1","k2","k3","tensorNet","BERNSTEIN","net","bu","bv","x","y","j","w","cornerWeights","patchBounds","minX","minY","maxX","maxY","steps"],"sources":["../../../src/features/meshPaint/surface.ts"],"sourcesContent":["/**\n * Coons and tensor-product patch surfaces — PDF's shading types 6 and 7, as\n * pure geometry.\n *\n * A patch is a curved quadrilateral: four cubic Bézier edges and a color at\n * each corner. The interior is what the edges imply — a Coons patch reads it\n * off the boundary alone; a tensor patch adds four interior control points\n * that pull it around. Both evaluate at a `(u, v)` in the unit square, which\n * is what lets the renderer subdivide a patch into as many triangles as it\n * wants without the patch knowing.\n *\n * Nothing here touches GL, a color string, or a scene. `evalPatch` is the\n * whole contract.\n */\n\n/** A point in the patch's own space. */\nexport interface MeshPoint {\n  x: number;\n  y: number;\n}\n\n/**\n * One patch.\n *\n * `points` walks the boundary: corner 0, the two control points of the edge\n * leaving it, corner 1, its two, and so on — twelve points, ending with the\n * two controls that return to corner 0. A tensor patch appends its four\n * interior points, in the order `(1,1)`, `(1,2)`, `(2,2)`, `(2,1)` of the\n * bicubic control net, which is PDF's own order.\n *\n * Twelve points is a Coons patch and sixteen is a tensor patch; there is no\n * flag, because the count already says which it is.\n *\n * `colors` are the corner colors in the same walk order, as whatever color\n * form the caller resolves — the renderer hands premultiplied RGBA in, the\n * serializer hands CSS strings.\n */\nexport interface MeshPatch<TColor = string> {\n  points: readonly MeshPoint[];\n  colors: readonly [TColor, TColor, TColor, TColor];\n}\n\n/** Corner `i` of the boundary walk. */\nexport function patchCorner(patch: MeshPatch<unknown>, i: number): MeshPoint {\n  return patch.points[(i & 3) * 3];\n}\n\n/** `true` when the patch carries the four interior points a tensor patch adds. */\nexport function isTensorPatch(patch: MeshPatch<unknown>): boolean {\n  return patch.points.length >= 16;\n}\n\n/** A patch is twelve boundary points, or sixteen with the interior. Anything\n *  else cannot be evaluated, and saying so here beats painting nonsense. */\nexport function isValidPatch(patch: MeshPatch<unknown>): boolean {\n  return patch.points.length === 12 || patch.points.length === 16;\n}\n\nfunction bezier(p0: MeshPoint, p1: MeshPoint, p2: MeshPoint, p3: MeshPoint, t: number): MeshPoint {\n  const s = 1 - t;\n  const a = s * s * s;\n  const b = 3 * s * s * t;\n  const c = 3 * s * t * t;\n  const d = t * t * t;\n  return {\n    x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,\n    y: a * p0.y + b * p1.y + c * p2.y + d * p3.y,\n  };\n}\n\n/** The edge leaving corner `i`, as its four control points. */\nfunction edge(patch: MeshPatch<unknown>, i: number): [MeshPoint, MeshPoint, MeshPoint, MeshPoint] {\n  const p = patch.points;\n  const a = (i & 3) * 3;\n  return [p[a], p[a + 1], p[a + 2], p[((i + 1) & 3) * 3]];\n}\n\n/**\n * The patch surface at `(u, v)`, both in `0..1`.\n *\n * `u` runs along the edge leaving corner 0 and `v` along the edge leaving\n * corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and\n * `(0,1)` corner 3 — the same walk `colors` is in.\n */\nexport function evalPatch(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  return isTensorPatch(patch) ? evalTensor(patch, u, v) : evalCoons(patch, u, v);\n}\n\nfunction evalCoons(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  const [b0, b1, b2, b3] = edge(patch, 0);        // corner 0 → 1, along u at v=0\n  const [r0, r1, r2, r3] = edge(patch, 1);        // corner 1 → 2, along v at u=1\n  const [t0, t1, t2, t3] = edge(patch, 2);        // corner 2 → 3, along u at v=1\n  const [l0, l1, l2, l3] = edge(patch, 3);        // corner 3 → 0, along v at u=0\n\n  const bottom = bezier(b0, b1, b2, b3, u);\n  const top = bezier(t0, t1, t2, t3, 1 - u);      // walks 2 → 3, so reverse it\n  const right = bezier(r0, r1, r2, r3, v);\n  const left = bezier(l0, l1, l2, l3, 1 - v);     // walks 3 → 0, so reverse it\n\n  const c0 = patchCorner(patch, 0);\n  const c1 = patchCorner(patch, 1);\n  const c2 = patchCorner(patch, 2);\n  const c3 = patchCorner(patch, 3);\n\n  // The Coons construction: the two ruled surfaces between opposite edges,\n  // minus the bilinear surface through the corners they both already carry.\n  const ruledU = (a: number, b: number): number => (1 - v) * a + v * b;\n  const ruledV = (a: number, b: number): number => (1 - u) * a + u * b;\n  const corner = (k0: number, k1: number, k2: number, k3: number): number =>\n    (1 - u) * (1 - v) * k0 + u * (1 - v) * k1 + u * v * k2 + (1 - u) * v * k3;\n\n  return {\n    x: ruledU(bottom.x, top.x) + ruledV(left.x, right.x)\n      - corner(c0.x, c1.x, c2.x, c3.x),\n    y: ruledU(bottom.y, top.y) + ruledV(left.y, right.y)\n      - corner(c0.y, c1.y, c2.y, c3.y),\n  };\n}\n\n/** The bicubic control net a tensor patch's sixteen points make, as\n *  `net[i][j]` with `i` along `u` and `j` along `v`. */\nfunction tensorNet(patch: MeshPatch<unknown>): MeshPoint[][] {\n  const p = patch.points;\n  // Boundary, read off the same walk; interior from the four trailing points.\n  return [\n    [p[0], p[11], p[10], p[9]],\n    [p[1], p[12], p[13], p[8]],\n    [p[2], p[15], p[14], p[7]],\n    [p[3], p[4], p[5], p[6]],\n  ];\n}\n\nconst BERNSTEIN = (t: number): [number, number, number, number] => {\n  const s = 1 - t;\n  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];\n};\n\nfunction evalTensor(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  const net = tensorNet(patch);\n  const bu = BERNSTEIN(u);\n  const bv = BERNSTEIN(v);\n  let x = 0;\n  let y = 0;\n  for (let i = 0; i < 4; i++) {\n    for (let j = 0; j < 4; j++) {\n      const w = bu[i] * bv[j];\n      x += w * net[i][j].x;\n      y += w * net[i][j].y;\n    }\n  }\n  return { x, y };\n}\n\n/**\n * The four corner weights at `(u, v)` — bilinear, in the corner walk order.\n *\n * Color is separate from position on purpose: it interpolates in whatever\n * space the caller chose, which is not a thing the surface can do for it.\n */\nexport function cornerWeights(u: number, v: number): [number, number, number, number] {\n  return [(1 - u) * (1 - v), u * (1 - v), u * v, (1 - u) * v];\n}\n\n/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone\n *  bound a Bézier but not tightly, and a mesh paint is baked into a texture\n *  sized from this — a loose box wastes texels on every side. */\nexport function patchBounds(\n  patch: MeshPatch<unknown>, steps = 8,\n): { x: number; y: number; width: number; height: number } {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (let i = 0; i <= steps; i++) {\n    for (let j = 0; j <= steps; j++) {\n      const p = evalPatch(patch, i / steps, j / steps);\n      if (p.x < minX) minX = p.x;\n      if (p.y < minY) minY = p.y;\n      if (p.x > maxX) maxX = p.x;\n      if (p.y > maxY) maxY = p.y;\n    }\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":"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"}

package/dist/features/minimap/actions.js

@@ -0,0 +1,53 @@
+//#region src/features/minimap/actions.ts
+var e = "minimap.center", t = "minimap.pan";
+function n(e, t, n) {
+	let r = e.hostSize?.();
+	if (!r) return;
+	let i = e.get();
+	e.set({
+		x: t - r.width / (2 * i.scale.x),
+		y: n - r.height / (2 * i.scale.y),
+		scale: i.scale
+	});
+}
+function r(e) {
+	return e.rootView;
+}
+function i() {
+	return {
+		id: e,
+		label: "Minimap — center the view here",
+		requires: ["rootView"],
+		invoker: {
+			timing: "immediate",
+			run: (e, t) => {
+				let i = t, a = r(e);
+				a && i?.worldX !== void 0 && i.worldY !== void 0 && n(a, i.worldX, i.worldY);
+			}
+		}
+	};
+}
+function a() {
+	return {
+		id: t,
+		label: "Minimap — pan the view",
+		requires: ["rootView"],
+		invoker: {
+			timing: "ongoing",
+			start(e) {
+				let t = r(e.deps);
+				return t ? {
+					onMove: (e) => {
+						let r = e.drag?.current ?? e.world;
+						n(t, r.x, r.y);
+					},
+					onEnd: () => {}
+				} : {};
+			}
+		}
+	};
+}
+//#endregion
+export { e as MINIMAP_CENTER, t as MINIMAP_PAN, n as centerRootOn, i as minimapCenterAction, a as minimapPanAction };
+
+//# sourceMappingURL=actions.js.map

package/dist/features/minimap/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","names":["MINIMAP_CENTER","MINIMAP_PAN","centerRootOn","size","root","v","x","y","rootOf","deps","minimapCenterAction","p","params","minimapPanAction","ctx","m"],"sources":["../../../src/features/minimap/actions.ts"],"sourcesContent":["/**\n * The minimap's input: press to recenter the main camera on a world point,\n * drag to keep it there. Both read `rootView` — never `view`, which inside the\n * minimap's own view answers the minimap's camera.\n */\nimport type { Action, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { ViewApi } from 'interactions/actions/depSchema';\n\n/** Action id for `minimapCenterAction`. */\nexport const MINIMAP_CENTER = 'minimap.center';\n/** Action id for `minimapPanAction`. */\nexport const MINIMAP_PAN = 'minimap.pan';\n\n/** Move `root` so world point (`x`, `y`) sits at the center of its host,\n *  keeping its scale. A no-op while the host is unmeasured. */\nexport function centerRootOn(root: ViewApi, x: number, y: number): void {\n  const size = root.hostSize?.();\n  if (!size) return;\n  const v = root.get();\n  root.set({\n    x: x - size.width / (2 * v.scale.x),\n    y: y - size.height / (2 * v.scale.y),\n    scale: v.scale,\n  });\n}\n\nfunction rootOf(deps: InvocationCtx['deps']): ViewApi | undefined {\n  return deps.rootView as ViewApi | undefined;\n}\n\n/** Recenter the main camera on the pressed world point. */\nexport function minimapCenterAction(): Action {\n  return {\n    id: MINIMAP_CENTER,\n    label: 'Minimap — center the view here',\n    requires: ['rootView'],\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const p = params as { worldX?: number; worldY?: number } | undefined;\n        const root = rootOf(deps);\n        if (!root || p?.worldX === undefined || p.worldY === undefined) return;\n        centerRootOn(root, p.worldX, p.worldY);\n      },\n    },\n  };\n}\n\n/** Keep the main camera centered on the pointer's world point while dragging.\n *  Pair it with `minimap.center` on `pointerDown`, which handles the press.\n *  A recenter lands the moment it is computed, so there is nothing to commit\n *  and a cancel ends where a release does. */\nexport function minimapPanAction(): Action {\n  return {\n    id: MINIMAP_PAN,\n    label: 'Minimap — pan the view',\n    requires: ['rootView'],\n    invoker: {\n      timing: 'ongoing',\n      start(ctx: InvocationCtx): OngoingHandle {\n        const root = rootOf(ctx.deps);\n        if (!root) return {};\n        // The press already centered (`minimap.center`); the move that crossed\n        // the drag threshold is pumped to `onMove` like every later one.\n        return {\n          onMove: (m) => {\n            const p = m.drag?.current ?? m.world;\n            centerRootOn(root, p.x, p.y);\n          },\n          onEnd: () => {},\n        };\n      },\n    },\n  };\n}\n"],"mappings":";AASA,IAAaA,IAAiB,kBAEjBC,IAAc;AAI3B,SAAgBC,EAAa,GAAe,GAAW,GAAiB;CACtE,IAAMC,IAAOC,EAAK,WAAW;CAC7B,IAAI,CAACD,GAAM;CACX,IAAME,IAAID,EAAK,IAAI;CACnB,EAAK,IAAI;EACP,GAAGE,IAAIH,EAAK,SAAS,IAAIE,EAAE,MAAM;EACjC,GAAGE,IAAIJ,EAAK,UAAU,IAAIE,EAAE,MAAM;EAClC,OAAOA,EAAE;CACX,CAAC;AACH;AAEA,SAASG,EAAO,GAAkD;CAChE,OAAOC,EAAK;AACd;AAGA,SAAgBC,IAA8B;CAC5C,OAAO;EACL,IAAIV;EACJ,OAAO;EACP,UAAU,CAAC,UAAU;EACrB,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMW,IAAIC,GACJR,IAAOI,EAAOC,CAAI;IACxB,AAAKL,KAAQO,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,KAAA,KACrDT,EAAaE,GAAMO,EAAE,QAAQA,EAAE,MAAM;GACvC;EACF;CACF;AACF;AAMA,SAAgBE,IAA2B;CACzC,OAAO;EACL,IAAIZ;EACJ,OAAO;EACP,UAAU,CAAC,UAAU;EACrB,SAAS;GACP,QAAQ;GACR,MAAM,GAAmC;IACvC,IAAMG,IAAOI,EAAOM,EAAI,IAAI;IAI5B,OAHKV,IAGE;KACL,SAAS,MAAM;MACb,IAAMO,IAAII,EAAE,MAAM,WAAWA,EAAE;MAC/B,EAAaX,GAAMO,EAAE,GAAGA,EAAE,CAAC;KAC7B;KACA,aAAa,CAAC;IAChB,IATkB,CAAC;GAUrB;EACF;CACF;AACF"}

package/dist/features/minimap/createMinimapContribution.js

@@ -0,0 +1,96 @@
+import { AUTO_POSE_DESCRIPTOR as e } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { FALLBACK_ACCENT as t, accentColorOf as n } from "../../canvas/accentColor.js";
+import { MINIMAP_CENTER as r, MINIMAP_PAN as i, minimapCenterAction as a, minimapPanAction as o } from "./actions.js";
+import { createIndicatorLayer as s, createLinkedCursorLayer as c } from "./layers.js";
+import { FALLBACK_FIT_VIEW as l, computeFitView as u } from "../../canvas/minimapMath.js";
+//#region src/features/minimap/createMinimapContribution.ts
+function d(e, r) {
+	let i = null, a = t, o = (e) => e !== null && r.some((t) => t !== e.viewId);
+	return {
+		layer: c({
+			id: e,
+			pointer: () => i,
+			color: () => a,
+			views: r
+		}),
+		attach: (e, t) => {
+			let r = t.get("pointer");
+			if (!r) return () => {};
+			a = n(e.element), i = r.get();
+			let s = r.subscribe(() => {
+				let t = i;
+				i = r.get(), (o(t) || o(i)) && e.requestRedraw();
+			});
+			return () => {
+				s(), i = null, e.requestRedraw();
+			};
+		}
+	};
+}
+function f(e = {}) {
+	let t = e.id ?? "linked-cursor", n = d(t, e.views ?? [null]);
+	return {
+		id: t,
+		eligibility: { always: !0 },
+		overlay: n.layer,
+		attach: n.attach
+	};
+}
+var p = "#18181c";
+function m(t) {
+	let n = t.id ?? "minimap", c = t.fit ?? "scene", f = null, m = null, h = (n, r) => {
+		let i = f?.get("scene");
+		if (!i) return l;
+		let a = typeof t.rect == "function" ? t.rect(n, r) : t.rect, o = i.getVersion();
+		if (m && m.scene === i && m.version === o && m.w === a.w && m.h === a.h) return m.view;
+		let s = f?.get("poseDescriptor") ?? e, d = u(i, {
+			width: a.w,
+			height: a.h
+		}, c, s);
+		return m = {
+			scene: i,
+			version: o,
+			w: a.w,
+			h: a.h,
+			view: d
+		}, d;
+	}, g = d(`${n}.cursor`, [null, n]), _ = s({
+		viewId: n,
+		root: () => f?.get("rootView"),
+		...t.indicatorStyle ? { style: t.indicatorStyle } : {}
+	});
+	return {
+		id: n,
+		eligibility: { always: !0 },
+		views: [{
+			id: n,
+			bounds: t.rect,
+			view: h,
+			interactive: !0,
+			background: t.background ?? p,
+			...t.layers ? { layers: t.layers } : {}
+		}],
+		actions: [a(), o()],
+		bindings: [{
+			spec: { kind: "pointerDown" },
+			actionId: r,
+			opts: { views: [n] }
+		}, {
+			spec: { kind: "drag" },
+			actionId: i,
+			opts: { views: [n] }
+		}],
+		overlay: [_, g.layer],
+		attach: (e, t) => {
+			f = t;
+			let n = g.attach(e, t);
+			return e.requestRedraw(), () => {
+				n(), f = null, m = null;
+			};
+		}
+	};
+}
+//#endregion
+export { f as createLinkedCursorContribution, m as createMinimapContribution };
+
+//# sourceMappingURL=createMinimapContribution.js.map

package/dist/features/minimap/createMinimapContribution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMinimapContribution.js","names":["linkedCursor","pointer","color","FALLBACK_ACCENT","visible","p","ownViews","v","createLinkedCursorLayer","store","deps","accentColorOf","api","off","prev","createLinkedCursorContribution","id","opts","cursor","DEFAULT_BACKGROUND","createMinimapContribution","fit","cached","fitCamera","scene","FALLBACK_FIT_VIEW","r","outer","dims","version","descriptor","AUTO_POSE_DESCRIPTOR","view","computeFitView","indicator","createIndicatorLayer","minimapCenterAction","minimapPanAction","MINIMAP_CENTER","MINIMAP_PAN","reader","detachCursor"],"sources":["../../../src/features/minimap/createMinimapContribution.ts"],"sourcesContent":["/**\n * A minimap over a `<SceneCanvas>`, written as one `SurfaceContribution`: a\n * view through a fit camera, the pan that moves the main camera from inside\n * it, the visible-rect indicator, and a linked crosshair.\n */\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { PointerWorldPos } from 'features/pointer/PointerContext';\nimport type { CanvasExtensionApi } from '../../canvas/canvasExtension';\nimport type { ViewRect } from '../../canvas/CanvasView';\nimport type { ContributionDepReader, SurfaceContribution } from '../../canvas/surfaceContribution';\nimport {\n  computeFitView, FALLBACK_FIT_VIEW, type IndicatorStyle, type MinimapFit,\n} from '../../canvas/minimapMath';\nimport {\n  MINIMAP_CENTER, MINIMAP_PAN, minimapCenterAction, minimapPanAction,\n} from './actions';\nimport { createIndicatorLayer, createLinkedCursorLayer } from './layers';\nimport { accentColorOf, FALLBACK_ACCENT } from '../../canvas/accentColor';\n\n\n/**\n * The linked crosshair's live half: follows the pointer store, and asks the\n * surface to repaint whenever the crosshair shows, moves, or has just hidden.\n * `ownViews` are the view ids this surface paints; the crosshair shows in any\n * of them the pointer is not over.\n */\nfunction linkedCursor(id: string, ownViews: readonly (string | null)[]) {\n  let pointer: PointerWorldPos = null;\n  let color = FALLBACK_ACCENT;\n  const visible = (p: PointerWorldPos): boolean =>\n    p !== null && ownViews.some((v) => v !== p.viewId);\n  const layer = createLinkedCursorLayer({ id, pointer: () => pointer, color: () => color, views: ownViews });\n  const attach = (api: CanvasExtensionApi, deps: ContributionDepReader): (() => void) => {\n    const store = deps.get('pointer');\n    if (!store) return () => {};\n    color = accentColorOf(api.element);\n    pointer = store.get();\n    const off = store.subscribe(() => {\n      const prev = pointer;\n      pointer = store.get();\n      if (visible(prev) || visible(pointer)) api.requestRedraw();\n    });\n    return () => {\n      off();\n      pointer = null;\n      api.requestRedraw();\n    };\n  };\n  return { layer, attach };\n}\n\n/** Options for {@link createLinkedCursorContribution}. */\nexport interface LinkedCursorOptions {\n  /** Entry id. Default `'linked-cursor'`. */\n  id?: string;\n  /** Views on this surface the crosshair may paint in. Default `[null]`, the\n   *  surface's own camera — the main canvas beside a detached minimap. */\n  views?: readonly (string | null)[];\n}\n\n/**\n * The linked crosshair alone: this surface paints the pointer's position\n * whenever the pointer is over some other view — another surface under the\n * same `<PointerContextProvider>`, such as a detached `<MinimapCanvas>`.\n *\n * A surface carrying `createMinimapContribution` already has one, in both its\n * views; this is for a surface without.\n */\nexport function createLinkedCursorContribution(opts: LinkedCursorOptions = {}): SurfaceContribution {\n  const id = opts.id ?? 'linked-cursor';\n  const cursor = linkedCursor(id, opts.views ?? [null]);\n  return { id, eligibility: { always: true }, overlay: cursor.layer, attach: cursor.attach };\n}\n\n/** Options for {@link createMinimapContribution}. */\nexport interface MinimapContributionOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {\n  /** View and entry id. Default `'minimap'`. */\n  id?: string;\n  /** Where the minimap paints, in CSS pixels from the canvas top-left. A\n   *  function is re-read every frame, so it can follow the canvas's size. */\n  rect: ViewRect | ((outer: View, dims: Dims) => ViewRect);\n  /** What the minimap frames. Default `'scene'`, the union of leaf poses. */\n  fit?: MinimapFit<TData, TLayer, TPose>;\n  /** The surface layers the minimap paints. Default: all of them. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  /** Ground painted before the minimap's layers, so the main canvas does not\n   *  show through. */\n  background?: string;\n  /** The visible-rect indicator's stroke. */\n  indicatorStyle?: IndicatorStyle;\n}\n\nconst DEFAULT_BACKGROUND = '#18181c';\n\n/**\n * A minimap inside a `<SceneCanvas>`, installed with one entry:\n *\n * ```tsx\n * const minimap = useMemo(() => createMinimapContribution({ rect: { x: 8, y: 8, w: 160, h: 110 } }), []);\n * <SceneCanvas ambient={[minimap]} … />\n * ```\n *\n * Press in it to center the main camera on that point, drag to keep it there.\n * It shows the main camera's visible rect, and a crosshair where the pointer is\n * over the other view. Build it once — each instance keeps the live state its\n * layers read.\n */\nexport function createMinimapContribution<TData = unknown, TLayer extends string = string, TPose = unknown>(\n  opts: MinimapContributionOptions<TData, TLayer, TPose>,\n): SurfaceContribution {\n  const id = opts.id ?? 'minimap';\n  const fit = (opts.fit ?? 'scene') as MinimapFit<unknown, string, unknown>;\n  let deps: ContributionDepReader | null = null;\n\n  // The fit follows the scene, so it is recomputed only when the scene's\n  // version or the minimap's size changes — it is read on every frame and\n  // every event.\n  let cached: { scene: unknown; version: number; w: number; h: number; view: View } | null = null;\n  const fitCamera = (outer: View, dims: Dims): View => {\n    const scene = deps?.get('scene') as Scene<unknown, string, unknown> | undefined;\n    if (!scene) return FALLBACK_FIT_VIEW;\n    const r = typeof opts.rect === 'function' ? opts.rect(outer, dims) : opts.rect;\n    const version = scene.getVersion();\n    if (cached && cached.scene === scene && cached.version === version && cached.w === r.w && cached.h === r.h) {\n      return cached.view;\n    }\n    const descriptor = (deps?.get('poseDescriptor') ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<unknown>;\n    const view = computeFitView(scene, { width: r.w, height: r.h }, fit, descriptor);\n    cached = { scene, version, w: r.w, h: r.h, view };\n    return view;\n  };\n\n  const cursor = linkedCursor(`${id}.cursor`, [null, id]);\n  const indicator = createIndicatorLayer({\n    viewId: id,\n    root: () => deps?.get('rootView'),\n    ...(opts.indicatorStyle ? { style: opts.indicatorStyle } : {}),\n  });\n\n  return {\n    id,\n    eligibility: { always: true },\n    views: [{\n      id,\n      bounds: opts.rect,\n      view: fitCamera,\n      interactive: true,\n      background: opts.background ?? DEFAULT_BACKGROUND,\n      ...(opts.layers ? { layers: opts.layers } : {}),\n    }],\n    actions: [minimapCenterAction(), minimapPanAction()],\n    bindings: [\n      { spec: { kind: 'pointerDown' }, actionId: MINIMAP_CENTER, opts: { views: [id] } },\n      { spec: { kind: 'drag' }, actionId: MINIMAP_PAN, opts: { views: [id] } },\n    ],\n    overlay: [indicator, cursor.layer],\n    attach: (api, reader) => {\n      deps = reader;\n      const detachCursor = cursor.attach(api, reader);\n      // The fit camera had no scene until now.\n      api.requestRedraw();\n      return () => {\n        detachCursor();\n        deps = null;\n        cached = null;\n      };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/features/minimap/layers.js

@@ -0,0 +1,103 @@
+//#region src/features/minimap/layers.ts
+function e(e) {
+	return e?.viewId ?? null;
+}
+function t(t) {
+	let { viewId: n, root: r, style: i = {} } = t;
+	return {
+		id: `${n}.indicator`,
+		label: "Minimap indicator",
+		draw: (t, a) => {
+			if (e(t) !== n) return [];
+			let o = r(), s = o?.hostSize?.();
+			if (!o || !s) return [];
+			let c = o.get(), l = 1 / a.scale.x;
+			return [{
+				kind: "path",
+				path: {
+					kind: "rect",
+					x: c.x,
+					y: c.y,
+					width: s.width / c.scale.x,
+					height: s.height / c.scale.y
+				},
+				stroke: {
+					paint: {
+						fill: "solid",
+						color: i.stroke ?? "#ffffff"
+					},
+					width: (i.width ?? 1) * l,
+					dash: (i.dash ?? [2, 3]).map((e) => e * l)
+				}
+			}];
+		}
+	};
+}
+var n = "rgba(0, 0, 0, 0.6)";
+function r(e, t, n) {
+	let r = n, i = 9 * r, a = 3 * r, o = 2 * r, s = 1 * r, c = [
+		{
+			x: e - a - i,
+			y: t - o / 2,
+			w: i,
+			h: o
+		},
+		{
+			x: e + a,
+			y: t - o / 2,
+			w: i,
+			h: o
+		},
+		{
+			x: e - o / 2,
+			y: t - a - i,
+			w: o,
+			h: i
+		},
+		{
+			x: e - o / 2,
+			y: t + a,
+			w: o,
+			h: i
+		}
+	];
+	return {
+		halo: c.map((e) => ({
+			x: e.x - s,
+			y: e.y - s,
+			w: e.w + 2 * s,
+			h: e.h + 2 * s
+		})),
+		bars: c
+	};
+}
+function i(t) {
+	let { id: i, pointer: a, color: o, views: s } = t;
+	return {
+		id: i,
+		label: "Linked cursor",
+		draw: (t, i) => {
+			let c = a(), l = e(t);
+			if (!c || c.viewId === l || s && !s.includes(l)) return [];
+			let { halo: u, bars: d } = r(c.worldX, c.worldY, 1 / i.scale.x), f = (e, t) => ({
+				kind: "path",
+				path: {
+					kind: "rect",
+					x: e.x,
+					y: e.y,
+					width: e.w,
+					height: e.h
+				},
+				fill: {
+					fill: "solid",
+					color: t
+				}
+			}), p = o();
+			return [...u.map((e) => f(e, n)), ...d.map((e) => f(e, p))];
+		}
+	};
+}
+//#endregion
+export { n as CROSSHAIR_HALO, t as createIndicatorLayer, i as createLinkedCursorLayer, r as crosshairRects };
+
+//# sourceMappingURL=layers.js.map

package/dist/features/minimap/layers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layers.js","names":["viewIdOf","data","createIndicatorLayer","opts","viewId","r","root","size","v","px","view","style","d","CROSSHAIR_HALO","crosshairRects","k","unitsPerPx","arm","gap","t","h","bars","x","y","b","createLinkedCursorLayer","p","pointer","here","views","rect","c","accent","color","halo"],"sources":["../../../src/features/minimap/layers.ts"],"sourcesContent":["/**\n * The minimap's chrome: the main camera's visible rect, drawn in the minimap,\n * and the linked crosshair, drawn in every view the pointer is not over.\n */\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '../../renderer/DrawCommand';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport type { PointerWorldPos } from 'features/pointer/PointerContext';\nimport type { IndicatorStyle } from '../../canvas/minimapMath';\n\n/** What a layer's `data` carries for this feature: the view it draws for. */\nfunction viewIdOf(data: unknown): string | null {\n  return (data as { viewId?: string | null } | null)?.viewId ?? null;\n}\n\n/**\n * The main camera's visible world rect, painted only in view `viewId`. Its\n * stroke and dash are screen pixels whatever the minimap's scale.\n */\nexport function createIndicatorLayer(opts: {\n  viewId: string;\n  root: () => ViewApi | undefined;\n  style?: IndicatorStyle;\n}): RenderLayer<unknown> {\n  const { viewId, root, style = {} } = opts;\n  return {\n    id: `${viewId}.indicator`,\n    label: 'Minimap indicator',\n    draw: (data, view: View): DrawCommand[] => {\n      if (viewIdOf(data) !== viewId) return [];\n      const r = root();\n      const size = r?.hostSize?.();\n      if (!r || !size) return [];\n      const v = r.get();\n      const px = 1 / view.scale.x;\n      return [{\n        kind: 'path',\n        path: { kind: 'rect', x: v.x, y: v.y, width: size.width / v.scale.x, height: size.height / v.scale.y },\n        stroke: {\n          paint: { fill: 'solid', color: style.stroke ?? '#ffffff' },\n          width: (style.width ?? 1) * px,\n          dash: (style.dash ?? [2, 3]).map((d) => d * px),\n        },\n      }];\n    },\n  };\n}\n\n/** Screen-pixel geometry of the crosshair: arm length, the gap at its center,\n *  line thickness, and the dark halo that keeps it legible over any content. */\nconst ARM = 9;\nconst GAP = 3;\nconst THICK = 2;\nconst HALO = 1;\n/** The halo's color: dark enough to separate the accent from any content. */\nexport const CROSSHAIR_HALO = 'rgba(0, 0, 0, 0.6)';\n\n/** An axis-aligned rect, `{ x, y, w, h }`. */\nexport interface CrosshairRect { x: number; y: number; w: number; h: number }\n\n/**\n * The linked crosshair at (`x`, `y`) as rects in the caller's units, where one\n * screen pixel is `unitsPerPx` of them: four halo rects to paint first, then\n * four bars. A painter with no weasel renderer — a 2D canvas — draws the same\n * crosshair from these.\n */\nexport function crosshairRects(\n  x: number, y: number, unitsPerPx: number,\n): { halo: CrosshairRect[]; bars: CrosshairRect[] } {\n  const k = unitsPerPx;\n  const arm = ARM * k, gap = GAP * k, t = THICK * k, h = HALO * k;\n  const bars: CrosshairRect[] = [\n    { x: x - gap - arm, y: y - t / 2, w: arm, h: t },\n    { x: x + gap, y: y - t / 2, w: arm, h: t },\n    { x: x - t / 2, y: y - gap - arm, w: t, h: arm },\n    { x: x - t / 2, y: y + gap, w: t, h: arm },\n  ];\n  const halo = bars.map((b) => ({ x: b.x - h, y: b.y - h, w: b.w + 2 * h, h: b.h + 2 * h }));\n  return { halo, bars };\n}\n\n/**\n * A crosshair at the pointer's world point, in each of `views` the pointer is\n * not over — the other side of a linked cursor. A fixed screen size in every\n * view. `views` omitted paints in every view.\n */\nexport function createLinkedCursorLayer(opts: {\n  id: string;\n  pointer: () => PointerWorldPos;\n  color: () => string;\n  views?: readonly (string | null)[];\n}): RenderLayer<unknown> {\n  const { id, pointer, color, views } = opts;\n  return {\n    id,\n    label: 'Linked cursor',\n    draw: (data, view: View): DrawCommand[] => {\n      const p = pointer();\n      const here = viewIdOf(data);\n      if (!p || p.viewId === here || (views && !views.includes(here))) return [];\n      const { halo, bars } = crosshairRects(p.worldX, p.worldY, 1 / view.scale.x);\n      const rect = (r: CrosshairRect, c: string): DrawCommand => ({\n        kind: 'path',\n        path: { kind: 'rect', x: r.x, y: r.y, width: r.w, height: r.h },\n        fill: { fill: 'solid', color: c },\n      });\n      const accent = color();\n      return [\n        ...halo.map((r) => rect(r, CROSSHAIR_HALO)),\n        ...bars.map((r) => rect(r, accent)),\n      ];\n    },\n  };\n}\n"],"mappings":";AAYA,SAASA,EAAS,GAA8B;CAC9C,OAAQC,GAA4C,UAAU;AAChE;AAMA,SAAgBC,EAAqB,GAIZ;CACvB,IAAM,EAAE,WAAQ,SAAM,WAAQ,CAAC,MAAMC;CACrC,OAAO;EACL,IAAI,GAAGC,EAAO;EACd,OAAO;EACP,OAAO,GAAM,MAA8B;GACzC,IAAIJ,EAASC,CAAI,MAAMG,GAAQ,OAAO,CAAC;GACvC,IAAMC,IAAIC,EAAK,GACTC,IAAOF,GAAG,WAAW;GAC3B,IAAI,CAACA,KAAK,CAACE,GAAM,OAAO,CAAC;GACzB,IAAMC,IAAIH,EAAE,IAAI,GACVI,IAAK,IAAIC,EAAK,MAAM;GAC1B,OAAO,CAAC;IACN,MAAM;IACN,MAAM;KAAE,MAAM;KAAQ,GAAGF,EAAE;KAAG,GAAGA,EAAE;KAAG,OAAOD,EAAK,QAAQC,EAAE,MAAM;KAAG,QAAQD,EAAK,SAASC,EAAE,MAAM;IAAE;IACrG,QAAQ;KACN,OAAO;MAAE,MAAM;MAAS,OAAOG,EAAM,UAAU;KAAU;KACzD,QAAQA,EAAM,SAAS,KAAKF;KAC5B,OAAOE,EAAM,QAAQ,CAAC,GAAG,CAAC,EAAA,CAAG,KAAK,MAAMC,IAAIH,CAAE;IAChD;GACF,CAAC;EACH;CACF;AACF;AAIA,IAKaI,IAAiB;AAW9B,SAAgBC,EACd,GAAW,GAAW,GAC4B;CAClD,IAAMC,IAAIC,GACJC,IAAM,IAAMF,GAAGG,IAAM,IAAMH,GAAGI,IAAI,IAAQJ,GAAGK,IAAI,IAAOL,GACxDM,IAAwB;EAC5B;GAAE,GAAGC,IAAIJ,IAAMD;GAAK,GAAGM,IAAIJ,IAAI;GAAG,GAAGF;GAAK,GAAGE;EAAE;EAC/C;GAAE,GAAGG,IAAIJ;GAAK,GAAGK,IAAIJ,IAAI;GAAG,GAAGF;GAAK,GAAGE;EAAE;EACzC;GAAE,GAAGG,IAAIH,IAAI;GAAG,GAAGI,IAAIL,IAAMD;GAAK,GAAGE;GAAG,GAAGF;EAAI;EAC/C;GAAE,GAAGK,IAAIH,IAAI;GAAG,GAAGI,IAAIL;GAAK,GAAGC;GAAG,GAAGF;EAAI;CAC3C;CAEA,OAAO;EAAE,MADII,EAAK,KAAK,OAAO;GAAE,GAAGG,EAAE,IAAIJ;GAAG,GAAGI,EAAE,IAAIJ;GAAG,GAAGI,EAAE,IAAI,IAAIJ;GAAG,GAAGI,EAAE,IAAI,IAAIJ;EAAE,EAC9E;EAAM;CAAK;AACtB;AAOA,SAAgBK,EAAwB,GAKf;CACvB,IAAM,EAAE,OAAI,YAAS,UAAO,aAAUtB;CACtC,OAAO;EACL;EACA,OAAO;EACP,OAAO,GAAM,MAA8B;GACzC,IAAMuB,IAAIC,EAAQ,GACZC,IAAO5B,EAASC,CAAI;GAC1B,IAAI,CAACyB,KAAKA,EAAE,WAAWE,KAASC,KAAS,CAACA,EAAM,SAASD,CAAI,GAAI,OAAO,CAAC;GACzE,IAAM,EAAE,SAAM,YAASd,EAAeY,EAAE,QAAQA,EAAE,QAAQ,IAAIhB,EAAK,MAAM,CAAC,GACpEoB,KAAQ,GAAkB,OAA4B;IAC1D,MAAM;IACN,MAAM;KAAE,MAAM;KAAQ,GAAGzB,EAAE;KAAG,GAAGA,EAAE;KAAG,OAAOA,EAAE;KAAG,QAAQA,EAAE;IAAE;IAC9D,MAAM;KAAE,MAAM;KAAS,OAAO0B;IAAE;GAClC,IACMC,IAASC,EAAM;GACrB,OAAO,CACL,GAAGC,EAAK,KAAK,MAAMJ,EAAKzB,GAAGQ,CAAc,CAAC,GAC1C,GAAGQ,EAAK,KAAK,MAAMS,EAAKzB,GAAG2B,CAAM,CAAC,CACpC;EACF;CACF;AACF"}

package/dist/features/modes/modeLayers.js

@@ -0,0 +1,113 @@
+import { viewToTransform as e } from "../../core/viewport/view.js";
+import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
+//#region src/features/modes/modeLayers.ts
+var n = .12;
+function r(r) {
+	let { registry: i } = r;
+	return {
+		id: r.id ?? "mode-tint",
+		label: r.label ?? "Mode tint",
+		space: "screen",
+		subscribe: i.subscribe,
+		draw: (a, o, s) => {
+			let c = i.current().workspace, l = c?.tint;
+			if (!l || l === "transparent") return [];
+			let u = r.intensity ?? c.intensity ?? n, { width: d, height: f } = s, p = (e, t, n, r, i, a) => ({
+				kind: "path",
+				path: {
+					kind: "rect",
+					x: e,
+					y: t,
+					width: n,
+					height: r
+				},
+				fill: c.gradient ? {
+					fill: "linear-gradient",
+					from: i,
+					to: a,
+					stops: [{
+						offset: 0,
+						color: l
+					}, {
+						offset: 1,
+						color: "transparent"
+					}],
+					opacity: u
+				} : {
+					fill: "solid",
+					color: l,
+					opacity: u
+				}
+			}), m = () => [c.gradient === "top-down" ? p(0, 0, d, f, {
+				x: 0,
+				y: 0
+			}, {
+				x: 0,
+				y: f
+			}) : p(0, 0, d, f, {
+				x: 0,
+				y: f
+			}, {
+				x: 0,
+				y: 0
+			})], h = r.page?.();
+			if (!h) return m();
+			let g = e(o), [_, v] = t(h.x, h.y, g), [y, b] = t(h.x + h.width, h.y + h.height, g), x = Math.max(0, Math.min(_, y)), S = Math.max(0, Math.min(v, b)), C = Math.min(d, Math.max(_, y)), w = Math.min(f, Math.max(v, b));
+			if (C <= x || w <= S) return [{
+				kind: "path",
+				path: {
+					kind: "rect",
+					x: 0,
+					y: 0,
+					width: d,
+					height: f
+				},
+				fill: {
+					fill: "solid",
+					color: l,
+					opacity: u
+				}
+			}];
+			let T = [], E = (e, t, n, r, i, a) => {
+				n > 0 && r > 0 && T.push(p(e, t, n, r, i, a));
+			};
+			return E(0, 0, d, S, {
+				x: 0,
+				y: 0
+			}, {
+				x: 0,
+				y: S
+			}), E(0, w, d, f - w, {
+				x: 0,
+				y: f
+			}, {
+				x: 0,
+				y: w
+			}), E(0, S, x, w - S, {
+				x: 0,
+				y: 0
+			}, {
+				x,
+				y: 0
+			}), E(C, S, d - C, w - S, {
+				x: d,
+				y: 0
+			}, {
+				x: C,
+				y: 0
+			}), T;
+		}
+	};
+}
+function i(e, t = {}) {
+	return {
+		id: t.id ?? "mode-decorations",
+		label: t.label ?? "Mode decorations",
+		subscribe: e.subscribe,
+		draw: () => e.paint()
+	};
+}
+//#endregion
+export { i as modeDecorationLayer, r as workspaceTintLayer };
+
+//# sourceMappingURL=modeLayers.js.map

package/dist/features/modes/modeLayers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeLayers.js","names":["DEFAULT_INTENSITY","workspaceTintLayer","opts","registry","ws","tint","opacity","W","H","dims","strip","whole","page","t","viewToTransform","view","sx0","sy0","worldToScreen","sx1","sy1","pl","pt","pr","pb","cmds","push","w","h","x","y","from","to","modeDecorationLayer","decorations"],"sources":["../../../src/features/modes/modeLayers.ts"],"sourcesContent":["import type { Rect } from '@weasel-js/geom';\nimport type { ModeDecorations, ModeRegistry } from '@weasel-js/modes';\nimport type { DrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\n\n/** Options for {@link workspaceTintLayer}. */\nexport interface WorkspaceTintLayerOptions {\n  registry: ModeRegistry;\n  /** The page, in world coordinates. When given, the tint covers only the\n   *  workspace around it, each strip fading toward the page edge if the mode\n   *  names a gradient. Without it the tint covers the whole canvas. */\n  page?: () => Rect | null;\n  /** Opacity for every mode's tint, in place of its `workspace.intensity`. */\n  intensity?: number;\n  id?: string;\n  label?: string;\n}\n\nconst DEFAULT_INTENSITY = 0.12;\n\n/**\n * A screen-space layer painting the active mode's `WorkspaceVisual`: nothing in\n * a mode without a tint, otherwise a wash at the mode's intensity, bottom-up or\n * top-down when the mode names a gradient. It subscribes to the registry, so a\n * mode switch repaints it.\n */\nexport function workspaceTintLayer(opts: WorkspaceTintLayerOptions): RenderLayer<unknown> {\n  const { registry } = opts;\n  return {\n    id: opts.id ?? 'mode-tint',\n    label: opts.label ?? 'Mode tint',\n    space: 'screen',\n    subscribe: registry.subscribe,\n    draw: (_data, view, dims) => {\n      const ws = registry.current().workspace;\n      const tint = ws?.tint;\n      if (!tint || tint === 'transparent') return [];\n      const opacity = opts.intensity ?? ws.intensity ?? DEFAULT_INTENSITY;\n      const { width: W, height: H } = dims;\n\n      const strip = (\n        x: number, y: number, width: number, height: number,\n        from: { x: number; y: number }, to: { x: number; y: number },\n      ): DrawCommand => ({\n        kind: 'path',\n        path: { kind: 'rect', x, y, width, height },\n        fill: ws.gradient\n          ? { fill: 'linear-gradient', from, to, stops: [{ offset: 0, color: tint }, { offset: 1, color: 'transparent' }], opacity }\n          : { fill: 'solid', color: tint, opacity },\n      });\n\n      const whole = (): DrawCommand[] => [\n        ws.gradient === 'top-down'\n          ? strip(0, 0, W, H, { x: 0, y: 0 }, { x: 0, y: H })\n          : strip(0, 0, W, H, { x: 0, y: H }, { x: 0, y: 0 }),\n      ];\n\n      const page = opts.page?.();\n      if (!page) return whole();\n\n      const t = viewToTransform(view);\n      const [sx0, sy0] = worldToScreen(page.x, page.y, t);\n      const [sx1, sy1] = worldToScreen(page.x + page.width, page.y + page.height, t);\n      const pl = Math.max(0, Math.min(sx0, sx1));\n      const pt = Math.max(0, Math.min(sy0, sy1));\n      const pr = Math.min(W, Math.max(sx0, sx1));\n      const pb = Math.min(H, Math.max(sy0, sy1));\n      if (pr <= pl || pb <= pt) {\n        return [{ kind: 'path', path: { kind: 'rect', x: 0, y: 0, width: W, height: H }, fill: { fill: 'solid', color: tint, opacity } }];\n      }\n\n      const cmds: DrawCommand[] = [];\n      const push = (\n        x: number, y: number, w: number, h: number,\n        from: { x: number; y: number }, to: { x: number; y: number },\n      ): void => { if (w > 0 && h > 0) cmds.push(strip(x, y, w, h, from, to)); };\n      push(0, 0, W, pt, { x: 0, y: 0 }, { x: 0, y: pt });\n      push(0, pb, W, H - pb, { x: 0, y: H }, { x: 0, y: pb });\n      push(0, pt, pl, pb - pt, { x: 0, y: 0 }, { x: pl, y: 0 });\n      push(pr, pt, W - pr, pb - pt, { x: W, y: 0 }, { x: pr, y: 0 });\n      return cmds;\n    },\n  };\n}\n\n/** A world-space layer drawing a `ModeDecorations`' active painter. It\n *  subscribes to the decorations, so a mode switch or a new painter repaints\n *  it. */\nexport function modeDecorationLayer(\n  decorations: ModeDecorations,\n  opts: { id?: string; label?: string } = {},\n): RenderLayer<unknown> {\n  return {\n    id: opts.id ?? 'mode-decorations',\n    label: opts.label ?? 'Mode decorations',\n    subscribe: decorations.subscribe,\n    draw: () => decorations.paint() as DrawCommand[],\n  };\n}\n"],"mappings":"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"}

package/dist/features/overlays/useNodeOverlayFrame.js

@@ -0,0 +1,103 @@
+import { useCanvasSize as e } from "../../core/viewport/useCanvasSize.js";
+import { composeWorldPose as t } from "../../core/scene/composeFrame.js";
+import { composeRectPose as n } from "../groups/composePose.js";
+import { effectivePose as r } from "../../core/scene/effectivePose.js";
+import { poseRotationOf as i } from "../../core/geometry/poseRotation.js";
+import { applyToPoint as a, invert as o, multiply as s } from "@weasel-js/geom";
+import { useCallback as c, useInsertionEffect as l, useRef as u } from "react";
+//#region src/features/overlays/useNodeOverlayFrame.ts
+function d(t, n, r, i = {}) {
+	let { width: d, height: g } = e(n), { view: _, compose: v } = i, y = c(() => {
+		let e = p(t, r, v);
+		return e ? s(m(f(_)), h(e)) : null;
+	}, [
+		t,
+		r,
+		v,
+		_
+	]), b = c((e) => {
+		let t = y();
+		if (!t) return e;
+		let [n, r] = a(t, e.x, e.y);
+		return {
+			x: n,
+			y: r
+		};
+	}, [y]), x = u(null), S = c((e) => {
+		let t = y(), n = t && o(t);
+		n && (x.current = n);
+		let [r, i] = a(n ?? x.current, e.x, e.y);
+		return {
+			x: r,
+			y: i
+		};
+	}, [y]), C = p(t, r, v), w = C && d !== 0 && g !== 0 ? y() : null, T = w && o(w);
+	return l(() => {
+		T && (x.current = T);
+	}), !C || !T ? null : {
+		box: {
+			x: C.x,
+			y: C.y,
+			width: C.width,
+			height: C.height
+		},
+		toScreen: b,
+		toLocal: S,
+		width: d,
+		height: g
+	};
+}
+function f(e) {
+	return typeof e == "function" ? e() : e;
+}
+function p(e, i, a) {
+	if (i == null) return null;
+	let o = e.nodes;
+	return o.has(i) ? t({
+		getPose: (t) => r(e, o.get(t)),
+		getParent: (e) => o.get(e)?.parent ?? null
+	}, i, a ?? n) : null;
+}
+function m(e) {
+	if (!e) return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	let { x: t, y: n } = e.scale;
+	return [
+		t,
+		0,
+		0,
+		n,
+		-e.x * t,
+		-e.y * n
+	];
+}
+function h(e) {
+	let t = i(e);
+	if (!t) return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	let n = Math.cos(t.rotation), r = Math.sin(t.rotation);
+	return [
+		n,
+		r,
+		-r,
+		n,
+		t.cx - t.cx * n + t.cy * r,
+		t.cy - t.cx * r - t.cy * n
+	];
+}
+//#endregion
+export { d as useNodeOverlayFrame };
+
+//# sourceMappingURL=useNodeOverlayFrame.js.map