@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/SceneCanvas/useCanvasTools.js

@@ -1,67 +1,126 @@
-import { createLongPressFeedbackContribution as e } from "../../features/longPress/longPressFeedback.js";
-import { KIT_STANDARD_ACTION_IDS as t } from "../../interactions/actions/useStandardActions.js";
-import { useTools as n } from "../../tools/overlayBinding.js";
-import { featureActionIds as r, featureAmbient as i, resolveFeatures as a } from "./features.js";
-import { useBuiltinTools as o } from "./useBuiltinTools.js";
-import { useEffect as s, useMemo as c } from "react";
-import { useLatest as l } from "@weasel-js/react";
+import { createLongPressFeedbackContribution } from "../../features/longPress/longPressFeedback.js";
+import { useTools } from "../../tools/overlayBinding.js";
+import { presetActions, presetAmbient, presetContributions, resolveFeatures } from "./features.js";
+import { useBuiltinTools } from "./useBuiltinTools.js";
+import { useCallback, useEffect, useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/canvas/SceneCanvas/useCanvasTools.ts
-function u(e) {
-	return typeof e.setActive == "function";
+/** Discriminate the polymorphic `tools` prop: `ToolsApi` has `setActive`
+*  / `active` / `registry`; the patch record shape has none of those. */
+function isToolsApi(tools) {
+	return typeof tools.setActive === "function";
 }
-function d(e, t) {
-	let n = (e ?? []).join("|");
-	return c(() => a(e, { viewport: t }), [n, t]);
+var presetSerials = /* @__PURE__ */ new WeakMap();
+var nextSerial = 0;
+var entryKey = (e) => {
+	if (typeof e === "string") return e;
+	let n = presetSerials.get(e);
+	if (n === void 0) presetSerials.set(e, n = nextSerial++);
+	return `#${n}`;
+};
+/** The presets a canvas runs with. Keyed on the entries, not the array, so
+*  an inline `features={['draw', pathTools]}` does not re-derive every render. */
+function useEnabledFeatures(features, named, hasViewport) {
+	const featuresKey = (features ?? []).map(entryKey).join("|");
+	return useMemo(() => resolveFeatures(features, named, { viewport: hasViewport }), [
+		featuresKey,
+		named,
+		hasViewport
+	]);
 }
-function f(t) {
-	let { select: r, enabled: i, tools: a, defaultTools: d, toolOptions: f, inertia: p, ambient: m, initialActiveTool: h, modes: g, onToolsCreated: _ } = t, v = a && u(a) ? a : null, y = o({
-		select: r,
-		enabled: i,
-		defaultTools: d,
-		patch: a && !u(a) ? a : null,
-		toolOptions: f,
-		inertia: p
-	}), b = c(() => e(), []), x = t.pressFeedback ?? !0, S = x === !0 ? b : x || null, C = c(() => S ? [...m ?? [], S] : m ?? [], [m, S]), w = n({
-		active: h ?? ("select" in y ? "select" : null),
-		registry: y,
-		...C.length ? { ambient: C } : {},
-		...g ? { modes: g } : {}
-	}), T = v ?? w, E = l(_);
-	return s(() => {
-		E.current?.(T);
-	}, [T, E]), {
-		tools: T,
-		internal: w,
-		takeover: v
+/**
+* The canvas's tools: a caller's own `ToolsApi` when the `tools` prop is one
+* (the takeover form), and otherwise the built-ins the presets and
+* `defaultTools` name, patched by a `tools` record.
+*/
+function useCanvasTools(args) {
+	const { select, enabled, tools: toolsProp, defaultTools, toolOptions, inertia, ambient, initialActiveTool, modes, onToolsCreated } = args;
+	const takeover = toolsProp && isToolsApi(toolsProp) ? toolsProp : null;
+	const selectionRef = useLatest(args.selection);
+	const selected = useCallback(() => selectionRef.current.get(), [selectionRef]);
+	const registry = useBuiltinTools({
+		select,
+		scene: args.scene,
+		selection: selected,
+		enabled,
+		defaultTools,
+		patch: toolsProp && !isToolsApi(toolsProp) ? toolsProp : null,
+		toolOptions,
+		inertia
+	});
+	const defaultPressFeedback = useMemo(() => createLongPressFeedbackContribution(), []);
+	const feedbackOpt = args.pressFeedback ?? true;
+	const pressFeedback = feedbackOpt === true ? defaultPressFeedback : feedbackOpt || null;
+	const mergedAmbient = useMemo(() => [
+		...presetContributions(enabled),
+		...ambient ?? [],
+		...pressFeedback ? [pressFeedback] : []
+	], [
+		enabled,
+		ambient,
+		pressFeedback
+	]);
+	const internal = useTools({
+		active: initialActiveTool ?? ("select" in registry ? "select" : null),
+		registry,
+		...mergedAmbient.length ? { ambient: mergedAmbient } : {},
+		...modes ? { modes } : {}
+	});
+	const tools = takeover ?? internal;
+	const onToolsCreatedRef = useLatest(onToolsCreated);
+	useEffect(() => {
+		onToolsCreatedRef.current?.(tools);
+	}, [tools, onToolsCreatedRef]);
+	return {
+		tools,
+		internal,
+		takeover
 	};
 }
-function p(e) {
-	let { enabled: n, tools: a, move: o, rotate: s } = e, l = c(() => i(n, {
-		move: o,
-		rotate: s
+/**
+* The presets' ambient bindings, and the standard actions the canvas
+* registers. The bindings are not tools and sit outside `tools`, so they apply
+* under a takeover too. An action is registered when an enabled preset brings
+* it, or when it is in `pool` and a tool or contribution on this canvas binds
+* it: a tool brings the actions it routes to, so `defaultTools={['rect']}`
+* works under any preset.
+*/
+function useFeatureBindings(args) {
+	const { enabled, pool, tools, move, rotate } = args;
+	const contributions = useMemo(() => presetAmbient(enabled, {
+		move,
+		rotate
 	}), [
-		n,
-		o,
-		s
+		enabled,
+		move,
+		rotate
 	]);
 	return {
-		contributions: l,
-		standardActionsExclude: c(() => {
-			let e = r(n), i = [
-				...Object.values(a.registry),
-				...a.ambient,
-				...l
-			];
-			for (let t of i) for (let n of t.bindings ?? []) e.add(n.actionId);
-			return t.filter((t) => !e.has(t));
+		contributions,
+		standardActions: useMemo(() => {
+			const out = presetActions(enabled);
+			const have = new Set(out.map((a) => a.id));
+			const bound = /* @__PURE__ */ new Set();
+			for (const entry of [
+				...Object.values(tools.registry),
+				...tools.ambient,
+				...contributions
+			]) for (const b of entry.bindings ?? []) bound.add(b.actionId);
+			for (const a of pool) if (bound.has(a.id) && !have.has(a.id)) {
+				have.add(a.id);
+				out.push(a);
+			}
+			return out;
 		}, [
-			n,
-			a,
-			l
+			enabled,
+			pool,
+			tools,
+			contributions
 		])
 	};
 }
-//#endregion
-export { f as useCanvasTools, d as useEnabledFeatures, p as useFeatureBindings };
 
+//#endregion
+export { useCanvasTools, useEnabledFeatures, useFeatureBindings };
 //# sourceMappingURL=useCanvasTools.js.map

package/dist/canvas/SceneCanvas/useCanvasTools.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasTools.js","names":["isToolsApi","tools","useEnabledFeatures","featuresKey","features","useMemo","resolveFeatures","hasViewport","useCanvasTools","toolsProp","args","takeover","registry","useBuiltinTools","defaultPressFeedback","createLongPressFeedbackContribution","feedbackOpt","pressFeedback","mergedAmbient","ambient","internal","useTools","initialActiveTool","modes","onToolsCreatedRef","useLatest","onToolsCreated","useEffect","useFeatureBindings","contributions","featureAmbient","enabled","move","rotate","include","featureActionIds","bound","entry","b","KIT_STANDARD_ACTION_IDS","id"],"sources":["../../../src/canvas/SceneCanvas/useCanvasTools.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { KIT_STANDARD_ACTION_IDS } from 'interactions/actions/useStandardActions';\nimport { createLongPressFeedbackContribution } from '../../features/longPress/longPressFeedback';\nimport { useTools, type Contribution, type Tool, type ToolsApi } from '../../tools/overlayBinding';\nimport {\n  featureActionIds,\n  featureAmbient,\n  resolveFeatures,\n  type BaseFeature,\n  type Feature,\n  type FeatureBindingOptions,\n} from './features';\nimport type { SceneCanvasProps } from './props';\nimport type { ToolsPatch } from './toolRegistry';\nimport { useBuiltinTools } from './useBuiltinTools';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\n\n/** Discriminate the polymorphic `tools` prop: `ToolsApi` has `setActive`\n *  / `active` / `registry`; the patch record shape has none of those. */\nfunction isToolsApi(tools: ToolsApi | ToolsPatch): tools is ToolsApi {\n  return typeof (tools as ToolsApi).setActive === 'function';\n}\n\n/** The presets a canvas runs with. Keyed on the ids, not the array, so an\n *  inline `features={['draw']}` does not re-derive every render. */\nexport function useEnabledFeatures(\n  features: readonly Feature[] | undefined,\n  hasViewport: boolean,\n): ReadonlySet<BaseFeature> {\n  const featuresKey = (features ?? []).join('|');\n  return useMemo(\n    () => resolveFeatures(features, { viewport: hasViewport }),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [featuresKey, hasViewport],\n  );\n}\n\n/**\n * The canvas's tools: a caller's own `ToolsApi` when the `tools` prop is one\n * (the takeover form), and otherwise the built-ins the presets and\n * `defaultTools` name, patched by a `tools` record.\n */\nexport function useCanvasTools(args: {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  enabled: ReadonlySet<BaseFeature>;\n  tools: Props['tools'];\n  defaultTools: Props['defaultTools'];\n  toolOptions: Props['toolOptions'];\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia: NonNullable<Props['viewport']>['inertia'];\n  ambient: Props['ambient'];\n  /** `longPress.feedback`. Default true, which installs the kit's own. */\n  pressFeedback: NonNullable<Props['longPress']>['feedback'];\n  initialActiveTool: Props['initialActiveTool'];\n  modes: Props['modes'];\n  onToolsCreated: Props['onToolsCreated'];\n}): {\n  /** What the canvas routes input through: the takeover, or `internal`. */\n  tools: ToolsApi;\n  /** The canvas's own api, built whether or not a takeover replaces it. */\n  internal: ToolsApi;\n  takeover: ToolsApi | null;\n} {\n  const { select, enabled, tools: toolsProp, defaultTools, toolOptions, inertia, ambient, initialActiveTool, modes, onToolsCreated } = args;\n\n  const takeover = toolsProp && isToolsApi(toolsProp) ? toolsProp : null;\n  const registry = useBuiltinTools({\n    select,\n    enabled,\n    defaultTools,\n    patch: toolsProp && !isToolsApi(toolsProp) ? toolsProp : null,\n    toolOptions,\n    inertia,\n  });\n\n  const defaultPressFeedback = useMemo(() => createLongPressFeedbackContribution(), []);\n  const feedbackOpt = args.pressFeedback ?? true;\n  const pressFeedback = feedbackOpt === true ? defaultPressFeedback : feedbackOpt || null;\n  const mergedAmbient = useMemo(\n    () => (pressFeedback ? [...(ambient ?? []), pressFeedback] : (ambient ?? [])),\n    [ambient, pressFeedback],\n  );\n\n  const internal = useTools({\n    active: initialActiveTool ?? ('select' in registry ? 'select' : null),\n    registry,\n    ...(mergedAmbient.length ? { ambient: mergedAmbient } : {}),\n    ...(modes ? { modes } : {}),\n  });\n  const tools = takeover ?? internal;\n\n  const onToolsCreatedRef = useLatest(onToolsCreated);\n  useEffect(() => { onToolsCreatedRef.current?.(tools); }, [tools, onToolsCreatedRef]);\n\n  return { tools, internal, takeover };\n}\n\n/**\n * The presets' ambient bindings, and the kit-standard actions the canvas\n * leaves unregistered. The bindings are not tools and sit outside `tools`, so\n * they apply under a takeover too. An action is registered when a preset\n * names it or a tool or contribution on this canvas binds it: a tool brings\n * the actions it routes to, so `defaultTools={['rect']}` works under any preset.\n */\nexport function useFeatureBindings(args: {\n  enabled: ReadonlySet<BaseFeature>;\n  tools: Pick<ToolsApi, 'registry' | 'ambient'>;\n  move: FeatureBindingOptions['move'];\n  rotate: FeatureBindingOptions['rotate'];\n}): { contributions: Contribution[]; standardActionsExclude: string[] } {\n  const { enabled, tools, move, rotate } = args;\n  const contributions = useMemo<Contribution[]>(\n    () => featureAmbient(enabled, { move, rotate }),\n    [enabled, move, rotate],\n  );\n  const standardActionsExclude = useMemo(() => {\n    const include = featureActionIds(enabled);\n    const bound = [...Object.values(tools.registry), ...tools.ambient, ...contributions];\n    for (const entry of bound) {\n      for (const b of entry.bindings ?? []) include.add(b.actionId);\n    }\n    return KIT_STANDARD_ACTION_IDS.filter((id) => !include.has(id));\n  }, [enabled, tools, contributions]);\n  return { contributions, standardActionsExclude };\n}\n"],"mappings":";;;;;;;;AAqBA,SAASA,EAAW,GAAiD;CACnE,OAAO,OAAQC,EAAmB,aAAc;AAClD;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,IAAMC,KAAeC,KAAY,CAAC,EAAA,CAAG,KAAK,GAAG;CAC7C,OAAOC,QACCC,EAAgBF,GAAU,EAAE,UAAUG,EAAY,CAAC,GAEzD,CAACJ,GAAaI,CAAW,CAC3B;AACF;AAOA,SAAgBC,EAAe,GAqB7B;CACA,IAAM,EAAE,WAAQ,YAAS,OAAOC,GAAW,iBAAc,gBAAa,YAAS,YAAS,sBAAmB,UAAO,sBAAmBC,GAE/HC,IAAWF,KAAaT,EAAWS,CAAS,IAAIA,IAAY,MAC5DG,IAAWC,EAAgB;EAC/B;EACA;EACA;EACA,OAAOJ,KAAa,CAACT,EAAWS,CAAS,IAAIA,IAAY;EACzD;EACA;CACF,CAAC,GAEKK,IAAuBT,QAAcU,EAAoC,GAAG,CAAC,CAAC,GAC9EC,IAAcN,EAAK,iBAAiB,IACpCO,IAAgBD,MAAgB,KAAOF,IAAuBE,KAAe,MAC7EE,IAAgBb,QACbY,IAAgB,CAAC,GAAIE,KAAW,CAAC,GAAIF,CAAa,IAAKE,KAAW,CAAC,GAC1E,CAACA,GAASF,CAAa,CACzB,GAEMG,IAAWC,EAAS;EACxB,QAAQC,MAAsB,YAAYV,IAAW,WAAW;EAChE;EACA,GAAIM,EAAc,SAAS,EAAE,SAASA,EAAc,IAAI,CAAC;EACzD,GAAIK,IAAQ,EAAE,SAAM,IAAI,CAAC;CAC3B,CAAC,GACKtB,IAAQU,KAAYS,GAEpBI,IAAoBC,EAAUC,CAAc;CAGlD,OAFAC,QAAgB;EAAE,EAAkB,UAAU1B,CAAK;CAAG,GAAG,CAACA,GAAOuB,CAAiB,CAAC,GAE5E;EAAE;EAAO;EAAU;CAAS;AACrC;AASA,SAAgBI,EAAmB,GAKqC;CACtE,IAAM,EAAE,YAAS,UAAO,SAAM,cAAWlB,GACnCmB,IAAgBxB,QACdyB,EAAeC,GAAS;EAAE;EAAM;CAAO,CAAC,GAC9C;EAACA;EAASC;EAAMC;CAAM,CACxB;CASA,OAAO;EAAE;EAAe,wBARO5B,QAAc;GAC3C,IAAM6B,IAAUC,EAAiBJ,CAAO,GAClCK,IAAQ;IAAC,GAAG,OAAO,OAAOnC,EAAM,QAAQ;IAAG,GAAGA,EAAM;IAAS,GAAG4B;GAAa;GACnF,KAAK,IAAMQ,KAASD,GAClB,KAAK,IAAME,KAAKD,EAAM,YAAY,CAAC,GAAG,EAAQ,IAAIC,EAAE,QAAQ;GAE9D,OAAOC,EAAwB,QAAQ,MAAO,CAACL,EAAQ,IAAIM,CAAE,CAAC;EAChE,GAAG;GAACT;GAAS9B;GAAO4B;EAAa,CACT;CAAuB;AACjD"}
+{"version":3,"file":"useCanvasTools.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useCanvasTools.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action, SelectionApi } from '@weasel-js/routing';\nimport type { Scene } from 'core/scene/types';\nimport { createLongPressFeedbackContribution } from '../../features/longPress/longPressFeedback';\nimport { useTools, type Contribution, type Tool, type ToolsApi } from '../../tools/overlayBinding';\nimport {\n  presetActions,\n  presetAmbient,\n  presetContributions,\n  resolveFeatures,\n  type EnabledPresets,\n  type FeatureBindingOptions,\n  type FeatureEntry,\n  type NamedPresets,\n} from './features';\nimport type { SceneCanvasProps } from './props';\nimport type { ToolsPatch } from './toolRegistry';\nimport { useBuiltinTools } from './useBuiltinTools';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\n\n/** Discriminate the polymorphic `tools` prop: `ToolsApi` has `setActive`\n *  / `active` / `registry`; the patch record shape has none of those. */\nfunction isToolsApi(tools: ToolsApi | ToolsPatch): tools is ToolsApi {\n  return typeof (tools as ToolsApi).setActive === 'function';\n}\n\nconst presetSerials = new WeakMap<object, number>();\nlet nextSerial = 0;\nconst entryKey = (e: FeatureEntry): string => {\n  if (typeof e === 'string') return e;\n  let n = presetSerials.get(e);\n  if (n === undefined) presetSerials.set(e, (n = nextSerial++));\n  return `#${n}`;\n};\n\n/** The presets a canvas runs with. Keyed on the entries, not the array, so\n *  an inline `features={['draw', pathTools]}` does not re-derive every render. */\nexport function useEnabledFeatures(\n  features: readonly FeatureEntry[] | undefined,\n  named: NamedPresets | null,\n  hasViewport: boolean,\n): EnabledPresets {\n  const featuresKey = (features ?? []).map(entryKey).join('|');\n  return useMemo(\n    () => resolveFeatures(features, named, { viewport: hasViewport }),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [featuresKey, named, hasViewport],\n  );\n}\n\n/**\n * The canvas's tools: a caller's own `ToolsApi` when the `tools` prop is one\n * (the takeover form), and otherwise the built-ins the presets and\n * `defaultTools` name, patched by a `tools` record.\n */\nexport function useCanvasTools(args: {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  /** The canvas's scene and selection, which the rig tools edit and read. */\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  enabled: EnabledPresets;\n  tools: Props['tools'];\n  defaultTools: Props['defaultTools'];\n  toolOptions: Props['toolOptions'];\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia: NonNullable<Props['viewport']>['inertia'];\n  ambient: Props['ambient'];\n  /** `longPress.feedback`. Default true, which installs the kit's own. */\n  pressFeedback: NonNullable<Props['longPress']>['feedback'];\n  initialActiveTool: Props['initialActiveTool'];\n  modes: Props['modes'];\n  onToolsCreated: Props['onToolsCreated'];\n}): {\n  /** What the canvas routes input through: the takeover, or `internal`. */\n  tools: ToolsApi;\n  /** The canvas's own api, built whether or not a takeover replaces it. */\n  internal: ToolsApi;\n  takeover: ToolsApi | null;\n} {\n  const { select, enabled, tools: toolsProp, defaultTools, toolOptions, inertia, ambient, initialActiveTool, modes, onToolsCreated } = args;\n\n  const takeover = toolsProp && isToolsApi(toolsProp) ? toolsProp : null;\n  const selectionRef = useLatest(args.selection);\n  const selected = useCallback(() => selectionRef.current.get(), [selectionRef]);\n  const registry = useBuiltinTools({\n    select,\n    scene: args.scene,\n    selection: selected,\n    enabled,\n    defaultTools,\n    patch: toolsProp && !isToolsApi(toolsProp) ? toolsProp : null,\n    toolOptions,\n    inertia,\n  });\n\n  const defaultPressFeedback = useMemo(() => createLongPressFeedbackContribution(), []);\n  const feedbackOpt = args.pressFeedback ?? true;\n  const pressFeedback = feedbackOpt === true ? defaultPressFeedback : feedbackOpt || null;\n  const mergedAmbient = useMemo(\n    () => [...presetContributions(enabled), ...(ambient ?? []), ...(pressFeedback ? [pressFeedback] : [])],\n    [enabled, ambient, pressFeedback],\n  );\n\n  const internal = useTools({\n    active: initialActiveTool ?? ('select' in registry ? 'select' : null),\n    registry,\n    ...(mergedAmbient.length ? { ambient: mergedAmbient } : {}),\n    ...(modes ? { modes } : {}),\n  });\n  const tools = takeover ?? internal;\n\n  const onToolsCreatedRef = useLatest(onToolsCreated);\n  useEffect(() => { onToolsCreatedRef.current?.(tools); }, [tools, onToolsCreatedRef]);\n\n  return { tools, internal, takeover };\n}\n\n/**\n * The presets' ambient bindings, and the standard actions the canvas\n * registers. The bindings are not tools and sit outside `tools`, so they apply\n * under a takeover too. An action is registered when an enabled preset brings\n * it, or when it is in `pool` and a tool or contribution on this canvas binds\n * it: a tool brings the actions it routes to, so `defaultTools={['rect']}`\n * works under any preset.\n */\nexport function useFeatureBindings(args: {\n  enabled: EnabledPresets;\n  /** Actions registered only when something binds them. */\n  pool: readonly Action[];\n  tools: Pick<ToolsApi, 'registry' | 'ambient'>;\n  move: FeatureBindingOptions['move'];\n  rotate: FeatureBindingOptions['rotate'];\n}): { contributions: Contribution[]; standardActions: Action[] } {\n  const { enabled, pool, tools, move, rotate } = args;\n  const contributions = useMemo<Contribution[]>(\n    () => presetAmbient(enabled, { move, rotate }),\n    [enabled, move, rotate],\n  );\n  const standardActions = useMemo(() => {\n    const out = presetActions(enabled);\n    const have = new Set(out.map((a) => a.id));\n    const bound = new Set<string>();\n    for (const entry of [...Object.values(tools.registry), ...tools.ambient, ...contributions]) {\n      for (const b of entry.bindings ?? []) bound.add(b.actionId);\n    }\n    for (const a of pool) {\n      if (bound.has(a.id) && !have.has(a.id)) {\n        have.add(a.id);\n        out.push(a);\n      }\n    }\n    return out;\n  }, [enabled, pool, tools, contributions]);\n  return { contributions, standardActions };\n}\n\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useChromeAffordances.js

@@ -0,0 +1,31 @@
+import { targetSizesPx } from "../../core/device/targets.js";
+import { chromeAffordances } from "../affordanceAt.js";
+import { useTargetBasePx } from "../../core/device/useTargetBasePx.js";
+import { useMemo } from "react";
+
+//#region src/canvas/SceneCanvas/useChromeAffordances.ts
+/** {@link chromeAffordances} sized by the device scale on the `targets` kit settings; an explicit `handleHitRadius` wins. */
+function useChromeAffordances(opts) {
+	const { targetScale, handleHitRadius, rotationBadge, getAnchorState, edgeHandles } = opts;
+	const sizes = targetSizesPx(targetScale, useTargetBasePx());
+	return useMemo(() => chromeAffordances({
+		handleHitRadius: handleHitRadius ?? sizes.handle,
+		anchorHitRadius: sizes.anchor,
+		rotateBandPx: sizes.rotationDistance,
+		rotationBadge,
+		edgeHandles,
+		...getAnchorState ? { getAnchorState } : {}
+	}), [
+		sizes.handle,
+		sizes.anchor,
+		sizes.rotationDistance,
+		handleHitRadius,
+		rotationBadge,
+		getAnchorState,
+		edgeHandles
+	]);
+}
+
+//#endregion
+export { useChromeAffordances };
+//# sourceMappingURL=useChromeAffordances.js.map

package/dist/canvas/SceneCanvas/useChromeAffordances.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChromeAffordances.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useChromeAffordances.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { Affordance } from 'affordances/types';\nimport { targetSizesPx } from 'core/device/targets';\nimport { useTargetBasePx } from 'core/device/useTargetBasePx';\nimport { chromeAffordances, type ChromeAffordanceOptions } from '../affordanceAt';\n\n/** {@link chromeAffordances} sized by the device scale on the `targets` kit settings; an explicit `handleHitRadius` wins. */\nexport function useChromeAffordances(\n  opts: Pick<ChromeAffordanceOptions, 'targetScale' | 'handleHitRadius' | 'rotationBadge' | 'getAnchorState' | 'edgeHandles'>,\n): Affordance[] {\n  const { targetScale, handleHitRadius, rotationBadge, getAnchorState, edgeHandles } = opts;\n  const sizes = targetSizesPx(targetScale, useTargetBasePx());\n  return useMemo(() => chromeAffordances({\n    handleHitRadius: handleHitRadius ?? sizes.handle,\n    anchorHitRadius: sizes.anchor,\n    rotateBandPx: sizes.rotationDistance,\n    rotationBadge,\n    edgeHandles,\n    ...(getAnchorState ? { getAnchorState } : {}),\n  }), [sizes.handle, sizes.anchor, sizes.rotationDistance, handleHitRadius, rotationBadge, getAnchorState, edgeHandles]);\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,qBACd,MACc;CACd,MAAM,EAAE,aAAa,iBAAiB,eAAe,gBAAgB,gBAAgB;CACrF,MAAM,QAAQ,cAAc,aAAa,gBAAgB,CAAC;CAC1D,OAAO,cAAc,kBAAkB;EACrC,iBAAiB,mBAAmB,MAAM;EAC1C,iBAAiB,MAAM;EACvB,cAAc,MAAM;EACpB;EACA;EACA,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;CAC7C,CAAC,GAAG;EAAC,MAAM;EAAQ,MAAM;EAAQ,MAAM;EAAkB;EAAiB;EAAe;EAAgB;CAAW,CAAC;AACvH"}

package/dist/canvas/SceneCanvas/useContributionRoles.js

@@ -1,75 +1,126 @@
-import { checkRequirements as e } from "../kitRequirements.js";
-import { useContributionFrameHooks as t } from "./contributionFrameHooks.js";
-import { useEffect as n, useRef as r } from "react";
-import { useActionsRegistry as i, useOffhandAction as a, useOptionalDepRegistry as o } from "@weasel-js/routing/react";
+import { checkRequirements } from "../kitRequirements.js";
+import { useContributionFrameHooks } from "./contributionFrameHooks.js";
+import { useEffect, useRef } from "react";
+import { isDev } from "@weasel-js/react";
+import { useActionsRegistry, useMenuHost, useOffhandAction, useOptionalDepRegistry } from "@weasel-js/routing/react";
+
 //#region src/canvas/SceneCanvas/useContributionRoles.ts
-var s = { get: () => void 0 }, c = /* @__PURE__ */ new WeakSet();
-function l(e) {
-	switch (e.reason) {
-		case "unsatisfied": return `${e.package} ${e.range} (running ${e.running})`;
-		case "invalid-range": return `${e.package} "${e.range}", which is not a range this check reads`;
-		case "unknown-package": return `${e.package} ${e.range}, but ${e.package} reports no version`;
+/**
+* `useContributionRoles` — installs the roles of every entry in the tools
+* registry that a surface owns rather than the dispatcher: its actions into the
+* `<ActionsProvider>`, its deps into the dep registry, and its `attach` against
+* the mounted canvas. Views are the fourth such role; `<SceneCanvas>` renders
+* those itself, because a view is a component.
+*
+* Tool hooks run wherever the consumer calls them, which may be outside any
+* registry. Declaring roles on the entry and installing them from in here keeps
+* the tool hook callable from anywhere.
+*/
+var NO_DEPS = { get: () => void 0 };
+var warnedRequirements = /* @__PURE__ */ new WeakSet();
+function describeMismatch(m) {
+	switch (m.reason) {
+		case "unsatisfied": return `${m.package} ${m.range} (running ${m.running})`;
+		case "invalid-range": return `${m.package} "${m.range}", which is not a range this check reads`;
+		case "unknown-package": return `${m.package} ${m.range}, but ${m.package} reports no version`;
 	}
 }
-function u(t, n) {
-	if (n !== "off") for (let r of t) {
-		let t = r.requires;
-		if (!t || n === "warn" && c.has(t)) continue;
-		let i = e(t);
-		if (i.length === 0) continue;
-		let a = `[weasel] contribution "${r.id}" requires ${i.map(l).join("; ")}.`;
-		if (n === "strict") throw Error(a);
-		c.add(t), console.warn(a);
+function checkEntryRequirements(entries, mode) {
+	if (mode === "off") return;
+	for (const entry of entries) {
+		const requires = entry.requires;
+		if (!requires) continue;
+		if (mode === "warn" && warnedRequirements.has(requires)) continue;
+		const mismatches = checkRequirements(requires);
+		if (mismatches.length === 0) continue;
+		const message = `[weasel] contribution "${entry.id}" requires ${mismatches.map(describeMismatch).join("; ")}.`;
+		if (mode === "strict") throw new Error(message);
+		warnedRequirements.add(requires);
+		console.warn(message);
 	}
 }
-function d(e) {
-	return [...Object.values(e.registry), ...e.ambient];
+/** Every entry the registry holds, registry and ambient alike. */
+function contributionEntries(tools) {
+	return [...Object.values(tools.registry), ...tools.ambient];
 }
-function f(e) {
-	let t = r(/* @__PURE__ */ new Map());
-	n(() => {
-		for (let [n, r] of t.current) e.has(n) || (r(), t.current.delete(n));
-		for (let [n, r] of e) t.current.has(n) || t.current.set(n, r());
-	}), n(() => () => {
-		for (let e of t.current.values()) e();
-		t.current.clear();
+/**
+* Keep one installation per key alive: install keys that appeared, tear down
+* keys that went. Keys are role objects the consumer owns, so an entry the
+* host re-wraps every render — `useTools` restates eligibility on a copy —
+* still installs once.
+*/
+function useKeyedInstall(items) {
+	const live = useRef(/* @__PURE__ */ new Map());
+	useEffect(() => {
+		for (const [key, teardown] of live.current) {
+			if (items.has(key)) continue;
+			teardown();
+			live.current.delete(key);
+		}
+		for (const [key, install] of items) {
+			if (live.current.has(key)) continue;
+			live.current.set(key, install());
+		}
+	});
+	useEffect(() => () => {
+		for (const teardown of live.current.values()) teardown();
+		live.current.clear();
 	}, []);
 }
-function p(e, r, c = "warn") {
-	let l = i(), p = o(), { registry: h, ambient: g } = e;
-	n(() => {
-		if (!l) return;
-		let e = [];
-		for (let t of d({
-			registry: h,
-			ambient: g
-		})) for (let n of t.actions ?? []) e.push(l.register(n));
+function useContributionRoles(tools, api, versionCheck = "warn") {
+	const registry = useActionsRegistry();
+	const depRegistry = useOptionalDepRegistry();
+	const { registry: toolRegistry, ambient } = tools;
+	useEffect(() => {
+		if (!registry) return;
+		const unregisters = [];
+		for (const entry of contributionEntries({
+			registry: toolRegistry,
+			ambient
+		})) for (const action of entry.actions ?? []) unregisters.push(registry.register(action));
 		return () => {
-			for (let t of e) t();
+			for (const u of unregisters) u();
 		};
 	}, [
-		l,
-		h,
-		g
+		registry,
+		toolRegistry,
+		ambient
 	]);
-	let _ = d(e);
-	(c === "strict" || c === "warn" && process.env.NODE_ENV !== "production") && u(_, c);
-	let v = p ?? s, y = /* @__PURE__ */ new Map();
-	for (let e of _) {
-		let t = e.deps;
-		t && p && y.set(t, () => m(p, t));
-		let n = e.attach;
-		n && r && y.set(n, () => n(r, v));
+	const menuHost = useMenuHost();
+	useEffect(() => {
+		if (!menuHost) return;
+		const releases = [];
+		for (const [id, entry] of Object.entries(toolRegistry)) for (const def of entry.menus ?? []) releases.push(menuHost.define(def, id));
+		for (const entry of ambient) for (const def of entry.menus ?? []) releases.push(menuHost.define(def, null));
+		return () => {
+			for (const r of releases) r();
+		};
+	}, [
+		menuHost,
+		toolRegistry,
+		ambient
+	]);
+	const entries = contributionEntries(tools);
+	if (versionCheck === "strict" || versionCheck === "warn" && isDev()) checkEntryRequirements(entries, versionCheck);
+	const reader = depRegistry ?? NO_DEPS;
+	const installs = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const deps = entry.deps;
+		if (deps && depRegistry) installs.set(deps, () => registerDeps(depRegistry, deps));
+		const attach = entry.attach;
+		if (attach && api) installs.set(attach, () => attach(api, reader));
 	}
-	f(y), t(_, r, v), a(d(e));
+	useKeyedInstall(installs);
+	useContributionFrameHooks(entries, api, reader);
+	useOffhandAction(contributionEntries(tools));
 }
-function m(e, t) {
-	let n = Object.keys(t).map((n) => e.register(n, t[n]));
+function registerDeps(depRegistry, deps) {
+	const unregisters = Object.keys(deps).map((name) => depRegistry.register(name, deps[name]));
 	return () => {
-		for (let e of n) e();
+		for (const u of unregisters) u();
 	};
 }
-//#endregion
-export { d as contributionEntries, p as useContributionRoles };
 
+//#endregion
+export { contributionEntries, useContributionRoles };
 //# sourceMappingURL=useContributionRoles.js.map

package/dist/canvas/SceneCanvas/useContributionRoles.js.map

@@ -1 +1 @@
-{"version":3,"file":"useContributionRoles.js","names":["NO_DEPS","warnedRequirements","describeMismatch","m","checkEntryRequirements","mode","entry","entries","requires","mismatches","checkRequirements","message","contributionEntries","tools","useKeyedInstall","live","useRef","useEffect","key","teardown","items","install","useContributionRoles","registry","useActionsRegistry","depRegistry","useOptionalDepRegistry","toolRegistry","unregisters","action","u","ambient","versionCheck","reader","installs","deps","registerDeps","attach","api","useContributionFrameHooks","useOffhandAction","name"],"sources":["../../../src/canvas/SceneCanvas/useContributionRoles.ts"],"sourcesContent":["/**\n * `useContributionRoles` — installs the roles of every entry in the tools\n * registry that a surface owns rather than the dispatcher: its actions into the\n * `<ActionsProvider>`, its deps into the dep registry, and its `attach` against\n * the mounted canvas. Views are the fourth such role; `<SceneCanvas>` renders\n * those itself, because a view is a component.\n *\n * Tool hooks run wherever the consumer calls them, which may be outside any\n * registry. Declaring roles on the entry and installing them from in here keeps\n * the tool hook callable from anywhere.\n */\nimport { useEffect, useRef } from 'react';\nimport { useActionsRegistry, useOffhandAction, useOptionalDepRegistry } from '@weasel-js/routing/react';\nimport type { DepRegistry } from '@weasel-js/routing/react';\nimport type { DepName } from 'interactions/actions/depSchema';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport { checkRequirements, type RequirementMismatch } from '../kitRequirements';\nimport { useContributionFrameHooks } from './contributionFrameHooks';\n\n/** How a surface treats an entry whose `requires` the running kit does not\n *  meet: warn in development (the default), throw, or not check. */\nexport type VersionCheck = 'warn' | 'strict' | 'off';\n\nconst NO_DEPS = { get: () => undefined };\nconst warnedRequirements = new WeakSet<object>();\n\nfunction describeMismatch(m: RequirementMismatch): string {\n  switch (m.reason) {\n    case 'unsatisfied': return `${m.package} ${m.range} (running ${m.running})`;\n    case 'invalid-range': return `${m.package} \"${m.range}\", which is not a range this check reads`;\n    case 'unknown-package': return `${m.package} ${m.range}, but ${m.package} reports no version`;\n  }\n}\n\nfunction checkEntryRequirements(entries: readonly SurfaceContribution[], mode: VersionCheck): void {\n  if (mode === 'off') return;\n  for (const entry of entries) {\n    const requires = entry.requires;\n    if (!requires) continue;\n    if (mode === 'warn' && warnedRequirements.has(requires)) continue;\n    const mismatches = checkRequirements(requires);\n    if (mismatches.length === 0) continue;\n    const message = `[weasel] contribution \"${entry.id}\" requires ${mismatches.map(describeMismatch).join('; ')}.`;\n    if (mode === 'strict') throw new Error(message);\n    warnedRequirements.add(requires);\n    console.warn(message);\n  }\n}\n\n/** Every entry the registry holds, registry and ambient alike. */\nexport function contributionEntries(tools: Pick<ToolsApi, 'registry' | 'ambient'>): SurfaceContribution[] {\n  return [...Object.values(tools.registry), ...tools.ambient] as SurfaceContribution[];\n}\n\n/**\n * Keep one installation per key alive: install keys that appeared, tear down\n * keys that went. Keys are role objects the consumer owns, so an entry the\n * host re-wraps every render — `useTools` restates eligibility on a copy —\n * still installs once.\n */\nfunction useKeyedInstall(\n  items: ReadonlyMap<object, () => () => void>,\n): void {\n  const live = useRef(new Map<object, () => void>());\n  useEffect(() => {\n    for (const [key, teardown] of live.current) {\n      if (items.has(key)) continue;\n      teardown();\n      live.current.delete(key);\n    }\n    for (const [key, install] of items) {\n      if (live.current.has(key)) continue;\n      live.current.set(key, install());\n    }\n  });\n  useEffect(() => () => {\n    for (const teardown of live.current.values()) teardown();\n    live.current.clear();\n  }, []);\n}\n\nexport function useContributionRoles(\n  tools: ToolsApi,\n  api: CanvasExtensionApi | null,\n  versionCheck: VersionCheck = 'warn',\n): void {\n  const registry = useActionsRegistry();\n  const depRegistry = useOptionalDepRegistry();\n  const { registry: toolRegistry, ambient } = tools;\n\n  useEffect(() => {\n    if (!registry) return;\n    const unregisters: Array<() => void> = [];\n    // Ambient entries included: an always-on entry owns actions its own\n    // bindings reference exactly as a registry tool does, and leaving them out\n    // gives the same silent failure this hook exists to prevent — a binding\n    // pointing at an id nothing registered.\n    for (const entry of contributionEntries({ registry: toolRegistry, ambient })) {\n      for (const action of entry.actions ?? []) {\n        unregisters.push(registry.register(action));\n      }\n    }\n    return () => { for (const u of unregisters) u(); };\n  }, [registry, toolRegistry, ambient]);\n\n  const entries = contributionEntries(tools);\n  // Development only for a warning; a strict surface asked to be stopped, so\n  // it throws in every build.\n  if (versionCheck === 'strict' || (versionCheck === 'warn' && process.env.NODE_ENV !== 'production')) {\n    checkEntryRequirements(entries, versionCheck);\n  }\n\n  const reader = depRegistry ?? NO_DEPS;\n  const installs = new Map<object, () => () => void>();\n  for (const entry of entries) {\n    const deps = entry.deps;\n    if (deps && depRegistry) installs.set(deps, () => registerDeps(depRegistry, deps));\n    const attach = entry.attach;\n    if (attach && api) installs.set(attach, () => attach(api, reader));\n  }\n  useKeyedInstall(installs);\n  useContributionFrameHooks(entries, api, reader);\n\n  // Tool assembly runs above the provider too, so its own registration of\n  // held-key engagement finds no registry unless the consumer mounted one.\n  useOffhandAction(contributionEntries(tools));\n}\n\nfunction registerDeps(\n  depRegistry: DepRegistry,\n  deps: NonNullable<SurfaceContribution['deps']>,\n): () => void {\n  const unregisters = (Object.keys(deps) as DepName[]).map((name) =>\n    depRegistry.register(name, deps[name] as never));\n  return () => { for (const u of unregisters) u(); };\n}\n"],"mappings":"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"}
+{"version":3,"file":"useContributionRoles.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useContributionRoles.ts"],"sourcesContent":["/**\n * `useContributionRoles` — installs the roles of every entry in the tools\n * registry that a surface owns rather than the dispatcher: its actions into the\n * `<ActionsProvider>`, its deps into the dep registry, and its `attach` against\n * the mounted canvas. Views are the fourth such role; `<SceneCanvas>` renders\n * those itself, because a view is a component.\n *\n * Tool hooks run wherever the consumer calls them, which may be outside any\n * registry. Declaring roles on the entry and installing them from in here keeps\n * the tool hook callable from anywhere.\n */\nimport { useEffect, useRef } from 'react';\nimport { useActionsRegistry, useMenuHost, useOffhandAction, useOptionalDepRegistry } from '@weasel-js/routing/react';\nimport type { DepRegistry } from '@weasel-js/routing/react';\nimport type { DepName } from 'interactions/actions/depSchema';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport { checkRequirements, type RequirementMismatch } from '../kitRequirements';\nimport { useContributionFrameHooks } from './contributionFrameHooks';\nimport { isDev } from '@weasel-js/react';\n\n/** How a surface treats an entry whose `requires` the running kit does not\n *  meet: warn in development (the default), throw, or not check. */\nexport type VersionCheck = 'warn' | 'strict' | 'off';\n\nconst NO_DEPS = { get: () => undefined };\nconst warnedRequirements = new WeakSet<object>();\n\nfunction describeMismatch(m: RequirementMismatch): string {\n  switch (m.reason) {\n    case 'unsatisfied': return `${m.package} ${m.range} (running ${m.running})`;\n    case 'invalid-range': return `${m.package} \"${m.range}\", which is not a range this check reads`;\n    case 'unknown-package': return `${m.package} ${m.range}, but ${m.package} reports no version`;\n  }\n}\n\nfunction checkEntryRequirements(entries: readonly SurfaceContribution[], mode: VersionCheck): void {\n  if (mode === 'off') return;\n  for (const entry of entries) {\n    const requires = entry.requires;\n    if (!requires) continue;\n    if (mode === 'warn' && warnedRequirements.has(requires)) continue;\n    const mismatches = checkRequirements(requires);\n    if (mismatches.length === 0) continue;\n    const message = `[weasel] contribution \"${entry.id}\" requires ${mismatches.map(describeMismatch).join('; ')}.`;\n    if (mode === 'strict') throw new Error(message);\n    warnedRequirements.add(requires);\n    console.warn(message);\n  }\n}\n\n/** Every entry the registry holds, registry and ambient alike. */\nexport function contributionEntries(tools: Pick<ToolsApi, 'registry' | 'ambient'>): SurfaceContribution[] {\n  return [...Object.values(tools.registry), ...tools.ambient] as SurfaceContribution[];\n}\n\n/**\n * Keep one installation per key alive: install keys that appeared, tear down\n * keys that went. Keys are role objects the consumer owns, so an entry the\n * host re-wraps every render — `useTools` restates eligibility on a copy —\n * still installs once.\n */\nfunction useKeyedInstall(\n  items: ReadonlyMap<object, () => () => void>,\n): void {\n  const live = useRef(new Map<object, () => void>());\n  useEffect(() => {\n    for (const [key, teardown] of live.current) {\n      if (items.has(key)) continue;\n      teardown();\n      live.current.delete(key);\n    }\n    for (const [key, install] of items) {\n      if (live.current.has(key)) continue;\n      live.current.set(key, install());\n    }\n  });\n  useEffect(() => () => {\n    for (const teardown of live.current.values()) teardown();\n    live.current.clear();\n  }, []);\n}\n\nexport function useContributionRoles(\n  tools: ToolsApi,\n  api: CanvasExtensionApi | null,\n  versionCheck: VersionCheck = 'warn',\n): void {\n  const registry = useActionsRegistry();\n  const depRegistry = useOptionalDepRegistry();\n  const { registry: toolRegistry, ambient } = tools;\n\n  useEffect(() => {\n    if (!registry) return;\n    const unregisters: Array<() => void> = [];\n    // Ambient entries included: an always-on entry owns actions its own\n    // bindings reference exactly as a registry tool does, and leaving them out\n    // gives the same silent failure this hook exists to prevent — a binding\n    // pointing at an id nothing registered.\n    for (const entry of contributionEntries({ registry: toolRegistry, ambient })) {\n      for (const action of entry.actions ?? []) {\n        unregisters.push(registry.register(action));\n      }\n    }\n    return () => { for (const u of unregisters) u(); };\n  }, [registry, toolRegistry, ambient]);\n\n  const menuHost = useMenuHost();\n  useEffect(() => {\n    if (!menuHost) return;\n    const releases: Array<() => void> = [];\n    for (const [id, entry] of Object.entries(toolRegistry)) {\n      for (const def of (entry as SurfaceContribution).menus ?? []) releases.push(menuHost.define(def, id));\n    }\n    for (const entry of ambient) {\n      for (const def of (entry as SurfaceContribution).menus ?? []) releases.push(menuHost.define(def, null));\n    }\n    return () => { for (const r of releases) r(); };\n  }, [menuHost, toolRegistry, ambient]);\n\n  const entries = contributionEntries(tools);\n  // Development only for a warning; a strict surface asked to be stopped, so\n  // it throws in every build.\n  if (versionCheck === 'strict' || (versionCheck === 'warn' && isDev())) {\n    checkEntryRequirements(entries, versionCheck);\n  }\n\n  const reader = depRegistry ?? NO_DEPS;\n  const installs = new Map<object, () => () => void>();\n  for (const entry of entries) {\n    const deps = entry.deps;\n    if (deps && depRegistry) installs.set(deps, () => registerDeps(depRegistry, deps));\n    const attach = entry.attach;\n    if (attach && api) installs.set(attach, () => attach(api, reader));\n  }\n  useKeyedInstall(installs);\n  useContributionFrameHooks(entries, api, reader);\n\n  // Tool assembly runs above the provider too, so its own registration of\n  // held-key engagement finds no registry unless the consumer mounted one.\n  useOffhandAction(contributionEntries(tools));\n}\n\nfunction registerDeps(\n  depRegistry: DepRegistry,\n  deps: NonNullable<SurfaceContribution['deps']>,\n): () => void {\n  const unregisters = (Object.keys(deps) as DepName[]).map((name) =>\n    depRegistry.register(name, deps[name] as never));\n  return () => { for (const u of unregisters) u(); };\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useDepartureGhostLayer.js

@@ -0,0 +1,64 @@
+import { deriveParallaxView } from "../../core/viewport/parallax.js";
+import { composeWorldPose, composesFrames } from "../../core/scene/composeFrame.js";
+import { definesFrame, effectivePose } from "../../core/scene/effectivePose.js";
+import { wrapWithPoseRotation } from "../poseRotation.js";
+import { isCustomEntry } from "../layerSlots.js";
+import { useMemo } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/SceneCanvas/useDepartureGhostLayer.ts
+/**
+* The layer `<SceneCanvas poseTransition exit>` draws removed nodes leaving
+* on: each ghost through the scene slot's `drawOne`, at the pose and opacity
+* its glide shows, inside the frame of a parent still in the scene.
+*/
+function useDepartureGhostLayer(args) {
+	const sceneRef = useLatest(args.scene);
+	const slotRef = useLatest(args.sceneSlot);
+	const { departures } = args;
+	return useMemo(() => ({
+		id: "departure-ghost",
+		label: "Departing nodes",
+		draw: (_data, view) => {
+			const slot = slotRef.current;
+			const leaving = departures.shown();
+			if (leaving.length === 0 || !slot || isCustomEntry(slot) || !slot.drawOne) return [];
+			const drawOne = slot.drawOne;
+			const sc = sceneRef.current;
+			const { compose } = sc.composition;
+			const composes = composesFrames(sc.composition);
+			const frames = {
+				getParent: (id) => sc.get(id)?.parent ?? null,
+				getPose: (id) => effectivePose(sc, sc.get(id)),
+				definesFrame: (id) => definesFrame(sc.get(id))
+			};
+			const viewOf = (layer) => {
+				const parallax = sc.layers.find((l) => l.id === layer)?.parallax;
+				return parallax ? deriveParallaxView(view, parallax) : view;
+			};
+			const draw = (r, pose, out) => {
+				out.push(...wrapWithPoseRotation(drawOne(r.node, pose, viewOf(r.node.layer)), pose));
+				for (const c of r.children) draw(c, composes ? compose(pose, c.pose) : c.pose, out);
+			};
+			return leaving.map(({ removal, pose, alpha }) => {
+				const parent = removal.parent !== null && sc.get(removal.parent) ? removal.parent : null;
+				const world = composes && parent !== null ? compose(composeWorldPose(frames, parent, compose), pose) : pose;
+				const children = [];
+				draw(removal, world, children);
+				return {
+					kind: "group",
+					alpha: Math.max(0, Math.min(1, alpha)),
+					children
+				};
+			});
+		}
+	}), [
+		departures,
+		sceneRef,
+		slotRef
+	]);
+}
+
+//#endregion
+export { useDepartureGhostLayer };
+//# sourceMappingURL=useDepartureGhostLayer.js.map

package/dist/canvas/SceneCanvas/useDepartureGhostLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDepartureGhostLayer.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useDepartureGhostLayer.ts"],"sourcesContent":["/**\n * The layer `<SceneCanvas poseTransition exit>` draws removed nodes leaving\n * on: each ghost through the scene slot's `drawOne`, at the pose and opacity\n * its glide shows, inside the frame of a parent still in the scene.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { composesFrames, composeWorldPose } from 'core/scene/composePose';\nimport { definesFrame, effectivePose } from 'core/scene/effectivePose';\nimport type { RemovedNode } from 'core/scene/poseWrites';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { deriveParallaxView } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport type { Departures } from '../../animation/departures';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\nimport { wrapWithPoseRotation } from '../poseRotation';\n\nexport function useDepartureGhostLayer<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  sceneSlot: LayersMap<Node<TData, TLayer, TPose>, TPose>['scene'];\n  departures: Departures<TPose, Node<TData, TLayer, TPose>>;\n}): RenderLayer<unknown> {\n  const sceneRef = useLatest(args.scene);\n  const slotRef = useLatest(args.sceneSlot);\n  const { departures } = args;\n\n  return useMemo<RenderLayer<unknown>>(() => ({\n    id: 'departure-ghost',\n    label: 'Departing nodes',\n    draw: (_data, view) => {\n      const slot = slotRef.current;\n      const leaving = departures.shown();\n      if (leaving.length === 0 || !slot || isCustomEntry(slot) || !slot.drawOne) return [];\n      const drawOne = slot.drawOne;\n      const sc = sceneRef.current;\n      const { compose } = sc.composition;\n      const composes = composesFrames(sc.composition);\n      const frames = {\n        getParent: (id: string) => sc.get(id as NodeId)?.parent ?? null,\n        getPose: (id: string) => effectivePose(sc, sc.get(id as NodeId)!),\n        definesFrame: (id: string) => definesFrame(sc.get(id as NodeId)!),\n      };\n      const viewOf = (layer: string): View => {\n        const parallax = sc.layers.find((l) => l.id === layer)?.parallax;\n        return parallax ? deriveParallaxView(view, parallax) : view;\n      };\n      const draw = (r: RemovedNode<TPose, Node<TData, TLayer, TPose>>, pose: TPose, out: DrawCommand[]): void => {\n        out.push(...wrapWithPoseRotation(drawOne(r.node, pose, viewOf(r.node.layer)), pose));\n        for (const c of r.children) draw(c, composes ? compose(pose, c.pose) : c.pose, out);\n      };\n      return leaving.map(({ removal, pose, alpha }): DrawCommand => {\n        const parent = removal.parent !== null && sc.get(removal.parent) ? removal.parent : null;\n        const world = composes && parent !== null ? compose(composeWorldPose(frames, parent, compose), pose) : pose;\n        const children: DrawCommand[] = [];\n        draw(removal, world, children);\n        return { kind: 'group', alpha: Math.max(0, Math.min(1, alpha)), children };\n      });\n    },\n  }), [departures, sceneRef, slotRef]);\n}\n"],"mappings":";;;;;;;;;;;;;;AAmBA,SAAgB,uBAA4D,MAInD;CACvB,MAAM,WAAW,UAAU,KAAK,KAAK;CACrC,MAAM,UAAU,UAAU,KAAK,SAAS;CACxC,MAAM,EAAE,eAAe;CAEvB,OAAO,eAAqC;EAC1C,IAAI;EACJ,OAAO;EACP,OAAO,OAAO,SAAS;GACrB,MAAM,OAAO,QAAQ;GACrB,MAAM,UAAU,WAAW,MAAM;GACjC,IAAI,QAAQ,WAAW,KAAK,CAAC,QAAQ,cAAc,IAAI,KAAK,CAAC,KAAK,SAAS,OAAO,CAAC;GACnF,MAAM,UAAU,KAAK;GACrB,MAAM,KAAK,SAAS;GACpB,MAAM,EAAE,YAAY,GAAG;GACvB,MAAM,WAAW,eAAe,GAAG,WAAW;GAC9C,MAAM,SAAS;IACb,YAAY,OAAe,GAAG,IAAI,EAAY,CAAC,EAAE,UAAU;IAC3D,UAAU,OAAe,cAAc,IAAI,GAAG,IAAI,EAAY,CAAE;IAChE,eAAe,OAAe,aAAa,GAAG,IAAI,EAAY,CAAE;GAClE;GACA,MAAM,UAAU,UAAwB;IACtC,MAAM,WAAW,GAAG,OAAO,MAAM,MAAM,EAAE,OAAO,KAAK,CAAC,EAAE;IACxD,OAAO,WAAW,mBAAmB,MAAM,QAAQ,IAAI;GACzD;GACA,MAAM,QAAQ,GAAmD,MAAa,QAA6B;IACzG,IAAI,KAAK,GAAG,qBAAqB,QAAQ,EAAE,MAAM,MAAM,OAAO,EAAE,KAAK,KAAK,CAAC,GAAG,IAAI,CAAC;IACnF,KAAK,MAAM,KAAK,EAAE,UAAU,KAAK,GAAG,WAAW,QAAQ,MAAM,EAAE,IAAI,IAAI,EAAE,MAAM,GAAG;GACpF;GACA,OAAO,QAAQ,KAAK,EAAE,SAAS,MAAM,YAAyB;IAC5D,MAAM,SAAS,QAAQ,WAAW,QAAQ,GAAG,IAAI,QAAQ,MAAM,IAAI,QAAQ,SAAS;IACpF,MAAM,QAAQ,YAAY,WAAW,OAAO,QAAQ,iBAAiB,QAAQ,QAAQ,OAAO,GAAG,IAAI,IAAI;IACvG,MAAM,WAA0B,CAAC;IACjC,KAAK,SAAS,OAAO,QAAQ;IAC7B,OAAO;KAAE,MAAM;KAAS,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC;KAAG;IAAS;GAC3E,CAAC;EACH;CACF,IAAI;EAAC;EAAY;EAAU;CAAO,CAAC;AACrC"}