@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/useCanvasElements.js

@@ -0,0 +1,31 @@
+import { useCallback, useInsertionEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useCanvasElements.ts
+function useCanvasElements(paintInto, inputElement) {
+	const canvasRef = useRef(null);
+	const ownCanvasRef = useRef(null);
+	const setOwnCanvas = useCallback((el) => {
+		ownCanvasRef.current = el;
+		canvasRef.current = el;
+	}, []);
+	const detached = !!paintInto;
+	useInsertionEffect(() => {
+		if (detached) canvasRef.current = inputElement ?? null;
+	});
+	return {
+		canvasRef,
+		ownCanvasRef,
+		setOwnCanvas,
+		detached,
+		paintTargetRef: useLatest(detached ? paintInto.canvas ?? null : null),
+		paintRectRef: useLatest(detached ? {
+			x: paintInto.x,
+			y: paintInto.y
+		} : null)
+	};
+}
+
+//#endregion
+export { useCanvasElements };
+//# sourceMappingURL=useCanvasElements.js.map

package/dist/canvas/useCanvasElements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasElements.js","names":[],"sources":["../../src/canvas/useCanvasElements.ts"],"sourcesContent":["import { useCallback, useInsertionEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { CanvasProps } from './canvasProps';\n\n/** The elements a canvas reads input from and paints into. */\nexport interface CanvasElements {\n  /**\n   * The element input comes from and every client→world conversion measures: the `<canvas>`\n   * this component renders, or under `paintInto` the caller's `inputElement`.\n   */\n  canvasRef: { current: HTMLElement | null };\n  /** The `<canvas>` this component rendered, if it rendered one. */\n  ownCanvasRef: { current: HTMLCanvasElement | null };\n  /** React's ref callback for the rendered `<canvas>`. */\n  setOwnCanvas: (el: HTMLCanvasElement | null) => void;\n  detached: boolean;\n  /** Where pixels go when detached; null otherwise. */\n  paintTargetRef: { readonly current: HTMLCanvasElement | null };\n  /** The detached tile's origin on its target; null otherwise. */\n  paintRectRef: { readonly current: { x: number; y: number } | null };\n}\n\nexport function useCanvasElements(\n  paintInto: CanvasProps<unknown>['paintInto'],\n  inputElement: HTMLElement | null | undefined,\n): CanvasElements {\n  const canvasRef = useRef<HTMLElement | null>(null);\n  const ownCanvasRef = useRef<HTMLCanvasElement | null>(null);\n  // Stable, so a commit does not detach the element: an inline ref is nulled\n  // until the layout phase reaches it, and a sync paint asked for before that\n  // finds no canvas.\n  const setOwnCanvas = useCallback((el: HTMLCanvasElement | null) => {\n    ownCanvasRef.current = el;\n    canvasRef.current = el;\n  }, []);\n  const detached = !!paintInto;\n  // The detached input element reaches `canvasRef` at commit; the own canvas\n  // arrives through `setOwnCanvas`.\n  useInsertionEffect(() => {\n    if (detached) canvasRef.current = inputElement ?? null;\n  });\n  const paintTargetRef = useLatest(detached ? (paintInto.canvas ?? null) : null);\n  const paintRectRef = useLatest(detached ? { x: paintInto.x, y: paintInto.y } : null);\n  return { canvasRef, ownCanvasRef, setOwnCanvas, detached, paintTargetRef, paintRectRef };\n}\n"],"mappings":";;;;AAsBA,SAAgB,kBACd,WACA,cACgB;CAChB,MAAM,YAAY,OAA2B,IAAI;CACjD,MAAM,eAAe,OAAiC,IAAI;CAI1D,MAAM,eAAe,aAAa,OAAiC;EACjE,aAAa,UAAU;EACvB,UAAU,UAAU;CACtB,GAAG,CAAC,CAAC;CACL,MAAM,WAAW,CAAC,CAAC;CAGnB,yBAAyB;EACvB,IAAI,UAAU,UAAU,UAAU,gBAAgB;CACpD,CAAC;CAGD,OAAO;EAAE;EAAW;EAAc;EAAc;EAAU,gBAFnC,UAAU,WAAY,UAAU,UAAU,OAAQ,IAEf;EAAgB,cADrD,UAAU,WAAW;GAAE,GAAG,UAAU;GAAG,GAAG,UAAU;EAAE,IAAI,IACL;CAAa;AACzF"}

package/dist/canvas/useCanvasHandle.js

@@ -0,0 +1,69 @@
+import { useCallback, useImperativeHandle } from "react";
+
+//#region src/canvas/useCanvasHandle.ts
+/** The bare canvas's imperative handle. Its own-frame members answer against `frame`. */
+function useCanvasHandle(ref, target, frame, api) {
+	const { canvasRef, ownCanvasRef, detached, paintRectRef, inputElement, paintCanvas } = target;
+	const { viewRef, dimsRef, helpersRef } = frame;
+	const { hitTestExtrasIn, clientToWorld, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume, registerLayer, getView, setView, subscribeView, getPaintedVersion, paintedCursor, cursorSink, getDebug } = api;
+	const hitTestExtras = useCallback((worldX, worldY, at) => hitTestExtrasIn(worldX, worldY, at?.view ?? viewRef.current, at?.dims ?? dimsRef.current, helpersRef.current), [
+		hitTestExtrasIn,
+		dimsRef,
+		viewRef,
+		helpersRef
+	]);
+	const getSurfaceRect = useCallback(() => {
+		const origin = paintRectRef.current;
+		const { width: w, height: h } = dimsRef.current;
+		return {
+			x: origin?.x ?? 0,
+			y: origin?.y ?? 0,
+			width: w,
+			height: h
+		};
+	}, [dimsRef, paintRectRef]);
+	useImperativeHandle(ref, () => ({
+		element: detached ? inputElement ?? null : canvasRef.current,
+		surface: detached ? paintCanvas ?? null : ownCanvasRef.current,
+		getSurfaceRect,
+		clientToWorld,
+		requestRedraw,
+		subscribeFrame,
+		subscribeBeforePaint,
+		subscribeResume,
+		registerLayer,
+		hitTestExtras,
+		getView,
+		setView,
+		subscribeView,
+		getPaintedVersion,
+		paintedCursor,
+		cursorSink,
+		getDebug
+	}), [
+		canvasRef,
+		ownCanvasRef,
+		detached,
+		inputElement,
+		paintCanvas,
+		getSurfaceRect,
+		clientToWorld,
+		requestRedraw,
+		subscribeFrame,
+		subscribeBeforePaint,
+		subscribeResume,
+		registerLayer,
+		hitTestExtras,
+		getView,
+		setView,
+		subscribeView,
+		getPaintedVersion,
+		paintedCursor,
+		cursorSink,
+		getDebug
+	]);
+}
+
+//#endregion
+export { useCanvasHandle };
+//# sourceMappingURL=useCanvasHandle.js.map

package/dist/canvas/useCanvasHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasHandle.js","names":[],"sources":["../../src/canvas/useCanvasHandle.ts"],"sourcesContent":["import { useCallback, useImperativeHandle } from 'react';\nimport type React from 'react';\nimport type { View } from 'core/viewport/view';\nimport type { Dims } from 'core/layers/render';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasElements } from './useCanvasElements';\nimport type { HitTestExtrasIn } from './useExtraLayers';\nimport type { SurfaceFrame } from './useViewRegistrySurface';\n\n/** The handle's members the canvas builds elsewhere. */\nexport type CanvasHandleApi = Omit<\n  CanvasExtensionApi,\n  'element' | 'surface' | 'getSurfaceRect' | 'hitTestExtras' | 'ingest' | 'addView'\n> & { hitTestExtrasIn: HitTestExtrasIn };\n\n/** The elements the handle names, as of this render. */\nexport interface CanvasHandleTarget\n  extends Pick<CanvasElements, 'canvasRef' | 'ownCanvasRef' | 'detached' | 'paintRectRef'> {\n  inputElement: HTMLElement | null | undefined;\n  paintCanvas: HTMLCanvasElement | null | undefined;\n}\n\n/** The bare canvas's imperative handle. Its own-frame members answer against `frame`. */\nexport function useCanvasHandle(\n  ref: React.ForwardedRef<CanvasExtensionApi>,\n  target: CanvasHandleTarget,\n  frame: SurfaceFrame,\n  api: CanvasHandleApi,\n): void {\n  const { canvasRef, ownCanvasRef, detached, paintRectRef, inputElement, paintCanvas } = target;\n  const { viewRef, dimsRef, helpersRef } = frame;\n  const {\n    hitTestExtrasIn, clientToWorld, requestRedraw, subscribeFrame, subscribeBeforePaint,\n    subscribeResume, registerLayer, getView, setView, subscribeView,\n    getPaintedVersion, paintedCursor, cursorSink, getDebug,\n  } = api;\n\n  const hitTestExtras = useCallback((worldX: number, worldY: number, at?: { view: View; dims: Dims }) => (\n    hitTestExtrasIn(worldX, worldY, at?.view ?? viewRef.current, at?.dims ?? dimsRef.current, helpersRef.current)\n  ), [hitTestExtrasIn, dimsRef, viewRef, helpersRef]);\n\n  const getSurfaceRect = useCallback(() => {\n    const origin = paintRectRef.current;\n    const { width: w, height: h } = dimsRef.current;\n    return { x: origin?.x ?? 0, y: origin?.y ?? 0, width: w, height: h };\n  }, [dimsRef, paintRectRef]);\n\n  useImperativeHandle(ref, () => ({\n    // Named rather than read off `canvasRef` so the handle rebuilds when a\n    // detached surface's input element arrives, which is a render later.\n    element: detached ? inputElement ?? null : canvasRef.current,\n    surface: detached ? paintCanvas ?? null : ownCanvasRef.current,\n    getSurfaceRect,\n    clientToWorld,\n    requestRedraw,\n    subscribeFrame,\n    subscribeBeforePaint,\n    subscribeResume,\n    registerLayer,\n    hitTestExtras,\n    getView,\n    setView,\n    subscribeView,\n    getPaintedVersion,\n    paintedCursor,\n    cursorSink,\n    getDebug,\n  }), [canvasRef, ownCanvasRef, detached, inputElement, paintCanvas,\n       getSurfaceRect, clientToWorld, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume,\n       registerLayer,\n       hitTestExtras, getView, setView, subscribeView, getPaintedVersion,\n       paintedCursor, cursorSink, getDebug]);\n}\n"],"mappings":";;;;AAuBA,SAAgB,gBACd,KACA,QACA,OACA,KACM;CACN,MAAM,EAAE,WAAW,cAAc,UAAU,cAAc,cAAc,gBAAgB;CACvF,MAAM,EAAE,SAAS,SAAS,eAAe;CACzC,MAAM,EACJ,iBAAiB,eAAe,eAAe,gBAAgB,sBAC/D,iBAAiB,eAAe,SAAS,SAAS,eAClD,mBAAmB,eAAe,YAAY,aAC5C;CAEJ,MAAM,gBAAgB,aAAa,QAAgB,QAAgB,OACjE,gBAAgB,QAAQ,QAAQ,IAAI,QAAQ,QAAQ,SAAS,IAAI,QAAQ,QAAQ,SAAS,WAAW,OAAO,GAC3G;EAAC;EAAiB;EAAS;EAAS;CAAU,CAAC;CAElD,MAAM,iBAAiB,kBAAkB;EACvC,MAAM,SAAS,aAAa;EAC5B,MAAM,EAAE,OAAO,GAAG,QAAQ,MAAM,QAAQ;EACxC,OAAO;GAAE,GAAG,QAAQ,KAAK;GAAG,GAAG,QAAQ,KAAK;GAAG,OAAO;GAAG,QAAQ;EAAE;CACrE,GAAG,CAAC,SAAS,YAAY,CAAC;CAE1B,oBAAoB,YAAY;EAG9B,SAAS,WAAW,gBAAgB,OAAO,UAAU;EACrD,SAAS,WAAW,eAAe,OAAO,aAAa;EACvD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,IAAI;EAAC;EAAW;EAAc;EAAU;EAAc;EACjD;EAAgB;EAAe;EAAe;EAAgB;EAAsB;EACpF;EACA;EAAe;EAAS;EAAS;EAAe;EAChD;EAAe;EAAY;CAAQ,CAAC;AAC3C"}

package/dist/canvas/useCanvasPaint.js

@@ -0,0 +1,91 @@
+import { DEFAULT_LAYER_RETAIN } from "../core/layers/retain.js";
+import { drawLayers } from "../core/layers/render.js";
+import { beginDebugFrame } from "../debug/useDebugSink.js";
+import { NO_LAYER_VISIBILITY } from "./useExtraLayers.js";
+import { viewToMat3 } from "@weasel-js/renderer";
+import { useCallback, useEffect, useInsertionEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useCanvasPaint.ts
+/**
+* Which content version the last paint showed. `markPainted` records the current one, read
+* from `contentVersion`'s latest committed value.
+*/
+function usePaintedVersion(contentVersion) {
+	const contentVersionRef = useLatest(contentVersion);
+	const paintedVersionRef = useRef(0);
+	return {
+		getPaintedVersion: useCallback(() => paintedVersionRef.current, []),
+		markPainted: useCallback(() => {
+			paintedVersionRef.current = contentVersionRef.current?.() ?? 0;
+		}, [contentVersionRef])
+	};
+}
+function retainPolicy(retain) {
+	if (retain === false) return false;
+	const minCommands = retain?.minCommands;
+	return minCommands === void 0 ? DEFAULT_LAYER_RETAIN : { minCommands };
+}
+/**
+* Publish the canvas's paint into `paintRef`, which the frame loop calls. The paint binds the
+* leased renderer to whichever canvas pixels go to and draws the layer stack through the
+* current view. The layer command cache lives as long as the canvas.
+*/
+function useCanvasPaint(paintRef, lease, target, frame, markPainted) {
+	const { paintTargetRef, ownCanvasRef, paintRectRef } = target;
+	const { inputsRef, viewRef, gateRef, helpersRef } = frame;
+	const layerCacheRef = useRef(/* @__PURE__ */ new Map());
+	const paint = useCallback(() => {
+		const c = paintTargetRef.current ?? ownCanvasRef.current;
+		if (!c) return false;
+		const rect = paintRectRef.current;
+		const { layers: paintLayers, width: w, height: h, debugSink: sink, frameStats: timed, dpr: dprIn, flattenTolerance: paintFlattenTolerance, layerGroups: groups, shaders: paintShaders, retain } = inputsRef.current;
+		if (w === 0 || h === 0) return false;
+		const debugFrame = beginDebugFrame(sink, timed, paintLayers);
+		const renderer = lease.bind(c, {
+			width: w,
+			height: h,
+			dpr: dprIn
+		}, {
+			tile: rect,
+			flattenTolerance: paintFlattenTolerance,
+			retainBudget: retain ? retain.budget : void 0,
+			shaders: paintShaders
+		});
+		if (!renderer) return false;
+		const view = viewRef.current;
+		const { layerVisibility: vis, layerOrder: order } = gateRef.current;
+		const spans = debugFrame?.time();
+		const commands = drawLayers(paintLayers, helpersRef.current, vis ?? NO_LAYER_VISIBILITY, order, view, {
+			width: w,
+			height: h
+		}, layerCacheRef.current, void 0, groups, spans, retainPolicy(retain));
+		renderer.render(commands, viewToMat3(view), spans ? { spans } : void 0);
+		debugFrame?.end(renderer.lastFrameStats());
+		markPainted();
+		return true;
+	}, [
+		gateRef,
+		helpersRef,
+		inputsRef,
+		lease,
+		markPainted,
+		ownCanvasRef,
+		paintRectRef,
+		paintTargetRef,
+		viewRef
+	]);
+	useInsertionEffect(() => {
+		paintRef.current = paint;
+	});
+	useEffect(() => {
+		const layerCache = layerCacheRef.current;
+		return () => {
+			layerCache.clear();
+		};
+	}, []);
+}
+
+//#endregion
+export { useCanvasPaint, usePaintedVersion };
+//# sourceMappingURL=useCanvasPaint.js.map

package/dist/canvas/useCanvasPaint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasPaint.js","names":[],"sources":["../../src/canvas/useCanvasPaint.ts"],"sourcesContent":["import { useCallback, useEffect, useInsertionEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { viewToMat3 } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport {\n  DEFAULT_LAYER_RETAIN, drawLayers, type LayerCommandCache, type LayerRetainPolicy, type RenderLayer,\n} from 'core/layers/render';\nimport type { CanvasDebugSink } from '../debug/types';\nimport { beginDebugFrame } from '../debug/useDebugSink';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport type { CanvasProps } from './canvasProps';\nimport type { CanvasElements } from './useCanvasElements';\nimport { NO_LAYER_VISIBILITY, type LayerGate } from './useExtraLayers';\n\n/** What a frame's paint reads that a React render owns. */\nexport interface PaintInputs extends Pick<CanvasProps<unknown>, 'dpr' | 'layerGroups' | 'shaders' | 'flattenTolerance' | 'retain'> {\n  layers: RenderLayer<unknown>[];\n  width: number;\n  height: number;\n  debugSink: CanvasDebugSink | null;\n  frameStats: boolean;\n}\n\n/** What a frame's paint reads that changes outside a render. */\nexport interface PaintFrame {\n  inputsRef: { readonly current: PaintInputs };\n  viewRef: { readonly current: View };\n  gateRef: { readonly current: LayerGate };\n  helpersRef: { readonly current: unknown };\n}\n\n/**\n * Which content version the last paint showed. `markPainted` records the current one, read\n * from `contentVersion`'s latest committed value.\n */\nexport function usePaintedVersion(contentVersion: (() => number) | undefined): {\n  getPaintedVersion: () => number;\n  markPainted: () => void;\n} {\n  const contentVersionRef = useLatest(contentVersion);\n  const paintedVersionRef = useRef(0);\n  const getPaintedVersion = useCallback(() => paintedVersionRef.current, []);\n  const markPainted = useCallback(() => {\n    paintedVersionRef.current = contentVersionRef.current?.() ?? 0;\n  }, [contentVersionRef]);\n  return { getPaintedVersion, markPainted };\n}\n\nfunction retainPolicy(retain: PaintInputs['retain']): LayerRetainPolicy | false {\n  if (retain === false) return false;\n  const minCommands = retain?.minCommands;\n  return minCommands === undefined ? DEFAULT_LAYER_RETAIN : { minCommands };\n}\n\n/**\n * Publish the canvas's paint into `paintRef`, which the frame loop calls. The paint binds the\n * leased renderer to whichever canvas pixels go to and draws the layer stack through the\n * current view. The layer command cache lives as long as the canvas.\n */\nexport function useCanvasPaint(\n  paintRef: { current: () => boolean },\n  lease: CanvasRendererLease,\n  target: Pick<CanvasElements, 'paintTargetRef' | 'ownCanvasRef' | 'paintRectRef'>,\n  frame: PaintFrame,\n  markPainted: () => void,\n): void {\n  const { paintTargetRef, ownCanvasRef, paintRectRef } = target;\n  const { inputsRef, viewRef, gateRef, helpersRef } = frame;\n  const layerCacheRef = useRef<LayerCommandCache>(new Map());\n\n  const paint = useCallback((): boolean => {\n    const c = paintTargetRef.current ?? ownCanvasRef.current;\n    if (!c) return false;\n    const rect = paintRectRef.current;\n    const {\n      layers: paintLayers, width: w, height: h, debugSink: sink, frameStats: timed,\n      dpr: dprIn,\n      flattenTolerance: paintFlattenTolerance,\n      layerGroups: groups, shaders: paintShaders, retain,\n    } = inputsRef.current;\n    if (w === 0 || h === 0) return false;\n\n    const debugFrame = beginDebugFrame(sink, timed, paintLayers);\n\n    const renderer = lease.bind(c, { width: w, height: h, dpr: dprIn }, {\n      tile: rect,\n      flattenTolerance: paintFlattenTolerance,\n      retainBudget: retain ? retain.budget : undefined,\n      shaders: paintShaders,\n    });\n    // No WebGL2 (jsdom), or a context that is lost for now: nothing to paint.\n    if (!renderer) return false;\n\n    const view = viewRef.current;\n    const { layerVisibility: vis, layerOrder: order } = gateRef.current;\n    const spans = debugFrame?.time();\n    const commands = drawLayers(\n      paintLayers,\n      helpersRef.current,\n      vis ?? NO_LAYER_VISIBILITY,\n      order,\n      view,\n      { width: w, height: h },\n      layerCacheRef.current,\n      undefined,\n      groups,\n      spans,\n      retainPolicy(retain),\n    );\n    renderer.render(commands, viewToMat3(view), spans ? { spans } : undefined);\n    debugFrame?.end(renderer.lastFrameStats());\n    markPainted();\n    return true;\n  }, [gateRef, helpersRef, inputsRef, lease, markPainted, ownCanvasRef, paintRectRef, paintTargetRef, viewRef]);\n  useInsertionEffect(() => {\n    paintRef.current = paint;\n  });\n\n  useEffect(() => {\n    const layerCache = layerCacheRef.current;\n    return () => { layerCache.clear(); };\n  }, []);\n}\n"],"mappings":";;;;;;;;;;;;;AAmCA,SAAgB,kBAAkB,gBAGhC;CACA,MAAM,oBAAoB,UAAU,cAAc;CAClD,MAAM,oBAAoB,OAAO,CAAC;CAKlC,OAAO;EAAE,mBAJiB,kBAAkB,kBAAkB,SAAS,CAAC,CAI/D;EAAmB,aAHR,kBAAkB;GACpC,kBAAkB,UAAU,kBAAkB,UAAU,KAAK;EAC/D,GAAG,CAAC,iBAAiB,CACO;CAAY;AAC1C;AAEA,SAAS,aAAa,QAA0D;CAC9E,IAAI,WAAW,OAAO,OAAO;CAC7B,MAAM,cAAc,QAAQ;CAC5B,OAAO,gBAAgB,SAAY,uBAAuB,EAAE,YAAY;AAC1E;;;;;;AAOA,SAAgB,eACd,UACA,OACA,QACA,OACA,aACM;CACN,MAAM,EAAE,gBAAgB,cAAc,iBAAiB;CACvD,MAAM,EAAE,WAAW,SAAS,SAAS,eAAe;CACpD,MAAM,gBAAgB,uBAA0B,IAAI,IAAI,CAAC;CAEzD,MAAM,QAAQ,kBAA2B;EACvC,MAAM,IAAI,eAAe,WAAW,aAAa;EACjD,IAAI,CAAC,GAAG,OAAO;EACf,MAAM,OAAO,aAAa;EAC1B,MAAM,EACJ,QAAQ,aAAa,OAAO,GAAG,QAAQ,GAAG,WAAW,MAAM,YAAY,OACvE,KAAK,OACL,kBAAkB,uBAClB,aAAa,QAAQ,SAAS,cAAc,WAC1C,UAAU;EACd,IAAI,MAAM,KAAK,MAAM,GAAG,OAAO;EAE/B,MAAM,aAAa,gBAAgB,MAAM,OAAO,WAAW;EAE3D,MAAM,WAAW,MAAM,KAAK,GAAG;GAAE,OAAO;GAAG,QAAQ;GAAG,KAAK;EAAM,GAAG;GAClE,MAAM;GACN,kBAAkB;GAClB,cAAc,SAAS,OAAO,SAAS;GACvC,SAAS;EACX,CAAC;EAED,IAAI,CAAC,UAAU,OAAO;EAEtB,MAAM,OAAO,QAAQ;EACrB,MAAM,EAAE,iBAAiB,KAAK,YAAY,UAAU,QAAQ;EAC5D,MAAM,QAAQ,YAAY,KAAK;EAC/B,MAAM,WAAW,WACf,aACA,WAAW,SACX,OAAO,qBACP,OACA,MACA;GAAE,OAAO;GAAG,QAAQ;EAAE,GACtB,cAAc,SACd,QACA,QACA,OACA,aAAa,MAAM,CACrB;EACA,SAAS,OAAO,UAAU,WAAW,IAAI,GAAG,QAAQ,EAAE,MAAM,IAAI,MAAS;EACzE,YAAY,IAAI,SAAS,eAAe,CAAC;EACzC,YAAY;EACZ,OAAO;CACT,GAAG;EAAC;EAAS;EAAY;EAAW;EAAO;EAAa;EAAc;EAAc;EAAgB;CAAO,CAAC;CAC5G,yBAAyB;EACvB,SAAS,UAAU;CACrB,CAAC;CAED,gBAAgB;EACd,MAAM,aAAa,cAAc;EACjC,aAAa;GAAE,WAAW,MAAM;EAAG;CACrC,GAAG,CAAC,CAAC;AACP"}

package/dist/canvas/useCanvasRenderer.js

@@ -1,31 +1,53 @@
-import { watchDevicePixelRatio as e } from "../core/device/watchDevicePixelRatio.js";
-import { leaseCanvasRenderer as t, shaderKeyOf as n } from "./canvasRenderer.js";
-import { getProgramSource as r, programSourceRegistry as i } from "@weasel-js/renderer";
-import { useEffect as a, useState as o } from "react";
+import { watchDevicePixelRatio } from "../core/device/watchDevicePixelRatio.js";
+import { leaseCanvasRenderer, shaderKeyOf } from "./canvasRenderer.js";
+import { getProgramSource, programSourceRegistry } from "@weasel-js/renderer";
+import { useEffect, useState } from "react";
+
 //#region src/canvas/useCanvasRenderer.ts
-function s() {
-	let [e] = o(t);
-	return a(() => () => e.release(), [e]), e;
+/**
+* The React lifetime of `leaseCanvasRenderer`: a stable lease for the
+* component's canvas, whose renderer and GL objects are freed on unmount.
+* Every canvas surface in core paints through this, so none can skip the
+* teardown.
+*/
+function useCanvasRenderer() {
+	const [lease] = useState(leaseCanvasRenderer);
+	useEffect(() => () => lease.release(), [lease]);
+	return lease;
 }
-function c(e, t) {
-	a(() => e.subscribeRestored(t), [e, t]);
+/** Repaint a surface when its canvas gets a lost GL context back. */
+function useRedrawOnRestore(lease, requestRedraw) {
+	useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);
 }
-function l(t, n) {
-	let r = n === void 0;
-	a(() => r ? e(() => t()) : void 0, [r, t]);
+/**
+* Repaint a surface that follows the ambient density when `devicePixelRatio`
+* changes. The lease reads the ratio at each paint, and nothing else asks for
+* one. A surface given its own `dpr` passes it here and is left alone.
+*/
+function useRedrawOnDensityChange(requestRedraw, dpr) {
+	const ambient = dpr === void 0;
+	useEffect(() => ambient ? watchDevicePixelRatio(() => requestRedraw()) : void 0, [ambient, requestRedraw]);
 }
-function u(e, t) {
-	let o = n(e);
-	a(() => {
-		if (!o) return;
-		let e = o.split("|"), n = e.map(r);
-		return i.subscribe(() => {
-			let i = e.map(r), a = i.some((e, t) => e !== n[t]);
-			n = i, a && t();
+/**
+* Repaint a surface when one of its custom programs is re-registered with new
+* source. The renderer recompiles on the frame that draws it, and nothing else
+* asks for that frame.
+*/
+function useRedrawOnShaderSource(shaders, requestRedraw) {
+	const key = shaderKeyOf(shaders);
+	useEffect(() => {
+		if (!key) return;
+		const ids = key.split("|");
+		let seen = ids.map(getProgramSource);
+		return programSourceRegistry.subscribe(() => {
+			const now = ids.map(getProgramSource);
+			const changed = now.some((src, i) => src !== seen[i]);
+			seen = now;
+			if (changed) requestRedraw();
 		});
-	}, [o, t]);
+	}, [key, requestRedraw]);
 }
-//#endregion
-export { s as useCanvasRenderer, l as useRedrawOnDensityChange, c as useRedrawOnRestore, u as useRedrawOnShaderSource };
 
+//#endregion
+export { useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource };
 //# sourceMappingURL=useCanvasRenderer.js.map

package/dist/canvas/useCanvasRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","ambient","dpr","watchDevicePixelRatio","useRedrawOnShaderSource","key","shaderKeyOf","shaders","ids","seen","getProgramSource","programSourceRegistry","now","changed","src","i"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { getProgramSource, programSourceRegistry, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { leaseCanvasRenderer, shaderKeyOf, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n\n/**\n * Repaint a surface when one of its custom programs is re-registered with new\n * source. The renderer recompiles on the frame that draws it, and nothing else\n * asks for that frame.\n */\nexport function useRedrawOnShaderSource(\n  shaders: readonly ShaderProgramHandle[] | undefined,\n  requestRedraw: () => void,\n): void {\n  const key = shaderKeyOf(shaders);\n  useEffect(() => {\n    if (!key) return;\n    const ids = key.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [key, requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT;AAGA,SAAgBI,EAAmB,GAA4B,GAAiC;CAC9F,QAAgBJ,EAAM,kBAAkBK,CAAa,GAAG,CAACL,GAAOK,CAAa,CAAC;AAChF;AAOA,SAAgBC,EAAyB,GAA2B,GAAoB;CACtF,IAAMC,IAAUC,MAAQ,KAAA;CACxB,QAAiBD,IAAUE,QAA4BJ,EAAc,CAAC,IAAI,KAAA,GAAY,CAACE,GAASF,CAAa,CAAC;AAChH;AAOA,SAAgBK,EACd,GACA,GACM;CACN,IAAMC,IAAMC,EAAYC,CAAO;CAC/B,QAAgB;EACd,IAAI,CAACF,GAAK;EACV,IAAMG,IAAMH,EAAI,MAAM,GAAG,GACrBI,IAAOD,EAAI,IAAIE,CAAgB;EACnC,OAAOC,EAAsB,gBAAgB;GAC3C,IAAMC,IAAMJ,EAAI,IAAIE,CAAgB,GAC9BG,IAAUD,EAAI,MAAM,GAAK,MAAME,MAAQL,EAAKM,EAAE;GAEpD,AADA,IAAOH,GACHC,KAASd,EAAc;EAC7B,CAAC;CACH,GAAG,CAACM,GAAKN,CAAa,CAAC;AACzB"}
+{"version":3,"file":"useCanvasRenderer.js","names":[],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { getProgramSource, programSourceRegistry, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { leaseCanvasRenderer, shaderKeyOf, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n\n/**\n * Repaint a surface when one of its custom programs is re-registered with new\n * source. The renderer recompiles on the frame that draws it, and nothing else\n * asks for that frame.\n */\nexport function useRedrawOnShaderSource(\n  shaders: readonly ShaderProgramHandle[] | undefined,\n  requestRedraw: () => void,\n): void {\n  const key = shaderKeyOf(shaders);\n  useEffect(() => {\n    if (!key) return;\n    const ids = key.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [key, requestRedraw]);\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,oBAAyC;CACvD,MAAM,CAAC,SAAS,SAAS,mBAAmB;CAC5C,sBAAsB,MAAM,QAAQ,GAAG,CAAC,KAAK,CAAC;CAC9C,OAAO;AACT;;AAGA,SAAgB,mBAAmB,OAA4B,eAAiC;CAC9F,gBAAgB,MAAM,kBAAkB,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC;AAChF;;;;;;AAOA,SAAgB,yBAAyB,eAA2B,KAAoB;CACtF,MAAM,UAAU,QAAQ;CACxB,gBAAiB,UAAU,4BAA4B,cAAc,CAAC,IAAI,QAAY,CAAC,SAAS,aAAa,CAAC;AAChH;;;;;;AAOA,SAAgB,wBACd,SACA,eACM;CACN,MAAM,MAAM,YAAY,OAAO;CAC/B,gBAAgB;EACd,IAAI,CAAC,KAAK;EACV,MAAM,MAAM,IAAI,MAAM,GAAG;EACzB,IAAI,OAAO,IAAI,IAAI,gBAAgB;EACnC,OAAO,sBAAsB,gBAAgB;GAC3C,MAAM,MAAM,IAAI,IAAI,gBAAgB;GACpC,MAAM,UAAU,IAAI,MAAM,KAAK,MAAM,QAAQ,KAAK,EAAE;GACpD,OAAO;GACP,IAAI,SAAS,cAAc;EAC7B,CAAC;CACH,GAAG,CAAC,KAAK,aAAa,CAAC;AACzB"}

package/dist/canvas/useCanvasSurface.js

@@ -1,31 +1,49 @@
-import { useCanvasRenderer as e, useRedrawOnDensityChange as t, useRedrawOnRestore as n, useRedrawOnShaderSource as r } from "./useCanvasRenderer.js";
-import { useFrameLoop as i } from "./useFrameLoop.js";
-import { useLateContentRedraw as a } from "./useLateContentRedraw.js";
-import { useRedrawOn as o } from "./useRedrawOn.js";
-import { useEffect as s, useLayoutEffect as c, useRef as l } from "react";
+import { useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource } from "./useCanvasRenderer.js";
+import { useFrameLoop } from "./useFrameLoop.js";
+import { useLateContentRedraw } from "./useLateContentRedraw.js";
+import { useRedrawOn } from "./useRedrawOn.js";
+import { useEffect, useLayoutEffect, useRef } from "react";
+
 //#region src/canvas/useCanvasSurface.ts
-function u(s, c = {}) {
-	let l = e(), u = i(() => s(l), c), { requestRedraw: f } = u;
-	return n(l, f), t(f, c.dpr), a(f), r(c.shaders, f), o(c.redrawOn, f), d(c.paintOnCommit === !0, () => s(l), f), {
-		...u,
-		lease: l
+/**
+* Everything a canvas surface in core needs around its paint: the renderer
+* lease, the frame loop, and a repaint for each thing that changes pixels with
+* no React render behind it — a restored GL context, a density change, late
+* content, a re-registered shader, and the caller's own `redrawOn` sources.
+*
+* @param paint As `useFrameLoop`'s, handed the lease to draw through.
+*/
+function useCanvasSurface(paint, options = {}) {
+	const lease = useCanvasRenderer();
+	const loop = useFrameLoop(() => paint(lease), options);
+	const { requestRedraw } = loop;
+	useRedrawOnRestore(lease, requestRedraw);
+	useRedrawOnDensityChange(requestRedraw, options.dpr);
+	useLateContentRedraw(requestRedraw);
+	useRedrawOnShaderSource(options.shaders, requestRedraw);
+	useRedrawOn(options.redrawOn, requestRedraw);
+	useRedrawOnCommit(options.onCommit, () => paint(lease), requestRedraw);
+	return {
+		...loop,
+		lease
 	};
 }
-function d(e, t, n) {
-	let r = l(!1);
-	c(() => {
-		if (e) {
-			if (r.current) {
-				n();
-				return;
-			}
-			r.current = t(), r.current || n();
+function useRedrawOnCommit(mode, paintNow, requestRedraw) {
+	const paintedRef = useRef(false);
+	useLayoutEffect(() => {
+		if (!mode) return;
+		if (mode === "redraw" || paintedRef.current) {
+			requestRedraw();
+			return;
 		}
-	}), s(() => () => {
-		r.current = !1;
+		paintedRef.current = paintNow();
+		if (!paintedRef.current) requestRedraw();
+	});
+	useEffect(() => () => {
+		paintedRef.current = false;
 	}, []);
 }
-//#endregion
-export { u as useCanvasSurface };
 
+//#endregion
+export { useCanvasSurface };
 //# sourceMappingURL=useCanvasSurface.js.map

package/dist/canvas/useCanvasSurface.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasSurface.js","names":["useCanvasSurface","lease","useCanvasRenderer","loop","useFrameLoop","paint","options","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","useLateContentRedraw","useRedrawOnShaderSource","useRedrawOn","usePaintOnCommit","paintedRef","useRef","useLayoutEffect","on","paintNow","useEffect"],"sources":["../../src/canvas/useCanvasSurface.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef } from 'react';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { RedrawSource } from '../core/layers/render';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport {\n  useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource,\n} from './useCanvasRenderer';\nimport { useFrameLoop, type FrameLoop, type FrameLoopOptions } from './useFrameLoop';\nimport { useLateContentRedraw } from './useLateContentRedraw';\nimport { useRedrawOn } from './useRedrawOn';\n\n/** What a surface tells {@link useCanvasSurface} about itself, beyond its paint. */\nexport interface CanvasSurfaceOptions extends FrameLoopOptions {\n  /** The surface's own density. Omit to follow `devicePixelRatio`. */\n  dpr?: number;\n  /** External state the paint reads; each source repaints when it notifies. */\n  redrawOn?: readonly RedrawSource[];\n  /** Custom programs the paint draws with; new source for one repaints. */\n  shaders?: readonly ShaderProgramHandle[];\n  /** Mark the surface dirty on every committed render, and paint the first\n   *  one in place, in the caller's stack, so the first frame shown is the\n   *  content and not a blank canvas. For a surface whose paint reads its\n   *  props. */\n  paintOnCommit?: boolean;\n}\n\n/** A surface's frame loop and the renderer lease its paint draws through. */\nexport interface CanvasSurface extends FrameLoop {\n  lease: CanvasRendererLease;\n}\n\n/**\n * Everything a canvas surface in core needs around its paint: the renderer\n * lease, the frame loop, and a repaint for each thing that changes pixels with\n * no React render behind it — a restored GL context, a density change, late\n * content, a re-registered shader, and the caller's own `redrawOn` sources.\n *\n * @param paint As `useFrameLoop`'s, handed the lease to draw through.\n */\nexport function useCanvasSurface(\n  paint: (lease: CanvasRendererLease) => boolean,\n  options: CanvasSurfaceOptions = {},\n): CanvasSurface {\n  const lease = useCanvasRenderer();\n  const loop = useFrameLoop(() => paint(lease), options);\n  const { requestRedraw } = loop;\n  useRedrawOnRestore(lease, requestRedraw);\n  useRedrawOnDensityChange(requestRedraw, options.dpr);\n  useLateContentRedraw(requestRedraw);\n  useRedrawOnShaderSource(options.shaders, requestRedraw);\n  useRedrawOn(options.redrawOn, requestRedraw);\n  usePaintOnCommit(options.paintOnCommit === true, () => paint(lease), requestRedraw);\n  return { ...loop, lease };\n}\n\nfunction usePaintOnCommit(on: boolean, paintNow: () => boolean, requestRedraw: () => void): void {\n  const paintedRef = useRef(false);\n  // No dependency array: the paint reads whatever the render did.\n  useLayoutEffect(() => {\n    if (!on) return;\n    if (paintedRef.current) { requestRedraw(); return; }\n    paintedRef.current = paintNow();\n    if (!paintedRef.current) requestRedraw();\n  });\n  // The renderer is freed on unmount; a remount (StrictMode) paints its first\n  // frame in place again.\n  useEffect(() => () => { paintedRef.current = false; }, []);\n}\n"],"mappings":";;;;;;AAuCA,SAAgBA,EACd,GACA,IAAgC,CAAC,GAClB;CACf,IAAMC,IAAQC,EAAkB,GAC1BC,IAAOC,QAAmBC,EAAMJ,CAAK,GAAGK,CAAO,GAC/C,EAAE,qBAAkBH;CAO1B,OANAI,EAAmBN,GAAOO,CAAa,GACvCC,EAAyBD,GAAeF,EAAQ,GAAG,GACnDI,EAAqBF,CAAa,GAClCG,EAAwBL,EAAQ,SAASE,CAAa,GACtDI,EAAYN,EAAQ,UAAUE,CAAa,GAC3CK,EAAiBP,EAAQ,kBAAkB,UAAYD,EAAMJ,CAAK,GAAGO,CAAa,GAC3E;EAAE,GAAGL;EAAM;CAAM;AAC1B;AAEA,SAASU,EAAiB,GAAa,GAAyB,GAAiC;CAC/F,IAAMC,IAAaC,EAAO,EAAK;CAU/B,AARAC,QAAsB;EACpB,IAAKC,GACL;OAAIH,EAAW,SAAS;IAAE,EAAc;IAAG;GAAQ;GAEnD,AADA,EAAW,UAAUI,EAAS,GACzBJ,EAAW,WAASN,EAAc;EAFY;CAGrD,CAAC,GAGDW,cAAsB;EAAE,EAAW,UAAU;CAAO,GAAG,CAAC,CAAC;AAC3D"}
+{"version":3,"file":"useCanvasSurface.js","names":[],"sources":["../../src/canvas/useCanvasSurface.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef } from 'react';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { RedrawSource } from '../core/layers/render';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport {\n  useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource,\n} from './useCanvasRenderer';\nimport { useFrameLoop, type FrameLoop, type FrameLoopOptions } from './useFrameLoop';\nimport { useLateContentRedraw } from './useLateContentRedraw';\nimport { useRedrawOn } from './useRedrawOn';\n\n/** What a surface tells {@link useCanvasSurface} about itself, beyond its paint. */\nexport interface CanvasSurfaceOptions extends FrameLoopOptions {\n  /** The surface's own density. Omit to follow `devicePixelRatio`. */\n  dpr?: number;\n  /** External state the paint reads; each source repaints when it notifies. */\n  redrawOn?: readonly RedrawSource[];\n  /** Custom programs the paint draws with; new source for one repaints. */\n  shaders?: readonly ShaderProgramHandle[];\n  /** Mark the surface dirty on every committed render, so a surface whose\n   *  paint reads its props cannot paint them stale. `'paint'` also paints the\n   *  first commit in place, in the caller's stack, so the first frame shown is\n   *  the content and not a blank canvas. */\n  onCommit?: 'redraw' | 'paint';\n}\n\n/** A surface's frame loop and the renderer lease its paint draws through. */\nexport interface CanvasSurface extends FrameLoop {\n  lease: CanvasRendererLease;\n}\n\n/**\n * Everything a canvas surface in core needs around its paint: the renderer\n * lease, the frame loop, and a repaint for each thing that changes pixels with\n * no React render behind it — a restored GL context, a density change, late\n * content, a re-registered shader, and the caller's own `redrawOn` sources.\n *\n * @param paint As `useFrameLoop`'s, handed the lease to draw through.\n */\nexport function useCanvasSurface(\n  paint: (lease: CanvasRendererLease) => boolean,\n  options: CanvasSurfaceOptions = {},\n): CanvasSurface {\n  const lease = useCanvasRenderer();\n  const loop = useFrameLoop(() => paint(lease), options);\n  const { requestRedraw } = loop;\n  useRedrawOnRestore(lease, requestRedraw);\n  useRedrawOnDensityChange(requestRedraw, options.dpr);\n  useLateContentRedraw(requestRedraw);\n  useRedrawOnShaderSource(options.shaders, requestRedraw);\n  useRedrawOn(options.redrawOn, requestRedraw);\n  useRedrawOnCommit(options.onCommit, () => paint(lease), requestRedraw);\n  return { ...loop, lease };\n}\n\nfunction useRedrawOnCommit(\n  mode: CanvasSurfaceOptions['onCommit'],\n  paintNow: () => boolean,\n  requestRedraw: () => void,\n): void {\n  const paintedRef = useRef(false);\n  // No dependency array: the paint reads whatever the render did.\n  useLayoutEffect(() => {\n    if (!mode) return;\n    if (mode === 'redraw' || paintedRef.current) { requestRedraw(); return; }\n    paintedRef.current = paintNow();\n    if (!paintedRef.current) requestRedraw();\n  });\n  // The renderer is freed on unmount; a remount (StrictMode) paints its first\n  // frame in place again.\n  useEffect(() => () => { paintedRef.current = false; }, []);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAuCA,SAAgB,iBACd,OACA,UAAgC,CAAC,GAClB;CACf,MAAM,QAAQ,kBAAkB;CAChC,MAAM,OAAO,mBAAmB,MAAM,KAAK,GAAG,OAAO;CACrD,MAAM,EAAE,kBAAkB;CAC1B,mBAAmB,OAAO,aAAa;CACvC,yBAAyB,eAAe,QAAQ,GAAG;CACnD,qBAAqB,aAAa;CAClC,wBAAwB,QAAQ,SAAS,aAAa;CACtD,YAAY,QAAQ,UAAU,aAAa;CAC3C,kBAAkB,QAAQ,gBAAgB,MAAM,KAAK,GAAG,aAAa;CACrE,OAAO;EAAE,GAAG;EAAM;CAAM;AAC1B;AAEA,SAAS,kBACP,MACA,UACA,eACM;CACN,MAAM,aAAa,OAAO,KAAK;CAE/B,sBAAsB;EACpB,IAAI,CAAC,MAAM;EACX,IAAI,SAAS,YAAY,WAAW,SAAS;GAAE,cAAc;GAAG;EAAQ;EACxE,WAAW,UAAU,SAAS;EAC9B,IAAI,CAAC,WAAW,SAAS,cAAc;CACzC,CAAC;CAGD,sBAAsB;EAAE,WAAW,UAAU;CAAO,GAAG,CAAC,CAAC;AAC3D"}

package/dist/canvas/useCanvasView.js

@@ -1,9 +1,16 @@
-import { normalizeView as e, sameView as t } from "../core/viewport/view.js";
-import { clampView as n } from "../core/viewport/clampView.js";
-import { useCallback as r, useRef as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
+import { normalizeView, sameView } from "../core/viewport/view.js";
+import { clampView } from "../core/viewport/clampView.js";
+import { useCallback, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/useCanvasView.ts
-var o = {
+/**
+* A camera: held in a ref when uncontrolled, taken from the `view` option when
+* controlled, with one write path and one subscriber list over both.
+* `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each
+* `<CanvasView>` makes its own.
+*/
+var IDENTITY = {
 	x: 0,
 	y: 0,
 	scale: {
@@ -11,55 +18,80 @@ var o = {
 		y: 1
 	}
 };
-function s(s) {
-	let { view: c, defaultView: l, onViewChange: u, viewBounds: d, dims: f, requestRedraw: p } = s, m = typeof c == "function" ? c : void 0, h = c === void 0 || m ? void 0 : e(c), g = i(h ?? e(l ?? o)), _ = i(/* @__PURE__ */ new Set()), v = a({
-		controlled: c !== void 0,
-		derived: m,
-		onViewChange: u,
-		viewBounds: d,
-		dims: f,
-		requestRedraw: p
-	}), y = i(!1), b = r(() => {
-		let t = v.current.derived;
-		return t ? e(t()) : g.current;
-	}, [v]), x = r((t, r) => {
-		let { controlled: i, derived: a, onViewChange: o, viewBounds: s, dims: c, requestRedraw: l } = v.current, u = e(t), d = s ? n(u, s, c()) : u;
-		if (i) {
-			r && !y.current && (y.current = !0, console.warn(o ? "[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path." : "[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.")), o?.(d), a && l();
+function useCanvasView(opts) {
+	const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;
+	const derived = typeof viewProp === "function" ? viewProp : void 0;
+	const controlledView = viewProp === void 0 || derived ? void 0 : normalizeView(viewProp);
+	const viewRef = useRef(controlledView ?? normalizeView(defaultView ?? IDENTITY));
+	const viewSubsRef = useRef(/* @__PURE__ */ new Set());
+	const live = useLatest({
+		controlled: viewProp !== void 0,
+		derived,
+		onViewChange,
+		viewBounds,
+		dims,
+		requestRedraw
+	});
+	const controlledWarnedRef = useRef(false);
+	const getView = useCallback(() => {
+		const thunk = live.current.derived;
+		return thunk ? normalizeView(thunk()) : viewRef.current;
+	}, [live]);
+	const write = useCallback((next, imperative) => {
+		const { controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw } = live.current;
+		const valid = normalizeView(next);
+		const clamped = bounds ? clampView(valid, bounds, size()) : valid;
+		if (controlled) {
+			if (imperative && !controlledWarnedRef.current) {
+				controlledWarnedRef.current = true;
+				console.warn(forward ? "[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path." : "[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.");
+			}
+			forward?.(clamped);
+			if (derived) redraw();
 			return;
 		}
-		g.current = d;
-		for (let e of _.current) e(d);
-		o?.(d), l();
-	}, [v]), S = r((e) => {
-		x(typeof e == "function" ? e(b()) : e, !0);
-	}, [x, b]), C = r((e) => {
-		x(e, !1);
-	}, [x]), w = r((e) => (_.current.add(e), () => {
-		_.current.delete(e);
-	}), []), T = i(!1);
+		viewRef.current = clamped;
+		for (const fn of viewSubsRef.current) fn(clamped);
+		forward?.(clamped);
+		redraw();
+	}, [live]);
+	const setView = useCallback((next) => {
+		write(typeof next === "function" ? next(getView()) : next, true);
+	}, [write, getView]);
+	const setViewFromInput = useCallback((next) => {
+		write(next, false);
+	}, [write]);
+	const subscribeView = useCallback((fn) => {
+		viewSubsRef.current.add(fn);
+		return () => {
+			viewSubsRef.current.delete(fn);
+		};
+	}, []);
+	const controlledMovedRef = useRef(false);
+	const adoptControlled = () => {
+		if (!controlledView) return;
+		controlledMovedRef.current ||= !sameView(viewRef.current, controlledView);
+		viewRef.current = controlledView;
+	};
 	return {
-		viewRef: g,
-		controlled: h,
-		setView: S,
-		setViewFromInput: C,
-		getView: b,
-		subscribeView: w,
-		adoptControlled: () => {
-			h && (T.current ||= !t(g.current, h), g.current = h);
-		},
-		announceControlled: r(() => {
-			if (T.current) {
-				T.current = !1;
-				for (let e of _.current) e(g.current);
-			}
+		viewRef,
+		controlled: controlledView,
+		setView,
+		setViewFromInput,
+		getView,
+		subscribeView,
+		adoptControlled,
+		announceControlled: useCallback(() => {
+			if (!controlledMovedRef.current) return;
+			controlledMovedRef.current = false;
+			for (const fn of viewSubsRef.current) fn(viewRef.current);
 		}, []),
-		clearSubscribers: r(() => {
-			_.current.clear();
+		clearSubscribers: useCallback(() => {
+			viewSubsRef.current.clear();
 		}, [])
 	};
 }
-//#endregion
-export { s as useCanvasView };
 
+//#endregion
+export { useCanvasView };
 //# sourceMappingURL=useCanvasView.js.map

package/dist/canvas/useCanvasView.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasView.js","names":["IDENTITY","useCanvasView","viewProp","opts","derived","controlledView","normalizeView","viewRef","useRef","defaultView","viewSubsRef","live","useLatest","controlledWarnedRef","getView","useCallback","thunk","write","forward","bounds","size","redraw","valid","next","clamped","clampView","controlled","imperative","fn","setView","setViewFromInput","subscribeView","controlledMovedRef","sameView"],"sources":["../../src/canvas/useCanvasView.ts"],"sourcesContent":["/**\n * A camera: held in a ref when uncontrolled, taken from the `view` option when\n * controlled, with one write path and one subscriber list over both.\n * `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each\n * `<CanvasView>` makes its own.\n */\nimport { useCallback, useRef, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dims } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { clampView } from 'core/viewport/clampView';\nimport { normalizeView, sameView, type View } from 'core/viewport/view';\n\n/** The view props a canvas takes for its camera. */\nexport interface CameraProps {\n  /** Controlled viewport. When supplied, the canvas does not own the value —\n   *  the consumer must supply `onViewChange` and re-render with the new\n   *  view. See `View` JSDoc for the camera-position convention. */\n  view?: View;\n  /** Initial viewport for the uncontrolled path. Default `{x:0, y:0}`. */\n  defaultView?: View;\n  /** Fires whenever the viewport changes — in both controlled and\n   *  uncontrolled modes. */\n  onViewChange?: (next: View) => void;\n  /**\n   * Optional world-space rect that constrains pan: every write to the view passes through\n   * `clampView` first, keeping the visible rect inside `viewBounds`. An axis where the\n   * visible rect is larger than the bounds is centered. Has no effect on `scale`.\n   */\n  viewBounds?: { x: number; y: number; width: number; height: number };\n}\n\n/** Inputs to {@link useCanvasView}: the camera's view props and what a write\n *  needs from whatever the camera looks through. */\nexport interface CanvasViewOptions {\n  /** Supplied, the camera is controlled. A thunk is a camera derived from\n   *  something else, read fresh at every {@link CanvasViewState.getView}. */\n  view: View | (() => View) | undefined;\n  defaultView: View | undefined;\n  onViewChange: ((next: View) => void) | undefined;\n  viewBounds: Bounds | undefined;\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  dims: () => Dims;\n  requestRedraw: () => void;\n}\n\n/** What `useCanvasView` hands back. The owner decides when in a commit\n *  the two controlled steps run, since they have to sit among its own effects. */\nexport interface CanvasViewState {\n  /** The view in effect. Written by a write when uncontrolled and by\n   *  `adoptControlled` when controlled. A camera derived by a thunk is not\n   *  kept here: read `getView`. */\n  viewRef: MutableRefObject<View>;\n  /** This render's controlled view, absent when the camera is uncontrolled or\n   *  derived. A new object every render, so compare its numbers. */\n  controlled: View | undefined;\n  /** The imperative write. Controlled, it is forwarded to `onViewChange`\n   *  instead of applied, and says so once per mount. */\n  setView: (next: View | ((current: View) => View)) => void;\n  /** The write input makes. Controlled, forwarding it to `onViewChange` is how\n   *  the owner hears of a pan at all, so nothing is warned. */\n  setViewFromInput: (next: View) => void;\n  getView: () => View;\n  subscribeView: (fn: (v: View) => void) => () => void;\n  /** Take this render's controlled view into `viewRef`. Call from an insertion effect. */\n  adoptControlled: () => void;\n  /** Tell subscribers of a controlled view that moved since the last call.\n   *  A controlled view reaches the ref with no write, so this is where they\n   *  hear of it. Call from a layout effect. */\n  announceControlled: () => void;\n  /** Drop every subscriber, on unmount. */\n  clearSubscribers: () => void;\n}\n\nconst IDENTITY: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\nexport function useCanvasView(opts: CanvasViewOptions): CanvasViewState {\n  const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;\n  const derived = typeof viewProp === 'function' ? viewProp : undefined;\n  const controlledView = viewProp === undefined || derived ? undefined : normalizeView(viewProp as View);\n  // The uncontrolled view lives in a ref, not `useState`, so a camera moving\n  // at 60 Hz costs no React render; DOM that mirrors it subscribes instead.\n  const viewRef = useRef<View>(controlledView ?? normalizeView(defaultView ?? IDENTITY));\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const live = useLatest({\n    controlled: viewProp !== undefined, derived, onViewChange, viewBounds, dims, requestRedraw,\n  });\n  const controlledWarnedRef = useRef(false);\n\n  const getView = useCallback((): View => {\n    const thunk = live.current.derived;\n    return thunk ? normalizeView(thunk()) : viewRef.current;\n  }, [live]);\n\n  const write = useCallback((next: View, imperative: boolean): void => {\n    const {\n      controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw,\n    } = live.current;\n    const valid = normalizeView(next);\n    const clamped = bounds ? clampView(valid, bounds, size()) : valid;\n    if (controlled) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      if (imperative && !controlledWarnedRef.current) {\n        controlledWarnedRef.current = true;\n        console.warn(forward\n          ? '[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path.'\n          : '[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.');\n      }\n      forward?.(clamped);\n      // A derived camera has no prop to change, so nothing else repaints it.\n      if (derived) redraw();\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    forward?.(clamped);\n    redraw();\n  }, [live]);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    write(typeof next === 'function' ? next(getView()) : next, true);\n  }, [write, getView]);\n  const setViewFromInput = useCallback((next: View) => { write(next, false); }, [write]);\n\n  const subscribeView = useCallback((fn: (v: View) => void) => {\n    viewSubsRef.current.add(fn);\n    return () => { viewSubsRef.current.delete(fn); };\n  }, []);\n\n  const controlledMovedRef = useRef(false);\n  // A closure over this render's prop, not a ref read: the owner calls it\n  // from the same render's insertion effect.\n  const adoptControlled = (): void => {\n    if (!controlledView) return;\n    controlledMovedRef.current ||= !sameView(viewRef.current, controlledView);\n    viewRef.current = controlledView;\n  };\n  const announceControlled = useCallback(() => {\n    if (!controlledMovedRef.current) return;\n    controlledMovedRef.current = false;\n    for (const fn of viewSubsRef.current) fn(viewRef.current);\n  }, []);\n  const clearSubscribers = useCallback(() => { viewSubsRef.current.clear(); }, []);\n\n  return {\n    viewRef, controlled: controlledView, setView, setViewFromInput, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  };\n}\n"],"mappings":";;;;;AA0EA,IAAMA,IAAiB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;AAE3D,SAAgBC,EAAc,GAA0C;CACtE,IAAM,EAAE,MAAMC,GAAU,gBAAa,iBAAc,eAAY,SAAM,qBAAkBC,GACjFC,IAAU,OAAOF,KAAa,aAAaA,IAAW,KAAA,GACtDG,IAAiBH,MAAa,KAAA,KAAaE,IAAU,KAAA,IAAYE,EAAcJ,CAAgB,GAG/FK,IAAUC,EAAaH,KAAkBC,EAAcG,KAAeT,CAAQ,CAAC,GAC/EU,IAAcF,kBAA+B,IAAI,IAAI,CAAC,GACtDG,IAAOC,EAAU;EACrB,YAAYV,MAAa,KAAA;EAAW;EAAS;EAAc;EAAY;EAAM;CAC/E,CAAC,GACKW,IAAsBL,EAAO,EAAK,GAElCM,IAAUC,QAAwB;EACtC,IAAMC,IAAQL,EAAK,QAAQ;EAC3B,OAAOK,IAAQV,EAAcU,EAAM,CAAC,IAAIT,EAAQ;CAClD,GAAG,CAACI,CAAI,CAAC,GAEHM,IAAQF,GAAa,GAAY,MAA8B;EACnE,IAAM,EACJ,eAAY,YAAS,cAAcG,GAAS,YAAYC,GAAQ,MAAMC,GAAM,eAAeC,MACzFV,EAAK,SACHW,IAAQhB,EAAciB,CAAI,GAC1BC,IAAUL,IAASM,EAAUH,GAAOH,GAAQC,EAAK,CAAC,IAAIE;EAC5D,IAAII,GAAY;GAWd,AARIC,KAAc,CAACd,EAAoB,YACrC,EAAoB,UAAU,IAC9B,QAAQ,KAAKK,IACT,wMACA,4LAA4L,IAElMA,IAAUM,CAAO,GAEbpB,KAASiB,EAAO;GACpB;EACF;EACA,EAAQ,UAAUG;EAClB,KAAK,IAAMI,KAAMlB,EAAY,SAAS,EAAGc,CAAO;EAEhD,AADAN,IAAUM,CAAO,GACjBH,EAAO;CACT,GAAG,CAACV,CAAI,CAAC,GAEHkB,IAAUd,GAAa,MAA2C;EACtE,EAAM,OAAOQ,KAAS,aAAaA,EAAKT,EAAQ,CAAC,IAAIS,GAAM,EAAI;CACjE,GAAG,CAACN,GAAOH,CAAO,CAAC,GACbgB,IAAmBf,GAAa,MAAe;EAAE,EAAMQ,GAAM,EAAK;CAAG,GAAG,CAACN,CAAK,CAAC,GAE/Ec,IAAgBhB,GAAa,OACjCL,EAAY,QAAQ,IAAIkB,CAAE,SACb;EAAE,EAAY,QAAQ,OAAOA,CAAE;CAAG,IAC9C,CAAC,CAAC,GAECI,IAAqBxB,EAAO,EAAK;CAevC,OAAO;EACL;EAAS,YAAYH;EAAgB;EAAS;EAAkB;EAAS;EACzE,uBAdkC;GAClC,AAAKA,MACL,EAAmB,YAAY,CAAC4B,EAAS1B,EAAQ,SAASF,CAAc,GACxE,EAAQ,UAAUA;EACpB;EAUmB,oBATQU,QAAkB;GAC3C,IAAKiB,EAAmB,SACxB;MAAmB,UAAU;IAC7B,KAAK,IAAMJ,KAAMlB,EAAY,SAAS,EAAGH,EAAQ,OAAO;GAD3B;EAE/B,GAAG,CAAC,CAKe;EAAoB,kBAJdQ,QAAkB;GAAE,EAAY,QAAQ,MAAM;EAAG,GAAG,CAAC,CAIvC;CACvC;AACF"}
+{"version":3,"file":"useCanvasView.js","names":[],"sources":["../../src/canvas/useCanvasView.ts"],"sourcesContent":["/**\n * A camera: held in a ref when uncontrolled, taken from the `view` option when\n * controlled, with one write path and one subscriber list over both.\n * `<SceneCanvas>` makes the one its `<Canvas>` looks through, and each\n * `<CanvasView>` makes its own.\n */\nimport { useCallback, useRef, type MutableRefObject } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Dims } from 'core/layers/render';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { clampView } from 'core/viewport/clampView';\nimport { normalizeView, sameView, type View } from 'core/viewport/view';\n\n/** The view props a canvas takes for its camera. */\nexport interface CameraProps {\n  /** Controlled viewport. When supplied, the canvas does not own the value —\n   *  the consumer must supply `onViewChange` and re-render with the new\n   *  view. See `View` JSDoc for the camera-position convention. */\n  view?: View;\n  /** Initial viewport for the uncontrolled path. Default `{x:0, y:0}`. */\n  defaultView?: View;\n  /** Fires whenever the viewport changes — in both controlled and\n   *  uncontrolled modes. */\n  onViewChange?: (next: View) => void;\n  /**\n   * Optional world-space rect that constrains pan: every write to the view passes through\n   * `clampView` first, keeping the visible rect inside `viewBounds`. An axis where the\n   * visible rect is larger than the bounds is centered. Has no effect on `scale`.\n   */\n  viewBounds?: { x: number; y: number; width: number; height: number };\n}\n\n/** Inputs to {@link useCanvasView}: the camera's view props and what a write\n *  needs from whatever the camera looks through. */\nexport interface CanvasViewOptions {\n  /** Supplied, the camera is controlled. A thunk is a camera derived from\n   *  something else, read fresh at every {@link CanvasViewState.getView}. */\n  view: View | (() => View) | undefined;\n  defaultView: View | undefined;\n  onViewChange: ((next: View) => void) | undefined;\n  viewBounds: Bounds | undefined;\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  dims: () => Dims;\n  requestRedraw: () => void;\n}\n\n/** What `useCanvasView` hands back. The owner decides when in a commit\n *  the two controlled steps run, since they have to sit among its own effects. */\nexport interface CanvasViewState {\n  /** The view in effect. Written by a write when uncontrolled and by\n   *  `adoptControlled` when controlled. A camera derived by a thunk is not\n   *  kept here: read `getView`. */\n  viewRef: MutableRefObject<View>;\n  /** This render's controlled view, absent when the camera is uncontrolled or\n   *  derived. A new object every render, so compare its numbers. */\n  controlled: View | undefined;\n  /** The imperative write. Controlled, it is forwarded to `onViewChange`\n   *  instead of applied, and says so once per mount. */\n  setView: (next: View | ((current: View) => View)) => void;\n  /** The write input makes. Controlled, forwarding it to `onViewChange` is how\n   *  the owner hears of a pan at all, so nothing is warned. */\n  setViewFromInput: (next: View) => void;\n  getView: () => View;\n  subscribeView: (fn: (v: View) => void) => () => void;\n  /** Take this render's controlled view into `viewRef`. Call from an insertion effect. */\n  adoptControlled: () => void;\n  /** Tell subscribers of a controlled view that moved since the last call.\n   *  A controlled view reaches the ref with no write, so this is where they\n   *  hear of it. Call from a layout effect. */\n  announceControlled: () => void;\n  /** Drop every subscriber, on unmount. */\n  clearSubscribers: () => void;\n}\n\nconst IDENTITY: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\nexport function useCanvasView(opts: CanvasViewOptions): CanvasViewState {\n  const { view: viewProp, defaultView, onViewChange, viewBounds, dims, requestRedraw } = opts;\n  const derived = typeof viewProp === 'function' ? viewProp : undefined;\n  const controlledView = viewProp === undefined || derived ? undefined : normalizeView(viewProp as View);\n  // The uncontrolled view lives in a ref, not `useState`, so a camera moving\n  // at 60 Hz costs no React render; DOM that mirrors it subscribes instead.\n  const viewRef = useRef<View>(controlledView ?? normalizeView(defaultView ?? IDENTITY));\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const live = useLatest({\n    controlled: viewProp !== undefined, derived, onViewChange, viewBounds, dims, requestRedraw,\n  });\n  const controlledWarnedRef = useRef(false);\n\n  const getView = useCallback((): View => {\n    const thunk = live.current.derived;\n    return thunk ? normalizeView(thunk()) : viewRef.current;\n  }, [live]);\n\n  const write = useCallback((next: View, imperative: boolean): void => {\n    const {\n      controlled, derived, onViewChange: forward, viewBounds: bounds, dims: size, requestRedraw: redraw,\n    } = live.current;\n    const valid = normalizeView(next);\n    const clamped = bounds ? clampView(valid, bounds, size()) : valid;\n    if (controlled) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      if (imperative && !controlledWarnedRef.current) {\n        controlledWarnedRef.current = true;\n        console.warn(forward\n          ? '[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path.'\n          : '[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.');\n      }\n      forward?.(clamped);\n      // A derived camera has no prop to change, so nothing else repaints it.\n      if (derived) redraw();\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    forward?.(clamped);\n    redraw();\n  }, [live]);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    write(typeof next === 'function' ? next(getView()) : next, true);\n  }, [write, getView]);\n  const setViewFromInput = useCallback((next: View) => { write(next, false); }, [write]);\n\n  const subscribeView = useCallback((fn: (v: View) => void) => {\n    viewSubsRef.current.add(fn);\n    return () => { viewSubsRef.current.delete(fn); };\n  }, []);\n\n  const controlledMovedRef = useRef(false);\n  // A closure over this render's prop, not a ref read: the owner calls it\n  // from the same render's insertion effect.\n  const adoptControlled = (): void => {\n    if (!controlledView) return;\n    controlledMovedRef.current ||= !sameView(viewRef.current, controlledView);\n    viewRef.current = controlledView;\n  };\n  const announceControlled = useCallback(() => {\n    if (!controlledMovedRef.current) return;\n    controlledMovedRef.current = false;\n    for (const fn of viewSubsRef.current) fn(viewRef.current);\n  }, []);\n  const clearSubscribers = useCallback(() => { viewSubsRef.current.clear(); }, []);\n\n  return {\n    viewRef, controlled: controlledView, setView, setViewFromInput, getView, subscribeView,\n    adoptControlled, announceControlled, clearSubscribers,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AA0EA,IAAM,WAAiB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;AAE3D,SAAgB,cAAc,MAA0C;CACtE,MAAM,EAAE,MAAM,UAAU,aAAa,cAAc,YAAY,MAAM,kBAAkB;CACvF,MAAM,UAAU,OAAO,aAAa,aAAa,WAAW;CAC5D,MAAM,iBAAiB,aAAa,UAAa,UAAU,SAAY,cAAc,QAAgB;CAGrG,MAAM,UAAU,OAAa,kBAAkB,cAAc,eAAe,QAAQ,CAAC;CACrF,MAAM,cAAc,uBAA+B,IAAI,IAAI,CAAC;CAC5D,MAAM,OAAO,UAAU;EACrB,YAAY,aAAa;EAAW;EAAS;EAAc;EAAY;EAAM;CAC/E,CAAC;CACD,MAAM,sBAAsB,OAAO,KAAK;CAExC,MAAM,UAAU,kBAAwB;EACtC,MAAM,QAAQ,KAAK,QAAQ;EAC3B,OAAO,QAAQ,cAAc,MAAM,CAAC,IAAI,QAAQ;CAClD,GAAG,CAAC,IAAI,CAAC;CAET,MAAM,QAAQ,aAAa,MAAY,eAA8B;EACnE,MAAM,EACJ,YAAY,SAAS,cAAc,SAAS,YAAY,QAAQ,MAAM,MAAM,eAAe,WACzF,KAAK;EACT,MAAM,QAAQ,cAAc,IAAI;EAChC,MAAM,UAAU,SAAS,UAAU,OAAO,QAAQ,KAAK,CAAC,IAAI;EAC5D,IAAI,YAAY;GAGd,IAAI,cAAc,CAAC,oBAAoB,SAAS;IAC9C,oBAAoB,UAAU;IAC9B,QAAQ,KAAK,UACT,wMACA,4LAA4L;GAClM;GACA,UAAU,OAAO;GAEjB,IAAI,SAAS,OAAO;GACpB;EACF;EACA,QAAQ,UAAU;EAClB,KAAK,MAAM,MAAM,YAAY,SAAS,GAAG,OAAO;EAChD,UAAU,OAAO;EACjB,OAAO;CACT,GAAG,CAAC,IAAI,CAAC;CAET,MAAM,UAAU,aAAa,SAA2C;EACtE,MAAM,OAAO,SAAS,aAAa,KAAK,QAAQ,CAAC,IAAI,MAAM,IAAI;CACjE,GAAG,CAAC,OAAO,OAAO,CAAC;CACnB,MAAM,mBAAmB,aAAa,SAAe;EAAE,MAAM,MAAM,KAAK;CAAG,GAAG,CAAC,KAAK,CAAC;CAErF,MAAM,gBAAgB,aAAa,OAA0B;EAC3D,YAAY,QAAQ,IAAI,EAAE;EAC1B,aAAa;GAAE,YAAY,QAAQ,OAAO,EAAE;EAAG;CACjD,GAAG,CAAC,CAAC;CAEL,MAAM,qBAAqB,OAAO,KAAK;CAGvC,MAAM,wBAA8B;EAClC,IAAI,CAAC,gBAAgB;EACrB,mBAAmB,YAAY,CAAC,SAAS,QAAQ,SAAS,cAAc;EACxE,QAAQ,UAAU;CACpB;CAQA,OAAO;EACL;EAAS,YAAY;EAAgB;EAAS;EAAkB;EAAS;EACzE;EAAiB,oBATQ,kBAAkB;GAC3C,IAAI,CAAC,mBAAmB,SAAS;GACjC,mBAAmB,UAAU;GAC7B,KAAK,MAAM,MAAM,YAAY,SAAS,GAAG,QAAQ,OAAO;EAC1D,GAAG,CAAC,CAKe;EAAoB,kBAJd,kBAAkB;GAAE,YAAY,QAAQ,MAAM;EAAG,GAAG,CAAC,CAIvC;CACvC;AACF"}