@weasel-js/core 1.7.0 → 1.7.2

package/dist/features/patterns/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createTilePattern","off","opts","c","oc","bitmap","registerTexture"],"sources":["../../../src/features/patterns/index.ts"],"sourcesContent":["/**\n * Tile-pattern primitive — a small helper for building repeating texture\n * tiles from a draw callback. The result plugs into a `FillStyle` of\n * `{ fill: 'pattern', pattern }` (see `@weasel-js/paint`).\n *\n * GL-backed: the tile is rendered to an `OffscreenCanvas` (with a 2D fallback\n * to a regular `<canvas>` for environments without `OffscreenCanvas`),\n * converted to an `ImageBitmap`, and registered with `registerTexture()`.\n * The returned `TextureHandle` is what `FillStyle.pattern` accepts.\n *\n * For ready-to-use named patterns (hatch, crosshatch, dots, chunks),\n * see the `@weasel-js/core/patterns-builtin` subpath.\n */\n\nimport { registerTexture } from '../../renderer/textures/registerTexture';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\n\n/** Options for `createTilePattern`. */\nexport interface TilePatternOpts {\n  /** Edge length (in pixels) of the square offscreen tile. */\n  size: number;\n  /** FillStyle one tile at integer-pixel coordinates `(0, 0) .. (size, size)`. */\n  draw: (oc: CanvasRenderingContext2D, size: number) => void;\n}\n\n/**\n * Render a single tile to an offscreen canvas and register it as a GL\n * texture, returning a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }`. Returns `null` only when an\n * `OffscreenCanvas`/2D context can't be acquired (very rare; same fallback\n * semantics as the prior `CanvasPattern`-based implementation).\n */\nexport function createTilePattern(opts: TilePatternOpts): TextureHandle | null {\n  // Prefer OffscreenCanvas; fall back to <canvas> for environments without it\n  // (tests in jsdom may need that fallback — try OffscreenCanvas first).\n  let off: OffscreenCanvas | HTMLCanvasElement;\n  try {\n    off = new OffscreenCanvas(opts.size, opts.size);\n  } catch {\n    if (typeof document === 'undefined') return null;\n    const c = document.createElement('canvas');\n    c.width = opts.size;\n    c.height = opts.size;\n    off = c;\n  }\n  const oc = off.getContext('2d') as CanvasRenderingContext2D | null;\n  if (!oc) return null;\n  opts.draw(oc, opts.size);\n\n  // Convert to ImageBitmap so registerTexture can store it.\n  // OffscreenCanvas.transferToImageBitmap() is the fast path; the\n  // synchronous path requires OffscreenCanvas. If we got here without it,\n  // the env doesn't support OffscreenCanvas — fail gracefully.\n  let bitmap: ImageBitmap;\n  if (typeof (off as OffscreenCanvas).transferToImageBitmap === 'function') {\n    bitmap = (off as OffscreenCanvas).transferToImageBitmap();\n  } else {\n    return null;\n  }\n  return registerTexture(bitmap);\n}\n"],"mappings":";;AAgCA,SAAgBA,EAAkB,GAA6C;CAG7E,IAAIC;CACJ,IAAI;EACF,IAAM,IAAI,gBAAgBC,EAAK,MAAMA,EAAK,IAAI;CAChD,QAAQ;EACN,IAAI,OAAO,WAAa,KAAa,OAAO;EAC5C,IAAMC,IAAI,SAAS,cAAc,QAAQ;EAGzC,AAFA,EAAE,QAAQD,EAAK,MACf,EAAE,SAASA,EAAK,MAChB,IAAMC;CACR;CACA,IAAMC,IAAKH,EAAI,WAAW,IAAI;CAC9B,IAAI,CAACG,GAAI,OAAO;CAChB,EAAK,KAAKA,GAAIF,EAAK,IAAI;CAMvB,IAAIG;CACJ,IAAI,OAAQJ,EAAwB,yBAA0B,YAC5D,IAAUA,EAAwB,sBAAsB;MAExD,OAAO;CAET,OAAOK,EAAgBD,CAAM;AAC/B"}

package/dist/features/patterns/patterns-builtin.js

@@ -0,0 +1,38 @@
+import { drawTileShapes as e, tileGeometry as t, tileSize as n } from "./tileGeometry.js";
+import { createTilePattern as r } from "./index.js";
+//#region src/features/patterns/patterns-builtin.ts
+function i(i) {
+	let a = t(i);
+	return r({
+		size: n(i),
+		draw: (t) => e(t, a)
+	});
+}
+function a(e) {
+	return i({
+		tile: "hatch",
+		...e
+	});
+}
+function o(e) {
+	return i({
+		tile: "crosshatch",
+		...e
+	});
+}
+function s(e) {
+	return i({
+		tile: "dots",
+		...e
+	});
+}
+function c(e) {
+	return i({
+		tile: "chunks",
+		...e
+	});
+}
+//#endregion
+export { c as chunks, o as crosshatch, s as dots, e as drawTileShapes, a as hatch, t as tileGeometry, n as tileSize };
+
+//# sourceMappingURL=patterns-builtin.js.map

package/dist/features/patterns/patterns-builtin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns-builtin.js","names":["build","geometry","tileGeometry","spec","createTilePattern","tileSize","drawTileShapes","oc","hatch","params","crosshatch","dots","chunks"],"sources":["../../../src/features/patterns/patterns-builtin.ts"],"sourcesContent":["/**\n * Built-in pattern factories — generic line/dot/scatter textures. Each\n * returns a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }` and pass to anything that accepts a `FillStyle`\n * (`FillStyle`-aware layers, path fills, etc.).\n * Imported from a subpath so consumers that ship their own catalog can\n * avoid the bundle cost.\n *\n * All factories require an explicit `color` (and `bg` for `chunks`). No\n * defaults are baked in — the caller's design system is the source of truth\n * for palette decisions.\n *\n * Each is a thin wrapper over `tileGeometry`, which describes the tile as\n * shapes so `@weasel-js/svg` can emit the same tile as a `<pattern>`.\n * Prefer naming a tile in a `TilePatternSpec` over calling these directly —\n * a spec serializes, a `TextureHandle` does not.\n */\n\nexport { tileGeometry, tileSize, drawTileShapes } from './tileGeometry';\nexport type { TileShape, TileGeometry } from './tileGeometry';\n\nimport { createTilePattern } from '.';\nimport { tileGeometry, drawTileShapes, tileSize } from './tileGeometry';\nimport type { TilePatternSpec } from '@weasel-js/paint';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\n\nfunction build(spec: TilePatternSpec): TextureHandle | null {\n  const geometry = tileGeometry(spec);\n  return createTilePattern({\n    size: tileSize(spec),\n    draw: (oc) => drawTileShapes(oc, geometry),\n  });\n}\n\n/** Diagonal hatch (forward slash). */\nexport interface HatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a diagonal-hatch pattern texture. */\nexport function hatch(params: HatchParams): TextureHandle | null {\n  return build({ tile: 'hatch', ...params });\n}\n\n/** Diagonal hatch in both directions. */\nexport interface CrosshatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a crosshatch pattern texture. */\nexport function crosshatch(params: CrosshatchParams): TextureHandle | null {\n  return build({ tile: 'crosshatch', ...params });\n}\n\n/** Regular grid of filled dots. */\nexport interface DotsParams {\n  color: string;\n  size?: number;\n  radius?: number;\n}\n\n/** Build a dot-grid pattern texture. */\nexport function dots(params: DotsParams): TextureHandle | null {\n  return build({ tile: 'dots', ...params });\n}\n\n/**\n * Random scatter of small ellipses on top of a solid background. Driven by a\n * seeded PRNG so the same `seed` produces a deterministic tile.\n *\n * Note: the `bg` field is optional — omit it for a transparent background\n * (the scatter shapes draw directly onto whatever sits beneath the overlay).\n */\nexport interface ChunksParams {\n  color: string;\n  bg?: string;\n  size?: number;\n  /** Coverage: `chunks * chunkSize²` per `size²` tile. Range ~[0, 1]. */\n  density?: number;\n  chunkSize?: number;\n  seed?: number;\n}\n\n/** Build a seeded random-scatter pattern texture. */\nexport function chunks(params: ChunksParams): TextureHandle | null {\n  return build({ tile: 'chunks', ...params });\n}\n"],"mappings":";;;AA0BA,SAASA,EAAM,GAA6C;CAC1D,IAAMC,IAAWC,EAAaC,CAAI;CAClC,OAAOC,EAAkB;EACvB,MAAMC,EAASF,CAAI;EACnB,OAAO,MAAOG,EAAeC,GAAIN,CAAQ;CAC3C,CAAC;AACH;AAUA,SAAgBO,EAAM,GAA2C;CAC/D,OAAOR,EAAM;EAAE,MAAM;EAAS,GAAGS;CAAO,CAAC;AAC3C;AAUA,SAAgBC,EAAW,GAAgD;CACzE,OAAOV,EAAM;EAAE,MAAM;EAAc,GAAGS;CAAO,CAAC;AAChD;AAUA,SAAgBE,EAAK,GAA0C;CAC7D,OAAOX,EAAM;EAAE,MAAM;EAAQ,GAAGS;CAAO,CAAC;AAC1C;AAoBA,SAAgBG,EAAO,GAA4C;CACjE,OAAOZ,EAAM;EAAE,MAAM;EAAU,GAAGS;CAAO,CAAC;AAC5C"}

package/dist/features/patterns/resolveSpec.js

@@ -0,0 +1,57 @@
+import { chunks as e, crosshatch as t, dots as n, hatch as r } from "./patterns-builtin.js";
+//#region src/features/patterns/resolveSpec.ts
+var i = /* @__PURE__ */ new Map();
+function a(e) {
+	let t = Object.keys(e).sort(), n = e;
+	return t.map((e) => `${e}=${String(n[e])}`).join("&");
+}
+function o(e) {
+	let t = a(e), n = i.get(t);
+	if (n !== void 0) return n;
+	let r = s(e);
+	return i.set(t, r), r;
+}
+function s(i) {
+	let { color: a, size: o } = i;
+	switch (i.tile) {
+		case "hatch": return r({
+			color: a,
+			size: o,
+			lineWidth: i.lineWidth
+		});
+		case "crosshatch": return t({
+			color: a,
+			size: o,
+			lineWidth: i.lineWidth
+		});
+		case "dots": return n({
+			color: a,
+			size: o,
+			radius: i.radius
+		});
+		case "chunks": return e({
+			color: a,
+			size: o,
+			bg: i.bg,
+			density: i.density,
+			chunkSize: i.chunkSize,
+			seed: i.seed
+		});
+		default: return null;
+	}
+}
+function c(e) {
+	return "tile" in e;
+}
+function l(e) {
+	if (e.fill !== "pattern" || !c(e.pattern)) return e;
+	let t = o(e.pattern);
+	return t ? {
+		...e,
+		pattern: t
+	} : null;
+}
+//#endregion
+export { c as isPatternSpec, l as resolveFillPattern, o as resolvePatternSpec };
+
+//# sourceMappingURL=resolveSpec.js.map

package/dist/features/patterns/resolveSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveSpec.js","names":["cache","specKey","keys","spec","bag","k","resolvePatternSpec","key","hit","built","buildTile","hatch","crosshatch","dots","chunks","isPatternSpec","payload","resolveFillPattern","fill","handle"],"sources":["../../../src/features/patterns/resolveSpec.ts"],"sourcesContent":["/**\n * `TilePatternSpec` → `TextureHandle`. The bridge between the serializable\n * half of a pattern paint and the GL texture that paints it.\n *\n * Memoized on the spec's field values, so identical specs across nodes share\n * one texture and a re-render never re-rasterizes. Entries live for the\n * session, matching `registerTexture`'s own lifetime.\n */\n\nimport type { FillStyle, TilePatternSpec } from '@weasel-js/paint';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\nimport { hatch, crosshatch, dots, chunks } from './patterns-builtin';\n\nconst cache = new Map<string, TextureHandle | null>();\n\n/** Stable key across key order — specs arriving from JSON have no guaranteed\n *  field order, and two orderings must not rasterize two tiles. */\nfunction specKey(spec: TilePatternSpec): string {\n  const keys = Object.keys(spec).sort();\n  const bag = spec as unknown as Record<string, unknown>;\n  return keys.map((k) => `${k}=${String(bag[k])}`).join('&');\n}\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetPatternSpecCacheForTests(): void {\n  cache.clear();\n}\n\n/**\n * Build (or fetch) the texture for a spec. Returns `null` when the tile\n * can't be rasterized — no `OffscreenCanvas`, same as `createTilePattern`.\n */\nexport function resolvePatternSpec(spec: TilePatternSpec): TextureHandle | null {\n  const key = specKey(spec);\n  const hit = cache.get(key);\n  if (hit !== undefined) return hit;\n\n  const built = buildTile(spec);\n  cache.set(key, built);\n  return built;\n}\n\nfunction buildTile(spec: TilePatternSpec): TextureHandle | null {\n  const { color, size } = spec;\n  switch (spec.tile) {\n    case 'hatch':\n      return hatch({ color, size, lineWidth: spec.lineWidth });\n    case 'crosshatch':\n      return crosshatch({ color, size, lineWidth: spec.lineWidth });\n    case 'dots':\n      return dots({ color, size, radius: spec.radius });\n    case 'chunks':\n      return chunks({\n        color, size, bg: spec.bg,\n        density: spec.density, chunkSize: spec.chunkSize, seed: spec.seed,\n      });\n    default:\n      return null;\n  }\n}\n\n/** Whether a pattern payload is a spec rather than an already-built handle. */\nexport function isPatternSpec(\n  payload: TextureHandle | TilePatternSpec,\n): payload is TilePatternSpec {\n  return 'tile' in payload;\n}\n\n/**\n * Swap a pattern paint's spec payload for the texture that paints it,\n * leaving every other fill untouched. The built-in painters run this\n * alongside `fillInPoseFrame`; a consumer emitting its own draw commands\n * runs it at the same place it runs that one.\n *\n * A spec that can't rasterize drops the fill rather than painting garbage.\n */\nexport function resolveFillPattern(fill: FillStyle): FillStyle | null {\n  if (fill.fill !== 'pattern') return fill;\n  if (!isPatternSpec(fill.pattern)) return fill;\n  const handle = resolvePatternSpec(fill.pattern);\n  return handle ? { ...fill, pattern: handle } : null;\n}\n"],"mappings":";;AAaA,IAAMA,oBAAQ,IAAI,IAAkC;AAIpD,SAASC,EAAQ,GAA+B;CAC9C,IAAMC,IAAO,OAAO,KAAKC,CAAI,CAAC,CAAC,KAAK,GAC9BC,IAAMD;CACZ,OAAOD,EAAK,KAAK,MAAM,GAAGG,EAAE,GAAG,OAAOD,EAAIC,EAAE,GAAG,CAAC,CAAC,KAAK,GAAG;AAC3D;AAWA,SAAgBC,EAAmB,GAA6C;CAC9E,IAAMC,IAAMN,EAAQE,CAAI,GAClBK,IAAMR,EAAM,IAAIO,CAAG;CACzB,IAAIC,MAAQ,KAAA,GAAW,OAAOA;CAE9B,IAAMC,IAAQC,EAAUP,CAAI;CAE5B,OADAH,EAAM,IAAIO,GAAKE,CAAK,GACbA;AACT;AAEA,SAASC,EAAU,GAA6C;CAC9D,IAAM,EAAE,UAAO,YAASP;CACxB,QAAQA,EAAK,MAAb;EACE,KAAK,SACH,OAAOQ,EAAM;GAAE;GAAO;GAAM,WAAWR,EAAK;EAAU,CAAC;EACzD,KAAK,cACH,OAAOS,EAAW;GAAE;GAAO;GAAM,WAAWT,EAAK;EAAU,CAAC;EAC9D,KAAK,QACH,OAAOU,EAAK;GAAE;GAAO;GAAM,QAAQV,EAAK;EAAO,CAAC;EAClD,KAAK,UACH,OAAOW,EAAO;GACZ;GAAO;GAAM,IAAIX,EAAK;GACtB,SAASA,EAAK;GAAS,WAAWA,EAAK;GAAW,MAAMA,EAAK;EAC/D,CAAC;EACH,SACE,OAAO;CACX;AACF;AAGA,SAAgBY,EACd,GAC4B;CAC5B,OAAO,UAAUC;AACnB;AAUA,SAAgBC,EAAmB,GAAmC;CAEpE,IADIC,EAAK,SAAS,aACd,CAACH,EAAcG,EAAK,OAAO,GAAG,OAAOA;CACzC,IAAMC,IAASb,EAAmBY,EAAK,OAAO;CAC9C,OAAOC,IAAS;EAAE,GAAGD;EAAM,SAASC;CAAO,IAAI;AACjD"}

package/dist/features/patterns/tileGeometry.js

@@ -0,0 +1,158 @@
+//#region src/features/patterns/tileGeometry.ts
+function e(e) {
+	if (e.size !== void 0) return e.size;
+	switch (e.tile) {
+		case "hatch": return 5;
+		case "crosshatch": return 6;
+		case "dots": return 6;
+		case "chunks": return 48;
+		default: return 8;
+	}
+}
+function t(e) {
+	let t = e | 0;
+	return () => {
+		t = t + 1831565813 | 0;
+		let e = Math.imul(t ^ t >>> 15, 1 | t);
+		return e = e + Math.imul(e ^ e >>> 7, 61 | e) ^ e, ((e ^ e >>> 14) >>> 0) / 4294967296;
+	};
+}
+function n(n) {
+	let a = e(n), { color: o } = n;
+	switch (n.tile) {
+		case "hatch": return {
+			size: a,
+			shapes: r(a, n.lineWidth ?? 1, o)
+		};
+		case "crosshatch": {
+			let e = n.lineWidth ?? .8;
+			return {
+				size: a,
+				shapes: [...r(a, e, o), ...i(a, e, o)]
+			};
+		}
+		case "dots": {
+			let e = n.radius ?? 1;
+			return {
+				size: a,
+				shapes: [{
+					kind: "circle",
+					cx: a / 2,
+					cy: a / 2,
+					r: e,
+					color: o
+				}]
+			};
+		}
+		case "chunks": {
+			let e = n.density ?? .35, r = n.chunkSize ?? 3, i = t(n.seed ?? 42), s = Math.round(a * a * e / (r * r)), c = [];
+			n.bg !== void 0 && c.push({
+				kind: "rect",
+				x: 0,
+				y: 0,
+				width: a,
+				height: a,
+				color: n.bg
+			});
+			for (let e = 0; e < s; e++) {
+				let e = i() * a, t = i() * a, n = r * (.5 + i()), s = r * (.5 + i()), l = i() * Math.PI;
+				c.push({
+					kind: "ellipse",
+					cx: e,
+					cy: t,
+					rx: n / 2,
+					ry: s / 2,
+					rotation: l,
+					color: o
+				});
+			}
+			return {
+				size: a,
+				shapes: c
+			};
+		}
+		default: return {
+			size: a,
+			shapes: []
+		};
+	}
+}
+function r(e, t, n) {
+	return [
+		{
+			kind: "line",
+			x1: -1,
+			y1: e + 1,
+			x2: e + 1,
+			y2: -1,
+			width: t,
+			color: n
+		},
+		{
+			kind: "line",
+			x1: -1,
+			y1: 1,
+			x2: 1,
+			y2: -1,
+			width: t,
+			color: n
+		},
+		{
+			kind: "line",
+			x1: e - 1,
+			y1: e + 1,
+			x2: e + 1,
+			y2: e - 1,
+			width: t,
+			color: n
+		}
+	];
+}
+function i(e, t, n) {
+	return [
+		{
+			kind: "line",
+			x1: -1,
+			y1: -1,
+			x2: e + 1,
+			y2: e + 1,
+			width: t,
+			color: n
+		},
+		{
+			kind: "line",
+			x1: e - 1,
+			y1: -1,
+			x2: e + 1,
+			y2: 1,
+			width: t,
+			color: n
+		},
+		{
+			kind: "line",
+			x1: -1,
+			y1: e - 1,
+			x2: 1,
+			y2: e + 1,
+			width: t,
+			color: n
+		}
+	];
+}
+function a(e, t) {
+	for (let n of t.shapes) {
+		if (n.kind === "line") {
+			e.strokeStyle = n.color, e.lineWidth = n.width, e.beginPath(), e.moveTo(n.x1, n.y1), e.lineTo(n.x2, n.y2), e.stroke();
+			continue;
+		}
+		if (e.fillStyle = n.color, n.kind === "rect") {
+			e.fillRect(n.x, n.y, n.width, n.height);
+			continue;
+		}
+		e.beginPath(), n.kind === "circle" ? e.arc(n.cx, n.cy, n.r, 0, Math.PI * 2) : e.ellipse(n.cx, n.cy, n.rx, n.ry, n.rotation, 0, Math.PI * 2), e.fill();
+	}
+}
+//#endregion
+export { a as drawTileShapes, n as tileGeometry, e as tileSize };
+
+//# sourceMappingURL=tileGeometry.js.map

package/dist/features/patterns/tileGeometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tileGeometry.js","names":["tileSize","spec","mulberry32","s","seed","t","tileGeometry","forwardDiagonals","color","width","backwardDiagonals","r","density","chunkSize","rand","count","shapes","i","cx","cy","w","h","rotation","drawTileShapes","shape","geometry","oc"],"sources":["../../../src/features/patterns/tileGeometry.ts"],"sourcesContent":["/**\n * The shapes a built-in tile is made of, as data.\n *\n * One description, two renderers: `patterns-builtin` strokes/fills these to\n * an `OffscreenCanvas` to build the GL texture, and `@weasel-js/svg` maps\n * them to `<pattern>` children. Duplicating the tile drawing in the\n * serializer would let the raster and vector forms drift apart silently.\n */\n\nimport type { TilePatternSpec } from '@weasel-js/paint';\n\n/** One primitive within a pattern tile, in tile-local coordinates. */\nexport type TileShape =\n  | { kind: 'line'; x1: number; y1: number; x2: number; y2: number; width: number; color: string }\n  | { kind: 'circle'; cx: number; cy: number; r: number; color: string }\n  | { kind: 'ellipse'; cx: number; cy: number; rx: number; ry: number; rotation: number; color: string }\n  | { kind: 'rect'; x: number; y: number; width: number; height: number; color: string };\n\n/** A built-in tile's shapes plus the edge length they're drawn within. */\nexport interface TileGeometry {\n  size: number;\n  shapes: TileShape[];\n}\n\n/** Defaults per tile kind, matching each factory's signature. */\nexport function tileSize(spec: TilePatternSpec): number {\n  if (spec.size !== undefined) return spec.size;\n  switch (spec.tile) {\n    case 'hatch': return 5;\n    case 'crosshatch': return 6;\n    case 'dots': return 6;\n    case 'chunks': return 48;\n    default: return 8;\n  }\n}\n\n/** Seeded PRNG (mulberry32) — `chunks` places its scatter with this, so the\n *  same `seed` yields the same tile in both the raster and vector paths. */\nfunction mulberry32(seed: number): () => number {\n  let s = seed | 0;\n  return () => {\n    s = (s + 0x6D2B79F5) | 0;\n    let t = Math.imul(s ^ (s >>> 15), 1 | s);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n/** Resolve a pattern spec to the shapes that make up one tile. Consumers that\n *  want to draw a pattern swatch themselves — a picker, an SVG export — read\n *  this rather than rasterizing a texture. */\nexport function tileGeometry(spec: TilePatternSpec): TileGeometry {\n  const s = tileSize(spec);\n  const { color } = spec;\n\n  switch (spec.tile) {\n    case 'hatch': {\n      const width = spec.lineWidth ?? 1;\n      return { size: s, shapes: forwardDiagonals(s, width, color) };\n    }\n    case 'crosshatch': {\n      const width = spec.lineWidth ?? 0.8;\n      return {\n        size: s,\n        shapes: [...forwardDiagonals(s, width, color), ...backwardDiagonals(s, width, color)],\n      };\n    }\n    case 'dots': {\n      const r = spec.radius ?? 1;\n      return { size: s, shapes: [{ kind: 'circle', cx: s / 2, cy: s / 2, r, color }] };\n    }\n    case 'chunks': {\n      const density = spec.density ?? 0.35;\n      const chunkSize = spec.chunkSize ?? 3;\n      const rand = mulberry32(spec.seed ?? 42);\n      const count = Math.round((s * s * density) / (chunkSize * chunkSize));\n      const shapes: TileShape[] = [];\n      if (spec.bg !== undefined) {\n        shapes.push({ kind: 'rect', x: 0, y: 0, width: s, height: s, color: spec.bg });\n      }\n      for (let i = 0; i < count; i++) {\n        const cx = rand() * s;\n        const cy = rand() * s;\n        const w = chunkSize * (0.5 + rand());\n        const h = chunkSize * (0.5 + rand());\n        const rotation = rand() * Math.PI;\n        shapes.push({ kind: 'ellipse', cx, cy, rx: w / 2, ry: h / 2, rotation, color });\n      }\n      return { size: s, shapes };\n    }\n    default:\n      return { size: s, shapes: [] };\n  }\n}\n\n/** The forward (`/`) diagonal, plus the two corner stubs that make it tile\n *  seamlessly across the edges. */\nfunction forwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: s + 1, x2: s + 1, y2: -1, width, color },\n    { kind: 'line', x1: -1, y1: 1, x2: 1, y2: -1, width, color },\n    { kind: 'line', x1: s - 1, y1: s + 1, x2: s + 1, y2: s - 1, width, color },\n  ];\n}\n\n/** The backward (`\\`) diagonal and its two stubs. */\nfunction backwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: -1, x2: s + 1, y2: s + 1, width, color },\n    { kind: 'line', x1: s - 1, y1: -1, x2: s + 1, y2: 1, width, color },\n    { kind: 'line', x1: -1, y1: s - 1, x2: 1, y2: s + 1, width, color },\n  ];\n}\n\n/** Draw a tile's shapes to a 2D context — the raster half of the pair. */\nexport function drawTileShapes(oc: CanvasRenderingContext2D, geometry: TileGeometry): void {\n  for (const shape of geometry.shapes) {\n    if (shape.kind === 'line') {\n      oc.strokeStyle = shape.color;\n      oc.lineWidth = shape.width;\n      oc.beginPath();\n      oc.moveTo(shape.x1, shape.y1);\n      oc.lineTo(shape.x2, shape.y2);\n      oc.stroke();\n      continue;\n    }\n    oc.fillStyle = shape.color;\n    if (shape.kind === 'rect') {\n      oc.fillRect(shape.x, shape.y, shape.width, shape.height);\n      continue;\n    }\n    oc.beginPath();\n    if (shape.kind === 'circle') {\n      oc.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);\n    } else {\n      oc.ellipse(shape.cx, shape.cy, shape.rx, shape.ry, shape.rotation, 0, Math.PI * 2);\n    }\n    oc.fill();\n  }\n}\n"],"mappings":"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"}

package/dist/features/pointer/PointerContext.js

@@ -0,0 +1,45 @@
+import { createContext as e, useContext as t, useMemo as n, useSyncExternalStore as r } from "react";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/features/pointer/PointerContext.tsx
+function a(e, t) {
+	return e === null || t === null ? e === t : e.worldX === t.worldX && e.worldY === t.worldY && e.viewId === t.viewId;
+}
+function o() {
+	let e = null, t = 0, n = /* @__PURE__ */ new Set(), r = () => e;
+	return {
+		get: r,
+		set(r) {
+			if (!a(e, r)) {
+				e = r, t++;
+				for (let e of [...n]) e();
+			}
+		},
+		subscribe(e) {
+			return n.add(e), () => {
+				n.delete(e);
+			};
+		},
+		getVersion: () => t,
+		getDropPoint: r
+	};
+}
+var s = e(null);
+function c({ children: e, store: t }) {
+	let r = n(o, []);
+	return /* @__PURE__ */ i(s.Provider, {
+		value: t ?? r,
+		children: e
+	});
+}
+function l() {
+	return t(s);
+}
+var u = () => () => {}, d = () => null;
+function f() {
+	let e = l();
+	return r(e ? e.subscribe : u, e ? e.get : d, e ? e.get : d);
+}
+//#endregion
+export { c as PointerContextProvider, o as createPointerStore, l as usePointerContext, f as usePointerPosition };
+
+//# sourceMappingURL=PointerContext.js.map

package/dist/features/pointer/PointerContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointerContext.js","names":["samePos","a","b","createPointerStore","current","version","listeners","get","next","fn","PointerContext","createContext","PointerContextProvider","own","useMemo","store","usePointerContext","useContext","noSubscribe","noPointer","usePointerPosition","useSyncExternalStore"],"sources":["../../../src/features/pointer/PointerContext.tsx"],"sourcesContent":["/**\n * @experimental\n * PointerContext — the world-space position of the canvas pointer, and the\n * view it is over, refreshed on every `pointermove` and cleared on\n * `pointerleave`.\n *\n * It is an external store rather than React state: cursor moves fire dozens of\n * times per second, and a consumer that only reads on demand (paste at the\n * pointer) must not re-render for each one. Readers that do need to follow it\n * — a linked cursor — subscribe, or use `usePointerPosition()`.\n *\n * `<SceneCanvas>` publishes automatically, and defers to a provider already in\n * scope, so several surfaces under one provider share one pointer: a detached\n * minimap and its main canvas each see where the other's pointer is.\n */\nimport {\n  createContext, useContext, useMemo, useSyncExternalStore, type ReactNode,\n} from 'react';\n\n/** @experimental World-space pointer position and the view it is over — a\n *  view id, or `null` for a surface's own camera. `null` as a whole when the\n *  pointer is over no publishing surface. */\nexport type PointerWorldPos = { worldX: number; worldY: number; viewId: string | null } | null;\n\n/** @experimental */\nexport interface PointerContextValue {\n  /** The latest position. */\n  get(): PointerWorldPos;\n  /** Publish a position. Subscribers hear only a changed value. */\n  set(next: PointerWorldPos): void;\n  /** Called after every change; returns the unsubscribe. */\n  subscribe(fn: () => void): () => void;\n  /** Bumps on every change. */\n  getVersion(): number;\n  /** `get()` as a stable thunk, for hooks taking a drop-point option. */\n  readonly getDropPoint: () => PointerWorldPos;\n}\n\nfunction samePos(a: PointerWorldPos, b: PointerWorldPos): boolean {\n  if (a === null || b === null) return a === b;\n  return a.worldX === b.worldX && a.worldY === b.worldY && a.viewId === b.viewId;\n}\n\n/** @experimental A pointer store with no provider around it. */\nexport function createPointerStore(): PointerContextValue {\n  let current: PointerWorldPos = null;\n  let version = 0;\n  const listeners = new Set<() => void>();\n  const get = (): PointerWorldPos => current;\n  return {\n    get,\n    set(next) {\n      if (samePos(current, next)) return;\n      current = next;\n      version++;\n      for (const fn of [...listeners]) fn();\n    },\n    subscribe(fn) {\n      listeners.add(fn);\n      return () => { listeners.delete(fn); };\n    },\n    getVersion: () => version,\n    getDropPoint: get,\n  };\n}\n\nconst PointerContext = createContext<PointerContextValue | null>(null);\n\n/**\n * @experimental\n * Wrap the part of the React tree that should share one pointer. Usually at\n * the app root, alongside `<ActionsProvider>` and `<SelectionContextProvider>`.\n *\n * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts\n * one when none is in scope. Mount it yourself when two surfaces should share\n * a pointer. Pass `store` to publish into one you hold elsewhere\n * (`createPointerStore()`).\n */\nexport function PointerContextProvider(\n  { children, store }: { children: ReactNode; store?: PointerContextValue },\n): ReactNode {\n  const own = useMemo(createPointerStore, []);\n  return <PointerContext.Provider value={store ?? own}>{children}</PointerContext.Provider>;\n}\n\n/** @experimental The surrounding pointer store, or `null` when no provider is\n *  in scope. */\nexport function usePointerContext(): PointerContextValue | null {\n  return useContext(PointerContext);\n}\n\nconst noSubscribe = (): (() => void) => () => {};\nconst noPointer = (): PointerWorldPos => null;\n\n/** @experimental The pointer, re-rendering the caller whenever it changes.\n *  `null` outside a provider. */\nexport function usePointerPosition(): PointerWorldPos {\n  const store = usePointerContext();\n  return useSyncExternalStore(\n    store ? store.subscribe : noSubscribe,\n    store ? store.get : noPointer,\n    store ? store.get : noPointer,\n  );\n}\n"],"mappings":";;;AAsCA,SAASA,EAAQ,GAAoB,GAA6B;CAEhE,OADIC,MAAM,QAAQC,MAAM,OAAaD,MAAMC,IACpCD,EAAE,WAAWC,EAAE,UAAUD,EAAE,WAAWC,EAAE,UAAUD,EAAE,WAAWC,EAAE;AAC1E;AAGA,SAAgBC,IAA0C;CACxD,IAAIC,IAA2B,MAC3BC,IAAU,GACRC,oBAAY,IAAI,IAAgB,GAChCC,UAA6BH;CACnC,OAAO;EACL;EACA,IAAI,GAAM;GACR,IAAI,GAAQA,GAASI,CAAI,GAEzB;IADA,IAAUA,GACV;IACA,KAAK,IAAMC,KAAM,CAAC,GAAGH,CAAS,GAAG,EAAG;GADpC;EAEF;EACA,UAAU,GAAI;GAEZ,OADAA,EAAU,IAAIG,CAAE,SACH;IAAE,EAAU,OAAOA,CAAE;GAAG;EACvC;EACA,kBAAkBJ;EAClB,cAAcE;CAChB;AACF;AAEA,IAAMG,IAAiBC,EAA0C,IAAI;AAYrE,SAAgBC,EACd,EAAE,aAAU,YACD;CACX,IAAMC,IAAMC,EAAQX,GAAoB,CAAC,CAAC;CAC1C,OAAO,kBAACO,EAAe,UAAhB;EAAyB,OAAOK,KAASF;EAAM;CAAkC,CAAA;AAC1F;AAIA,SAAgBG,IAAgD;CAC9D,OAAOC,EAAWP,CAAc;AAClC;AAEA,IAAMQ,gBAAwC,CAAC,GACzCC,UAAmC;AAIzC,SAAgBC,IAAsC;CACpD,IAAML,IAAQC,EAAkB;CAChC,OAAOK,EACLN,IAAQA,EAAM,YAAYG,GAC1BH,IAAQA,EAAM,MAAMI,GACpBJ,IAAQA,EAAM,MAAMI,CACtB;AACF"}

package/dist/features/poseRun/usePoseRun.js

@@ -0,0 +1,70 @@
+import { useVisibleRaf as e } from "../../scheduling/useVisibleRaf.js";
+import { dropPreviewOverrides as t, syncPreviewOverrides as n } from "../../interactions/actions/previewOverrides.js";
+import { useCallback as r, useEffect as i, useMemo as a, useRef as o } from "react";
+import { useLatest as s } from "@weasel-js/react";
+//#region src/features/poseRun/usePoseRun.ts
+var c = /* @__PURE__ */ new Map();
+function l(l) {
+	let u = s(l), d = o({
+		previews: /* @__PURE__ */ new Map(),
+		overrideEntries: /* @__PURE__ */ new Map()
+	}), f = o(!1), p = o(0), m = o(!0), h = e(() => {
+		b();
+	}, {
+		requestFrame: l.requestFrame,
+		cancelFrame: l.cancelFrame
+	}), g = r(() => ({
+		scene: u.current.scene,
+		previews: d.current.previews,
+		overrideEntries: d.current.overrideEntries
+	}), [u]), _ = () => {
+		let { overrides: e } = u.current.scene, t;
+		for (let n of e.ids()) {
+			let r = e.get(n);
+			r !== void 0 && r !== d.current.overrideEntries.get(n) && r.pose !== void 0 && (t ??= /* @__PURE__ */ new Map()).set(n, r.pose);
+		}
+		return t ?? c;
+	}, v = () => {
+		let { previews: e } = d.current, n = u.current.scene, r = 0;
+		e.size > 0 && n.batch(u.current.label ?? "Layout", () => {
+			for (let [t, i] of e) n.get(t) !== void 0 && (n.setPose(t, i), r++);
+		}), t(g()), e.clear(), u.current.onCommit?.(r);
+	}, y = () => {
+		f.current = !1, h.cancel();
+	}, b = () => {
+		if (!m.current || !f.current) return;
+		let e = _(), { poses: t, done: r } = u.current.step({
+			pinned: e,
+			frame: p.current
+		});
+		p.current++, d.current.previews.clear();
+		for (let [n, r] of t) e.has(n) || d.current.previews.set(n, r);
+		if (n(g()), r) {
+			y(), v();
+			return;
+		}
+		h.request();
+	};
+	return i(() => {
+		m.current = !0;
+		let { previews: e } = d.current;
+		return () => {
+			m.current = !1, h.cancel(), t(g()), e.clear();
+		};
+	}, [h, g]), a(() => ({
+		start() {
+			!f.current && m.current && (f.current = !0, p.current = 0, h.request());
+		},
+		stop() {
+			f.current && (y(), v());
+		},
+		cancel() {
+			y(), t(g()), d.current.previews.clear();
+		},
+		isRunning: () => f.current
+	}), [h]);
+}
+//#endregion
+export { l as usePoseRun };
+
+//# sourceMappingURL=usePoseRun.js.map

package/dist/features/poseRun/usePoseRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePoseRun.js","names":["EMPTY","usePoseRun","optsRef","useLatest","opts","state","useRef","running","frame","mounted","loop","useVisibleRaf","syncState","useCallback","pinnedNow","pinned","id","overrides","entry","commit","scene","moved","previews","pose","dropPreviewOverrides","halt","tick","poses","syncPreviewOverrides","done","useEffect","useMemo"],"sources":["../../../src/features/poseRun/usePoseRun.ts"],"sourcesContent":["/**\n * A pose run: poses published per frame, committed once.\n *\n * The frames go to `scene.overrides` — the ephemeral table a drag publishes to,\n * which `effectivePose`, the derived-geometry lookup and the pick source\n * already read. So an edge follows a node the run is moving with nothing added,\n * and the whole run lands as one undo entry when it settles.\n *\n * It knows nothing about layout. Each frame it asks `step` for poses and\n * whether it is finished; a relaxation, an eased transition to a target, and a\n * scrubbed timeline are all the same shape to it.\n *\n * **A node another gesture owns is pinned, not driven.** The run publishes\n * entries it holds by reference, so an override it did not put there belongs to\n * somebody else — a drag, a resize. It never writes that id, never commits it,\n * and hands it to `step` as pinned so the producer can hold its neighbors\n * against it.\n */\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../../scheduling/useVisibleRaf';\nimport {\n  dropPreviewOverrides,\n  syncPreviewOverrides,\n} from '../../interactions/actions/previewOverrides';\nimport type { NodeId, Scene } from '../../core/scene/types';\n\n/** What a producer is told before it is asked for a frame. */\nexport interface PoseRunCtx<TPose> {\n  /** Nodes another gesture is moving, and the pose each is drawn at. The run\n   *  will not write these, so a producer holds them fixed. */\n  pinned: ReadonlyMap<NodeId, TPose>;\n  /** Frames this run has produced, starting at 0. */\n  frame: number;\n}\n\n/** One frame of a run. */\nexport interface PoseRunStep<TPose> {\n  /** Where the nodes it drives are this frame — the whole picture, not a\n   *  delta. An id the frame omits stops being published, which is how a node\n   *  leaves the run's hands: a producer that drops a grabbed box and its rows\n   *  from one frame has released them by the next. */\n  poses: Iterable<readonly [NodeId, TPose]>;\n  /** Whether the run is finished. The frame is published either way, and a\n   *  finished run commits. */\n  done: boolean;\n}\n\n/** Options for `usePoseRun`. Read fresh each frame, so they may change mid-run. */\nexport interface UsePoseRunOptions<TPose> {\n  scene: Scene<unknown, string, TPose>;\n  /** Called once per frame while running, for that frame's poses. */\n  step: (ctx: PoseRunCtx<TPose>) => PoseRunStep<TPose>;\n  /** The undo entry's name. Default `'Layout'`. */\n  label?: string;\n  /** How many nodes the commit wrote. Fires after the ops land. */\n  onCommit?: (moved: number) => void;\n  /** Clock injection, for tests. Defaults to `requestAnimationFrame`. */\n  requestFrame?: (cb: (t: number) => void) => number;\n  cancelFrame?: (handle: number) => void;\n}\n\n/** Controls for a pose run. Stable for the life of the component. */\nexport interface PoseRun {\n  /** Begin a new run, counting frames from 0. Idempotent while running. */\n  start(): void;\n  /** Finish now: commit what is published, then drop the overrides. */\n  stop(): void;\n  /** Abandon: drop the overrides and write nothing, like a canceled drag. */\n  cancel(): void;\n  isRunning(): boolean;\n}\n\nconst EMPTY: ReadonlyMap<NodeId, unknown> = new Map<NodeId, unknown>();\n\n/**\n * Drive node poses frame by frame through `scene.overrides`, committing them as\n * one undo entry when `step` reports done or `stop` is called. Idle until\n * `start`; unmounting abandons the run without writing.\n */\nexport function usePoseRun<TPose>(opts: UsePoseRunOptions<TPose>): PoseRun {\n  const optsRef = useLatest(opts);\n\n  /** This frame's poses, and the entries published for them. Held by\n   *  reference so a frame mutates in place rather than re-notifying per node. */\n  const state = useRef({\n    previews: new Map<NodeId, unknown>(),\n    overrideEntries: new Map<NodeId, { pose: unknown }>(),\n  });\n  const running = useRef(false);\n  const frame = useRef(0);\n  const mounted = useRef(true);\n\n  // The gate defaults an absent clock to `requestAnimationFrame` itself, so\n  // these pass straight through rather than being defaulted twice.\n  const loop = useVisibleRaf(() => { tick(); }, {\n    requestFrame: opts.requestFrame,\n    cancelFrame: opts.cancelFrame,\n  });\n\n  /** The scene as the previous frame left it, for `syncPreviewOverrides`. */\n  const syncState = useCallback((): {\n    scene: Scene<unknown, string, unknown>;\n    previews: Map<NodeId, unknown>;\n    overrideEntries: Map<NodeId, { pose: unknown }>;\n  } => ({\n    scene: optsRef.current.scene as Scene<unknown, string, unknown>,\n    previews: state.current.previews,\n    overrideEntries: state.current.overrideEntries,\n  }), [optsRef]);\n\n  /** Overrides somebody else published, and the pose each carries. */\n  const pinnedNow = (): ReadonlyMap<NodeId, TPose> => {\n    const { overrides } = optsRef.current.scene;\n    let pinned: Map<NodeId, TPose> | undefined;\n    for (const id of overrides.ids()) {\n      const entry = overrides.get(id);\n      if (entry === undefined || entry === state.current.overrideEntries.get(id)) continue;\n      if (entry.pose === undefined) continue;\n      (pinned ??= new Map()).set(id, entry.pose);\n    }\n    return pinned ?? (EMPTY as ReadonlyMap<NodeId, TPose>);\n  };\n\n  const commit = (): void => {\n    const { previews } = state.current;\n    const scene = optsRef.current.scene;\n    let moved = 0;\n    if (previews.size > 0) {\n      scene.batch(optsRef.current.label ?? 'Layout', () => {\n        for (const [id, pose] of previews) {\n          if (scene.get(id) === undefined) continue;\n          scene.setPose(id, pose as TPose);\n          moved++;\n        }\n      });\n    }\n    // After the ops land: dropping first leaves a window in which the scene\n    // answers with the pre-run pose.\n    dropPreviewOverrides(syncState());\n    previews.clear();\n    optsRef.current.onCommit?.(moved);\n  };\n\n  const halt = (): void => {\n    running.current = false;\n    loop.cancel();\n  };\n\n  const tick = (): void => {\n    if (!mounted.current || !running.current) return;\n    const pinned = pinnedNow();\n    const { poses, done } = optsRef.current.step({ pinned, frame: frame.current });\n    frame.current++;\n    // Each frame replaces the last: an id this one omits — a node just\n    // grabbed, or a row under one — stops being published, rather than being\n    // held at a pose from before the press while the gesture carries it\n    // somewhere else.\n    state.current.previews.clear();\n    for (const [id, pose] of poses) {\n      if (pinned.has(id)) continue;\n      state.current.previews.set(id, pose);\n    }\n    syncPreviewOverrides(syncState());\n    if (done) {\n      halt();\n      commit();\n      return;\n    }\n    loop.request();\n  };\n\n  useEffect(() => {\n    mounted.current = true;\n    const { previews } = state.current;\n    return () => {\n      mounted.current = false;\n      loop.cancel();\n      // Teardown is not a decision: an unmounted run abandons its frames\n      // rather than writing them.\n      dropPreviewOverrides(syncState());\n      previews.clear();\n    };\n  }, [loop, syncState]);\n\n  return useMemo<PoseRun>(() => ({\n    start() {\n      if (running.current || !mounted.current) return;\n      running.current = true;\n      frame.current = 0;\n      loop.request();\n    },\n    stop() {\n      if (!running.current) return;\n      halt();\n      commit();\n    },\n    cancel() {\n      halt();\n      dropPreviewOverrides(syncState());\n      state.current.previews.clear();\n    },\n    isRunning: () => running.current,\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }), [loop]);\n}\n"],"mappings":";;;;;AAyEA,IAAMA,oBAAsC,IAAI,IAAqB;AAOrE,SAAgBC,EAAkB,GAAyC;CACzE,IAAMC,IAAUC,EAAUC,CAAI,GAIxBC,IAAQC,EAAO;EACnB,0BAAU,IAAI,IAAqB;EACnC,iCAAiB,IAAI,IAA+B;CACtD,CAAC,GACKC,IAAUD,EAAO,EAAK,GACtBE,IAAQF,EAAO,CAAC,GAChBG,IAAUH,EAAO,EAAI,GAIrBI,IAAOC,QAAoB;EAAE,EAAK;CAAG,GAAG;EAC5C,cAAcP,EAAK;EACnB,aAAaA,EAAK;CACpB,CAAC,GAGKQ,IAAYC,SAIZ;EACJ,OAAOX,EAAQ,QAAQ;EACvB,UAAUG,EAAM,QAAQ;EACxB,iBAAiBA,EAAM,QAAQ;CACjC,IAAI,CAACH,CAAO,CAAC,GAGPY,UAA8C;EAClD,IAAM,EAAE,iBAAcZ,EAAQ,QAAQ,OAClCa;EACJ,KAAK,IAAMC,KAAMC,EAAU,IAAI,GAAG;GAChC,IAAMC,IAAQD,EAAU,IAAID,CAAE;GAC9B,AAAIE,MAAU,KAAA,KAAaA,MAAUb,EAAM,QAAQ,gBAAgB,IAAIW,CAAE,KACrEE,EAAM,SAAS,KAAA,MAClB,sBAAW,IAAI,IAAI,EAAA,CAAG,IAAIF,GAAIE,EAAM,IAAI;EAC3C;EACA,OAAOH,KAAWf;CACpB,GAEMmB,UAAqB;EACzB,IAAM,EAAE,gBAAad,EAAM,SACrBe,IAAQlB,EAAQ,QAAQ,OAC1BmB,IAAQ;EAcZ,AAbIC,EAAS,OAAO,KAClBF,EAAM,MAAMlB,EAAQ,QAAQ,SAAS,gBAAgB;GACnD,KAAK,IAAM,CAACc,GAAIO,MAASD,GACvB,AAAIF,EAAM,IAAIJ,CAAE,MAAM,KAAA,MACtBI,EAAM,QAAQJ,GAAIO,CAAa,GAC/B;EAEJ,CAAC,GAIHC,EAAqBZ,EAAU,CAAC,GAChCU,EAAS,MAAM,GACfpB,EAAQ,QAAQ,WAAWmB,CAAK;CAClC,GAEMI,UAAmB;EAEvB,AADA,EAAQ,UAAU,IAClBf,EAAK,OAAO;CACd,GAEMgB,UAAmB;EACvB,IAAI,CAACjB,EAAQ,WAAW,CAACF,EAAQ,SAAS;EAC1C,IAAMQ,IAASD,EAAU,GACnB,EAAE,UAAO,YAASZ,EAAQ,QAAQ,KAAK;GAAE;GAAQ,OAAOM,EAAM;EAAQ,CAAC;EAM7E,AALA,EAAM,WAKNH,EAAM,QAAQ,SAAS,MAAM;EAC7B,KAAK,IAAM,CAACW,GAAIO,MAASI,GACvB,AAAIZ,EAAO,IAAIC,CAAE,KACjBX,EAAM,QAAQ,SAAS,IAAIW,GAAIO,CAAI;EAGrC,IADAK,EAAqBhB,EAAU,CAAC,GAC5BiB,GAAM;GAER,AADAJ,EAAK,GACLN,EAAO;GACP;EACF;EACA,EAAK,QAAQ;CACf;CAeA,OAbAW,QAAgB;EACd,EAAQ,UAAU;EAClB,IAAM,EAAE,gBAAazB,EAAM;EAC3B,aAAa;GAMX,AALA,EAAQ,UAAU,IAClBK,EAAK,OAAO,GAGZc,EAAqBZ,EAAU,CAAC,GAChCU,EAAS,MAAM;EACjB;CACF,GAAG,CAACZ,GAAME,CAAS,CAAC,GAEbmB,SAAwB;EAC7B,QAAQ;GACN,AAAI,GAAQ,WAAYtB,EAAQ,YAChC,EAAQ,UAAU,IAClB,EAAM,UAAU,GAChBC,EAAK,QAAQ;EACf;EACA,OAAO;GACL,AAAKH,EAAQ,YACbkB,EAAK,GACLN,EAAO;EACT;EACA,SAAS;GAGP,AAFAM,EAAK,GACLD,EAAqBZ,EAAU,CAAC,GAChCP,EAAM,QAAQ,SAAS,MAAM;EAC/B;EACA,iBAAiBE,EAAQ;CAE3B,IAAI,CAACG,CAAI,CAAC;AACZ"}

package/dist/features/selection/SelectionContext.js

@@ -0,0 +1,46 @@
+import { createContext as e, useCallback as t, useContext as n, useEffect as r, useMemo as i, useRef as a, useState as o } from "react";
+import { useLatest as s } from "@weasel-js/react";
+import { Fragment as c, jsx as l } from "react/jsx-runtime";
+//#region src/features/selection/SelectionContext.tsx
+var u = e(null);
+function d({ children: e }) {
+	let [n, r] = o({
+		selection: [],
+		kinds: void 0
+	}), s = a(""), c = t((e, t) => {
+		let n = JSON.stringify([e, t]);
+		n !== s.current && (s.current = n, r({
+			selection: e,
+			kinds: t
+		}));
+	}, []), d = i(() => ({
+		selection: n.selection,
+		...n.kinds === void 0 ? {} : { kinds: n.kinds },
+		publishSelection: c
+	}), [n, c]);
+	return /* @__PURE__ */ l(u.Provider, {
+		value: d,
+		children: e
+	});
+}
+function f() {
+	return n(u);
+}
+function p({ children: e }) {
+	return n(u) === null ? /* @__PURE__ */ l(d, { children: e }) : /* @__PURE__ */ l(c, { children: e });
+}
+function m(e, t) {
+	let i = n(u), a = s(e), o = s(t), c = JSON.stringify([e, t]), l = i?.publishSelection;
+	r(() => {
+		l && l(a.current, o.current);
+	}, [
+		l,
+		c,
+		a,
+		o
+	]);
+}
+//#endregion
+export { d as SelectionContextProvider, p as SelectionContextProviderIfRoot, m as usePublishSelection, f as useSelectionContext };
+
+//# sourceMappingURL=SelectionContext.js.map

package/dist/features/selection/SelectionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionContext.js","names":["_Fragment","SelectionContext","createContext","SelectionContextProvider","state","setState","useState","lastSerializedRef","useRef","publishSelection","useCallback","next","ids","kinds","value","useMemo","useSelectionContext","useContext","SelectionContextProviderIfRoot","Fragment","usePublishSelection","ctx","idsRef","useLatest","kindsRef","serialized","publish"],"sources":["../../../src/features/selection/SelectionContext.tsx"],"sourcesContent":["/**\n * @experimental\n * SelectionContext — a tiny ambient context that publishes \"what's currently\n * selected\" so non-canvas UI (command palette, status bar, breadcrumbs,\n * undo-label generation) can read it without threading a selection prop\n * through the tree.\n *\n * **Single-slot semantics (v1):** the context holds one selection array.\n * Whichever canvas (or other publisher) calls `publishSelection` most\n * recently owns the slot. For single-canvas pages — the typical case —\n * this Just Works. Multi-canvas pages get last-writer-wins, which is\n * approximately \"most recently rendered.\" A v2 could become focus-aware\n * (canvas claims the slot on focus, releases on blur), but that's deferred\n * until a real multi-canvas use case lands.\n *\n * `<SceneCanvas>` calls `publishSelection` automatically when wrapped in a\n * `<SelectionContext>`. Bare-`<Canvas>` consumers opt in by calling\n * `useSelectionContext().publishSelection(ids)` themselves.\n */\nimport {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactNode,\n} from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from 'core/scene/types';\n\n/** @experimental */\nexport interface SelectionContextValue {\n  /** The most-recently-published selection. Empty array when no canvas\n   *  has published or when the active canvas's selection is empty. */\n  readonly selection: readonly NodeId[];\n  /** Optional per-id kind label, parallel to `selection`. Publishers that\n   *  know their domain populate it (e.g. `'rectangle'`, `'path'`, `'group'`)\n   *  so consumers can render type-aware copy. Sparse entries (`undefined`)\n   *  are allowed; consumers should treat the kinds array as best-effort.\n   *\n   *  See `docs/TODO.md` (Tier 1.5 → \"Typed scene-object references\") for the\n   *  longer-term direction toward a proper id+kind value type. */\n  readonly kinds?: readonly (string | undefined)[];\n  /** Publish the calling canvas's selection. Idempotent — calling with\n   *  the same array (by content equality) does not trigger a re-render\n   *  of the consumer tree. */\n  publishSelection(ids: readonly NodeId[], kinds?: readonly (string | undefined)[]): void;\n}\n\nconst SelectionContext = createContext<SelectionContextValue | null>(null);\n\n/**\n * @experimental\n * Wrap the part of the React tree that should share a selection context.\n * Usually placed at the demo / app root, alongside `<ActionsProvider>`.\n */\nexport function SelectionContextProvider({ children }: { children: ReactNode }): ReactNode {\n  const [state, setState] = useState<{\n    selection: readonly NodeId[];\n    kinds: readonly (string | undefined)[] | undefined;\n  }>({ selection: [], kinds: undefined });\n  const lastSerializedRef = useRef<string>('');\n\n  const publishSelection = useCallback((\n    ids: readonly NodeId[],\n    kinds?: readonly (string | undefined)[],\n  ): void => {\n    // Cheap content equality via JSON serialization over both ids and kinds.\n    // Selection arrays are typically small (≤ a few dozen entries); the cost\n    // is dwarfed by avoiding a re-render when nothing changed.\n    const next = JSON.stringify([ids, kinds]);\n    if (next === lastSerializedRef.current) return;\n    lastSerializedRef.current = next;\n    setState({ selection: ids, kinds });\n  }, []);\n\n  const value = useMemo<SelectionContextValue>(\n    () => ({\n      selection: state.selection,\n      ...(state.kinds !== undefined ? { kinds: state.kinds } : {}),\n      publishSelection,\n    }),\n    [state, publishSelection],\n  );\n\n  return <SelectionContext.Provider value={value}>{children}</SelectionContext.Provider>;\n}\n\n/**\n * @experimental\n * Read the current selection-context value. Returns `null` when no\n * `<SelectionContextProvider>` is in scope; consumers should fall back\n * gracefully (e.g. command palette hides the \"N selected\" header).\n */\nexport function useSelectionContext(): SelectionContextValue | null {\n  return useContext(SelectionContext);\n}\n\n/**\n * @experimental\n * Conditional `<SelectionContextProvider>` wrapper. Mounts a provider only\n * when no parent provider is in scope — otherwise renders children unwrapped\n * so callers (e.g. `<WeaselProvider>`) defer to the host's existing scope.\n * Mirrors `ActionsProviderIfRoot` / `DepRegistryProviderIfRoot`.\n */\nexport function SelectionContextProviderIfRoot({\n  children,\n}: {\n  children: ReactNode;\n}): ReactNode {\n  const parent = useContext(SelectionContext);\n  if (parent !== null) return <>{children}</>;\n  return <SelectionContextProvider>{children}</SelectionContextProvider>;\n}\n\n/**\n * @experimental\n * Convenience hook for canvas components: publishes the supplied `ids`\n * into the surrounding `<SelectionContextProvider>` whenever the\n * content of `ids` changes. No-op when there's no provider in scope.\n *\n * Used by `<SceneCanvas>` internally to auto-publish; bare-Canvas\n * consumers call `useSelectionContext()` and `publishSelection` directly.\n */\nexport function usePublishSelection(\n  ids: readonly NodeId[],\n  kinds?: readonly (string | undefined)[],\n): void {\n  const ctx = useContext(SelectionContext);\n  // Track latest values via refs so the effect's deps array can use a stable\n  // serialization — avoids re-firing on identity-only changes.\n  const idsRef = useLatest(ids);\n  const kindsRef = useLatest(kinds);\n  const serialized = JSON.stringify([ids, kinds]);\n  // Depend on `publishSelection` rather than `ctx`: the provider mints a new\n  // context value on every publish, so keying on `ctx` refires this effect for\n  // every publisher whenever any one of them publishes.\n  const publish = ctx?.publishSelection;\n  useEffect(() => {\n    if (!publish) return;\n    publish(idsRef.current, kindsRef.current);\n  }, [publish, serialized, idsRef, kindsRef]);\n}\n"],"mappings":";;;;AAmDA,IAAMC,IAAmBC,EAA4C,IAAI;AAOzE,SAAgBC,EAAyB,EAAE,eAAgD;CACzF,IAAM,CAACC,GAAOC,KAAYC,EAGvB;EAAE,WAAW,CAAC;EAAG,OAAO,KAAA;CAAU,CAAC,GAChCC,IAAoBC,EAAe,EAAE,GAErCC,IAAmBC,GACvB,GACA,MACS;EAIT,IAAMC,IAAO,KAAK,UAAU,CAACC,GAAKC,CAAK,CAAC;EACxC,AAAIF,MAASJ,EAAkB,YAC/B,EAAkB,UAAUI,GAC5BN,EAAS;GAAE,WAAWO;GAAK;EAAM,CAAC;CACpC,GAAG,CAAC,CAAC,GAECE,IAAQC,SACL;EACL,WAAWX,EAAM;EACjB,GAAIA,EAAM,UAAU,KAAA,IAAqC,CAAC,IAA1B,EAAE,OAAOA,EAAM,MAAM;EACrD;CACF,IACA,CAACA,GAAOK,CAAgB,CAC1B;CAEA,OAAO,kBAACR,EAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACvF;AAQA,SAAgBe,IAAoD;CAClE,OAAOC,EAAWhB,CAAgB;AACpC;AASA,SAAgBiB,EAA+B,EAC7C,eAGY;CAGZ,OAFeD,EAAWhB,CACtB,MAAW,OACR,kBAACE,GAAD,EAA2B,YAAmC,CAAA,IADzC,kBAAAH,GAAA,EAAG,YAAW,CAAA;AAE5C;AAWA,SAAgBoB,EACd,GACA,GACM;CACN,IAAMC,IAAMJ,EAAWhB,CAAgB,GAGjCqB,IAASC,EAAUX,CAAG,GACtBY,IAAWD,EAAUV,CAAK,GAC1BY,IAAa,KAAK,UAAU,CAACb,GAAKC,CAAK,CAAC,GAIxCa,IAAUL,GAAK;CACrB,QAAgB;EACd,AAAKK,KACLA,EAAQJ,EAAO,SAASE,EAAS,OAAO;CAC1C,GAAG;EAACE;EAASD;EAAYH;EAAQE;CAAQ,CAAC;AAC5C"}