@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/scene/layerStack.js

@@ -1,131 +1,162 @@
 //#region src/core/scene/layerStack.ts
-function e(e) {
+/** A declared system layer as the stack holds it. */
+function systemLayerRecord(spec) {
 	return {
 		kind: "system",
-		id: e.id,
-		visible: e.visible ?? !0,
-		locked: e.locked ?? !1,
-		...e.parallax ? { parallax: e.parallax } : {}
+		id: spec.id,
+		visible: spec.visible ?? true,
+		locked: spec.locked ?? false,
+		...spec.parallax ? { parallax: spec.parallax } : {},
+		...spec.annotation ? { annotation: true } : {}
 	};
 }
-function t(e, t) {
-	function n(n) {
-		e.layers.length = 0, e.layerIndex.clear(), t();
-		for (let t of n) {
-			if (e.layerIndex.has(t.id)) throw Error(`Scene: duplicate ${t.kind} layer id "${t.id}"`);
-			e.layerIndex.set(t.id, e.layers.length), e.layers.push(t);
+/** The reads over `state`'s layers the rest of the scene uses, and the two
+*  ways the stack is rebuilt. It starts empty; `reset` fills it. */
+function createLayerStack(state, invalidateOrder) {
+	/** Replace the whole stack with `records`, in order. Throws on a duplicate
+	*  id, leaving the stack holding the records before it. */
+	function reset(records) {
+		state.layers.length = 0;
+		state.layerIndex.clear();
+		invalidateOrder();
+		for (const record of records) {
+			if (state.layerIndex.has(record.id)) throw new Error(`Scene: duplicate ${record.kind} layer id "${record.id}"`);
+			state.layerIndex.set(record.id, state.layers.length);
+			state.layers.push(record);
 		}
 	}
-	function r(t) {
-		let n = e.layerIndex.get(t);
-		if (n === void 0) throw Error(`Scene: unknown layer "${t}"`);
-		return n;
+	function requireLayerIndex(layer) {
+		const i = state.layerIndex.get(layer);
+		if (i === void 0) throw new Error(`Scene: unknown layer "${layer}"`);
+		return i;
 	}
-	function i() {
-		t(), e.layerIndex.clear();
-		for (let t = 0; t < e.layers.length; t++) e.layerIndex.set(e.layers[t].id, t);
+	/** Repopulate `state.layerIndex` from the current `state.layers` order.
+	*  Call after any op that inserts, removes, or reorders a layer record. */
+	function rebuildLayerIndex() {
+		invalidateOrder();
+		state.layerIndex.clear();
+		for (let i = 0; i < state.layers.length; i++) state.layerIndex.set(state.layers[i].id, i);
 	}
-	function a(e, t, n, i, a = "place") {
-		if (r(t) < r(i)) {
-			let r = a === "place" ? `cannot place node '${e ?? "<new>"}' on layer '${t}' under parent '${n}' on layer '${i}'` : `cannot setLayer('${e ?? "<new>"}', '${t}') — node has parent '${n}' on layer '${i}'`;
-			throw Error(`Scene: ${r} — a child may not render below its parent's layer`);
+	/**
+	* A child may sit on its parent's layer **or any layer above it** (higher
+	* render index) — never below. `renderOrder()` is layer-major
+	* (each node yielded in its OWN layer's pass) and `buildSceneTree` buckets by
+	* each node's own layer, so a child on a higher layer than its parent renders
+	* correctly on top while staying a tree child for hit-testing / move /
+	* reparent (e.g. plantings tagged into a top `plantings` layer while remaining
+	* children of their container). Rejecting only the *below* case keeps the
+	* sensible invariant that a child never paints under its own parent.
+	*/
+	function assertSubtreeLayer(nodeId, nodeLayer, parentId, parentLayer, verb = "place") {
+		if (requireLayerIndex(nodeLayer) < requireLayerIndex(parentLayer)) {
+			const action = verb === "place" ? `cannot place node '${nodeId ?? "<new>"}' on layer '${nodeLayer}' under parent '${parentId}' on layer '${parentLayer}'` : `cannot setLayer('${nodeId ?? "<new>"}', '${nodeLayer}') — node has parent '${parentId}' on layer '${parentLayer}'`;
+			throw new Error(`Scene: ${action} — a child may not render below its parent's layer`);
 		}
 	}
 	return {
-		reset: n,
-		requireLayerIndex: r,
-		rebuildLayerIndex: i,
-		assertSubtreeLayer: a
+		reset,
+		requireLayerIndex,
+		rebuildLayerIndex,
+		assertSubtreeLayer
 	};
 }
-function n(e, t, n, r) {
-	let i = /* @__PURE__ */ new Map();
-	for (let e = 0; e < t.length; e++) i.set(t[e].id, e);
-	for (let t of e.values()) {
-		if (t.parent === null) continue;
-		let a = e.get(t.parent);
-		if (a && i.get(t.layer) < i.get(a.layer)) throw Error(`Scene: moveLayer("${n}", ${r}) — a child may not render below its parent's layer`);
+/** Throw when moving a layer to give `order` would put a child below its parent. */
+function assertOrderKeepsChildrenAbove(nodes, order, layer, index) {
+	const place = /* @__PURE__ */ new Map();
+	for (let i = 0; i < order.length; i++) place.set(order[i].id, i);
+	for (const node of nodes.values()) {
+		if (node.parent === null) continue;
+		const parent = nodes.get(node.parent);
+		if (!parent) continue;
+		if (place.get(node.layer) < place.get(parent.layer)) throw new Error(`Scene: moveLayer("${layer}", ${index}) — a child may not render below its parent's layer`);
 	}
 }
-function r(e) {
-	let { layers: t, nodes: r, requireLayerIndex: i, record: a } = e;
-	function o(e, n) {
-		let r = t[i(e)];
-		if (r.kind !== "user") throw Error(`Scene: cannot ${n} system layer "${e}"`);
-		return r;
+function createLayerEdits(env) {
+	const { layers, nodes, requireLayerIndex, record } = env;
+	function userLayer(layer, verb) {
+		const rec = layers[requireLayerIndex(layer)];
+		if (rec.kind !== "user") throw new Error(`Scene: cannot ${verb} system layer "${layer}"`);
+		return rec;
 	}
 	return {
-		setLayerVisible(e, n) {
-			let r = t[i(e)];
-			a("kit:setLayerVisible", {
-				layer: e,
-				from: r.visible,
-				to: n
+		setLayerVisible(layer, visible) {
+			const rec = layers[requireLayerIndex(layer)];
+			record("kit:setLayerVisible", {
+				layer,
+				from: rec.visible,
+				to: visible
 			}, "setLayerVisible");
 		},
-		setLayerLocked(e, n) {
-			let r = t[i(e)];
-			a("kit:setLayerLocked", {
-				layer: e,
-				from: r.locked,
-				to: n
+		setLayerLocked(layer, locked) {
+			const rec = layers[requireLayerIndex(layer)];
+			record("kit:setLayerLocked", {
+				layer,
+				from: rec.locked,
+				to: locked
 			}, "setLayerLocked");
 		},
-		setLayerParallax(e, n) {
-			let r = t[i(e)];
-			a("kit:setLayerParallax", {
-				layer: e,
-				from: r.parallax,
-				to: n
+		setLayerParallax(layer, parallax) {
+			const rec = layers[requireLayerIndex(layer)];
+			record("kit:setLayerParallax", {
+				layer,
+				from: rec.parallax,
+				to: parallax
 			}, "setLayerParallax");
 		},
-		addLayer(n) {
-			if (e.layerIndex.has(n.id)) throw Error(`Scene: duplicate layer id "${n.id}"`);
-			let r = Math.max(0, Math.min(n.index ?? t.length, t.length)), i = {
+		addLayer(spec) {
+			if (env.layerIndex.has(spec.id)) throw new Error(`Scene: duplicate layer id "${spec.id}"`);
+			const index = Math.max(0, Math.min(spec.index ?? layers.length, layers.length));
+			const layer = {
 				kind: "user",
-				id: n.id,
-				name: n.name,
-				visible: n.visible ?? !0,
-				locked: n.locked ?? !1,
-				...n.parallax ? { parallax: n.parallax } : {}
+				id: spec.id,
+				name: spec.name,
+				visible: spec.visible ?? true,
+				locked: spec.locked ?? false,
+				...spec.parallax ? { parallax: spec.parallax } : {},
+				...spec.annotation ? { annotation: true } : {}
 			};
-			a("kit:addLayer", {
-				record: i,
-				index: r
+			record("kit:addLayer", {
+				record: layer,
+				index
 			}, "addLayer");
 		},
-		removeLayer(t) {
-			let n = o(t, "remove");
-			e.lifted(() => e.batch("removeLayer", () => {
-				let o = [];
-				for (let [e, n] of r) n.layer === t && o.push(e);
-				e.removeMany(o), a("kit:removeLayer", {
-					record: n,
-					index: i(t)
+		removeLayer(layer) {
+			const rec = userLayer(layer, "remove");
+			env.lifted(() => env.batch("removeLayer", () => {
+				const tagged = [];
+				for (const [id, node] of nodes) if (node.layer === layer) tagged.push(id);
+				env.removeMany(tagged);
+				record("kit:removeLayer", {
+					record: rec,
+					index: requireLayerIndex(layer)
 				}, "removeLayer");
 			}));
 		},
-		renameLayer(e, t) {
-			let n = o(e, "rename");
-			a("kit:renameLayer", {
-				layer: e,
-				from: n.name,
-				to: t
+		renameLayer(layer, name) {
+			const rec = userLayer(layer, "rename");
+			record("kit:renameLayer", {
+				layer,
+				from: rec.name,
+				to: name
 			}, "renameLayer");
 		},
-		moveLayer(e, o) {
-			let s = i(e), c = Math.max(0, Math.min(o, t.length - 1));
-			if (s === c) return;
-			let l = [...t], [u] = l.splice(s, 1);
-			l.splice(c, 0, u), n(r, l, e, o), a("kit:moveLayer", {
-				layer: e,
-				from: s,
-				to: c
+		moveLayer(layer, index) {
+			const from = requireLayerIndex(layer);
+			const to = Math.max(0, Math.min(index, layers.length - 1));
+			if (from === to) return;
+			const proposed = [...layers];
+			const [rec] = proposed.splice(from, 1);
+			proposed.splice(to, 0, rec);
+			assertOrderKeepsChildrenAbove(nodes, proposed, layer, index);
+			record("kit:moveLayer", {
+				layer,
+				from,
+				to
 			}, "moveLayer");
 		}
 	};
 }
-//#endregion
-export { r as createLayerEdits, t as createLayerStack, e as systemLayerRecord };
 
+//#endregion
+export { createLayerEdits, createLayerStack, systemLayerRecord };
 //# sourceMappingURL=layerStack.js.map

package/dist/core/scene/layerStack.js.map

@@ -1 +1 @@
-{"version":3,"file":"layerStack.js","names":["systemLayerRecord","spec","createLayerStack","reset","state","invalidateOrder","record","records","requireLayerIndex","i","layer","rebuildLayerIndex","assertSubtreeLayer","nodeLayer","parentLayer","action","verb","nodeId","parentId","assertOrderKeepsChildrenAbove","place","order","node","nodes","parent","index","createLayerEdits","env","userLayer","rec","layers","visible","locked","parallax","tagged","id","name","from","to","proposed"],"sources":["../../../src/core/scene/layerStack.ts"],"sourcesContent":["/**\n * The scene's layer stack: the ordered layer records, the index from a\n * layer's id to its place in that order, the rule tying a node's layer to\n * its parent's, and the edits a caller makes to the stack.\n */\nimport type { LayerRecord, Node, NodeId, Scene, UseSceneOptions, UserLayerRecord } from './types';\n\n/** What the stack keeps of a scene's state. */\nexport interface LayerStackState<TLayer extends string> {\n  layers: LayerRecord<TLayer>[];\n  layerIndex: Map<TLayer, number>;\n}\n\n/** A declared system layer as the stack holds it. */\nexport function systemLayerRecord<TLayer extends string>(\n  spec: UseSceneOptions<unknown, TLayer, unknown>['systemLayers'][number],\n): LayerRecord<TLayer> {\n  return {\n    kind: 'system',\n    id: spec.id,\n    visible: spec.visible ?? true,\n    locked: spec.locked ?? false,\n    ...(spec.parallax ? { parallax: spec.parallax } : {}),\n  };\n}\n\n/** The reads over `state`'s layers the rest of the scene uses, and the two\n *  ways the stack is rebuilt. It starts empty; `reset` fills it. */\nexport function createLayerStack<TLayer extends string>(\n  state: LayerStackState<TLayer>,\n  /** Called whenever the layer order changes. */\n  invalidateOrder: () => void,\n) {\n  /** Replace the whole stack with `records`, in order. Throws on a duplicate\n   *  id, leaving the stack holding the records before it. */\n  function reset(records: readonly LayerRecord<TLayer>[]): void {\n    state.layers.length = 0;\n    state.layerIndex.clear();\n    invalidateOrder();\n    for (const record of records) {\n      if (state.layerIndex.has(record.id)) {\n        throw new Error(`Scene: duplicate ${record.kind} layer id \"${record.id}\"`);\n      }\n      state.layerIndex.set(record.id, state.layers.length);\n      state.layers.push(record);\n    }\n  }\n\n  function requireLayerIndex(layer: TLayer): number {\n    const i = state.layerIndex.get(layer);\n    if (i === undefined) throw new Error(`Scene: unknown layer \"${layer}\"`);\n    return i;\n  }\n\n  /** Repopulate `state.layerIndex` from the current `state.layers` order.\n   *  Call after any op that inserts, removes, or reorders a layer record. */\n  function rebuildLayerIndex(): void {\n    invalidateOrder();\n    state.layerIndex.clear();\n    for (let i = 0; i < state.layers.length; i++) {\n      state.layerIndex.set(state.layers[i].id, i);\n    }\n  }\n\n  /**\n   * A child may sit on its parent's layer **or any layer above it** (higher\n   * render index) — never below. `renderOrder()` is layer-major\n   * (each node yielded in its OWN layer's pass) and `buildSceneTree` buckets by\n   * each node's own layer, so a child on a higher layer than its parent renders\n   * correctly on top while staying a tree child for hit-testing / move /\n   * reparent (e.g. plantings tagged into a top `plantings` layer while remaining\n   * children of their container). Rejecting only the *below* case keeps the\n   * sensible invariant that a child never paints under its own parent.\n   */\n  function assertSubtreeLayer(\n    nodeId: string | undefined,\n    nodeLayer: TLayer,\n    parentId: NodeId,\n    parentLayer: TLayer,\n    verb: 'place' | 'relayer' = 'place',\n  ): void {\n    if (requireLayerIndex(nodeLayer) < requireLayerIndex(parentLayer)) {\n      const action = verb === 'place'\n        ? `cannot place node '${nodeId ?? '<new>'}' on layer '${nodeLayer}' under parent '${parentId}' on layer '${parentLayer}'`\n        : `cannot setLayer('${nodeId ?? '<new>'}', '${nodeLayer}') — node has parent '${parentId}' on layer '${parentLayer}'`;\n      throw new Error(`Scene: ${action} — a child may not render below its parent's layer`);\n    }\n  }\n\n  return { reset, requireLayerIndex, rebuildLayerIndex, assertSubtreeLayer };\n}\n\n/** What the layer edits read of the scene, and what they record through. */\nexport interface LayerEditsEnv<TData, TLayer extends string, TPose> {\n  layers: readonly LayerRecord<TLayer>[];\n  layerIndex: ReadonlyMap<TLayer, number>;\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  requireLayerIndex(layer: TLayer): number;\n  /** Apply a kit op and record it as an edit. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run with the lock guard lifted. */\n  lifted<T>(fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  removeMany(ids: readonly NodeId[]): void;\n}\n\nexport type LayerEdits<TData, TLayer extends string, TPose> = Pick<\n  Scene<TData, TLayer, TPose>,\n  | 'setLayerVisible' | 'setLayerLocked' | 'setLayerParallax'\n  | 'addLayer' | 'removeLayer' | 'renameLayer' | 'moveLayer'\n>;\n\n/** Throw when moving a layer to give `order` would put a child below its parent. */\nfunction assertOrderKeepsChildrenAbove<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n  order: readonly LayerRecord<TLayer>[],\n  layer: TLayer,\n  index: number,\n): void {\n  const place = new Map<TLayer, number>();\n  for (let i = 0; i < order.length; i++) place.set(order[i].id, i);\n  for (const node of nodes.values()) {\n    if (node.parent === null) continue;\n    const parent = nodes.get(node.parent);\n    if (!parent) continue;\n    if (place.get(node.layer)! < place.get(parent.layer)!) {\n      throw new Error(\n        `Scene: moveLayer(\"${layer}\", ${index}) — a child may not render below its parent's layer`,\n      );\n    }\n  }\n}\n\nexport function createLayerEdits<TData, TLayer extends string, TPose>(\n  env: LayerEditsEnv<TData, TLayer, TPose>,\n): LayerEdits<TData, TLayer, TPose> {\n  const { layers, nodes, requireLayerIndex, record } = env;\n\n  function userLayer(layer: TLayer, verb: string): UserLayerRecord<TLayer> {\n    const rec = layers[requireLayerIndex(layer)];\n    if (rec.kind !== 'user') throw new Error(`Scene: cannot ${verb} system layer \"${layer}\"`);\n    return rec;\n  }\n\n  return {\n    setLayerVisible(layer, visible) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerVisible', { layer, from: rec.visible, to: visible }, 'setLayerVisible');\n    },\n\n    setLayerLocked(layer, locked) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerLocked', { layer, from: rec.locked, to: locked }, 'setLayerLocked');\n    },\n\n    setLayerParallax(layer, parallax) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerParallax', { layer, from: rec.parallax, to: parallax }, 'setLayerParallax');\n    },\n\n    addLayer(spec) {\n      if (env.layerIndex.has(spec.id)) throw new Error(`Scene: duplicate layer id \"${spec.id}\"`);\n      const index = Math.max(0, Math.min(spec.index ?? layers.length, layers.length));\n      const layer: UserLayerRecord<TLayer> = {\n        kind: 'user',\n        id: spec.id,\n        name: spec.name,\n        visible: spec.visible ?? true,\n        locked: spec.locked ?? false,\n        ...(spec.parallax ? { parallax: spec.parallax } : {}),\n      };\n      record('kit:addLayer', { record: layer, index }, 'addLayer');\n    },\n\n    removeLayer(layer) {\n      const rec = userLayer(layer, 'remove');\n      // A layer operation, like the lock toggle: taking a locked layer away\n      // takes its nodes with it.\n      env.lifted(() => env.batch('removeLayer', () => {\n        const tagged: NodeId[] = [];\n        for (const [id, node] of nodes) {\n          if (node.layer === layer) tagged.push(id);\n        }\n        env.removeMany(tagged);\n        record('kit:removeLayer', { record: rec, index: requireLayerIndex(layer) }, 'removeLayer');\n      }));\n    },\n\n    renameLayer(layer, name) {\n      const rec = userLayer(layer, 'rename');\n      record('kit:renameLayer', { layer, from: rec.name, to: name }, 'renameLayer');\n    },\n\n    moveLayer(layer, index) {\n      const from = requireLayerIndex(layer);\n      const to = Math.max(0, Math.min(index, layers.length - 1));\n      if (from === to) return;\n      const proposed = [...layers];\n      const [rec] = proposed.splice(from, 1);\n      proposed.splice(to, 0, rec);\n      assertOrderKeepsChildrenAbove(nodes, proposed, layer, index);\n      record('kit:moveLayer', { layer, from, to }, 'moveLayer');\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"layerStack.js","names":[],"sources":["../../../src/core/scene/layerStack.ts"],"sourcesContent":["/**\n * The scene's layer stack: the ordered layer records, the index from a\n * layer's id to its place in that order, the rule tying a node's layer to\n * its parent's, and the edits a caller makes to the stack.\n */\nimport type { LayerRecord, Node, NodeId, Scene, UseSceneOptions, UserLayerRecord } from './types';\n\n/** What the stack keeps of a scene's state. */\nexport interface LayerStackState<TLayer extends string> {\n  layers: LayerRecord<TLayer>[];\n  layerIndex: Map<TLayer, number>;\n}\n\n/** A declared system layer as the stack holds it. */\nexport function systemLayerRecord<TLayer extends string>(\n  spec: UseSceneOptions<unknown, TLayer, unknown>['systemLayers'][number],\n): LayerRecord<TLayer> {\n  return {\n    kind: 'system',\n    id: spec.id,\n    visible: spec.visible ?? true,\n    locked: spec.locked ?? false,\n    ...(spec.parallax ? { parallax: spec.parallax } : {}),\n    ...(spec.annotation ? { annotation: true } : {}),\n  };\n}\n\n/** The reads over `state`'s layers the rest of the scene uses, and the two\n *  ways the stack is rebuilt. It starts empty; `reset` fills it. */\nexport function createLayerStack<TLayer extends string>(\n  state: LayerStackState<TLayer>,\n  /** Called whenever the layer order changes. */\n  invalidateOrder: () => void,\n) {\n  /** Replace the whole stack with `records`, in order. Throws on a duplicate\n   *  id, leaving the stack holding the records before it. */\n  function reset(records: readonly LayerRecord<TLayer>[]): void {\n    state.layers.length = 0;\n    state.layerIndex.clear();\n    invalidateOrder();\n    for (const record of records) {\n      if (state.layerIndex.has(record.id)) {\n        throw new Error(`Scene: duplicate ${record.kind} layer id \"${record.id}\"`);\n      }\n      state.layerIndex.set(record.id, state.layers.length);\n      state.layers.push(record);\n    }\n  }\n\n  function requireLayerIndex(layer: TLayer): number {\n    const i = state.layerIndex.get(layer);\n    if (i === undefined) throw new Error(`Scene: unknown layer \"${layer}\"`);\n    return i;\n  }\n\n  /** Repopulate `state.layerIndex` from the current `state.layers` order.\n   *  Call after any op that inserts, removes, or reorders a layer record. */\n  function rebuildLayerIndex(): void {\n    invalidateOrder();\n    state.layerIndex.clear();\n    for (let i = 0; i < state.layers.length; i++) {\n      state.layerIndex.set(state.layers[i].id, i);\n    }\n  }\n\n  /**\n   * A child may sit on its parent's layer **or any layer above it** (higher\n   * render index) — never below. `renderOrder()` is layer-major\n   * (each node yielded in its OWN layer's pass) and `buildSceneTree` buckets by\n   * each node's own layer, so a child on a higher layer than its parent renders\n   * correctly on top while staying a tree child for hit-testing / move /\n   * reparent (e.g. plantings tagged into a top `plantings` layer while remaining\n   * children of their container). Rejecting only the *below* case keeps the\n   * sensible invariant that a child never paints under its own parent.\n   */\n  function assertSubtreeLayer(\n    nodeId: string | undefined,\n    nodeLayer: TLayer,\n    parentId: NodeId,\n    parentLayer: TLayer,\n    verb: 'place' | 'relayer' = 'place',\n  ): void {\n    if (requireLayerIndex(nodeLayer) < requireLayerIndex(parentLayer)) {\n      const action = verb === 'place'\n        ? `cannot place node '${nodeId ?? '<new>'}' on layer '${nodeLayer}' under parent '${parentId}' on layer '${parentLayer}'`\n        : `cannot setLayer('${nodeId ?? '<new>'}', '${nodeLayer}') — node has parent '${parentId}' on layer '${parentLayer}'`;\n      throw new Error(`Scene: ${action} — a child may not render below its parent's layer`);\n    }\n  }\n\n  return { reset, requireLayerIndex, rebuildLayerIndex, assertSubtreeLayer };\n}\n\n/** What the layer edits read of the scene, and what they record through. */\nexport interface LayerEditsEnv<TData, TLayer extends string, TPose> {\n  layers: readonly LayerRecord<TLayer>[];\n  layerIndex: ReadonlyMap<TLayer, number>;\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;\n  requireLayerIndex(layer: TLayer): number;\n  /** Apply a kit op and record it as an edit. */\n  record(kind: string, payload: unknown, label: string): void;\n  /** Run with the lock guard lifted. */\n  lifted<T>(fn: () => T): T;\n  batch<T>(label: string, fn: () => T): T;\n  removeMany(ids: readonly NodeId[]): void;\n}\n\nexport type LayerEdits<TData, TLayer extends string, TPose> = Pick<\n  Scene<TData, TLayer, TPose>,\n  | 'setLayerVisible' | 'setLayerLocked' | 'setLayerParallax'\n  | 'addLayer' | 'removeLayer' | 'renameLayer' | 'moveLayer'\n>;\n\n/** Throw when moving a layer to give `order` would put a child below its parent. */\nfunction assertOrderKeepsChildrenAbove<TData, TLayer extends string, TPose>(\n  nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>,\n  order: readonly LayerRecord<TLayer>[],\n  layer: TLayer,\n  index: number,\n): void {\n  const place = new Map<TLayer, number>();\n  for (let i = 0; i < order.length; i++) place.set(order[i].id, i);\n  for (const node of nodes.values()) {\n    if (node.parent === null) continue;\n    const parent = nodes.get(node.parent);\n    if (!parent) continue;\n    if (place.get(node.layer)! < place.get(parent.layer)!) {\n      throw new Error(\n        `Scene: moveLayer(\"${layer}\", ${index}) — a child may not render below its parent's layer`,\n      );\n    }\n  }\n}\n\nexport function createLayerEdits<TData, TLayer extends string, TPose>(\n  env: LayerEditsEnv<TData, TLayer, TPose>,\n): LayerEdits<TData, TLayer, TPose> {\n  const { layers, nodes, requireLayerIndex, record } = env;\n\n  function userLayer(layer: TLayer, verb: string): UserLayerRecord<TLayer> {\n    const rec = layers[requireLayerIndex(layer)];\n    if (rec.kind !== 'user') throw new Error(`Scene: cannot ${verb} system layer \"${layer}\"`);\n    return rec;\n  }\n\n  return {\n    setLayerVisible(layer, visible) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerVisible', { layer, from: rec.visible, to: visible }, 'setLayerVisible');\n    },\n\n    setLayerLocked(layer, locked) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerLocked', { layer, from: rec.locked, to: locked }, 'setLayerLocked');\n    },\n\n    setLayerParallax(layer, parallax) {\n      const rec = layers[requireLayerIndex(layer)];\n      record('kit:setLayerParallax', { layer, from: rec.parallax, to: parallax }, 'setLayerParallax');\n    },\n\n    addLayer(spec) {\n      if (env.layerIndex.has(spec.id)) throw new Error(`Scene: duplicate layer id \"${spec.id}\"`);\n      const index = Math.max(0, Math.min(spec.index ?? layers.length, layers.length));\n      const layer: UserLayerRecord<TLayer> = {\n        kind: 'user',\n        id: spec.id,\n        name: spec.name,\n        visible: spec.visible ?? true,\n        locked: spec.locked ?? false,\n        ...(spec.parallax ? { parallax: spec.parallax } : {}),\n        ...(spec.annotation ? { annotation: true } : {}),\n      };\n      record('kit:addLayer', { record: layer, index }, 'addLayer');\n    },\n\n    removeLayer(layer) {\n      const rec = userLayer(layer, 'remove');\n      // A layer operation, like the lock toggle: taking a locked layer away\n      // takes its nodes with it.\n      env.lifted(() => env.batch('removeLayer', () => {\n        const tagged: NodeId[] = [];\n        for (const [id, node] of nodes) {\n          if (node.layer === layer) tagged.push(id);\n        }\n        env.removeMany(tagged);\n        record('kit:removeLayer', { record: rec, index: requireLayerIndex(layer) }, 'removeLayer');\n      }));\n    },\n\n    renameLayer(layer, name) {\n      const rec = userLayer(layer, 'rename');\n      record('kit:renameLayer', { layer, from: rec.name, to: name }, 'renameLayer');\n    },\n\n    moveLayer(layer, index) {\n      const from = requireLayerIndex(layer);\n      const to = Math.max(0, Math.min(index, layers.length - 1));\n      if (from === to) return;\n      const proposed = [...layers];\n      const [rec] = proposed.splice(from, 1);\n      proposed.splice(to, 0, rec);\n      assertOrderKeepsChildrenAbove(nodes, proposed, layer, index);\n      record('kit:moveLayer', { layer, from, to }, 'moveLayer');\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/layoutPass.js

@@ -1,95 +1,166 @@
-import { composeWorldPose as e, rebaseLocalPose as t } from "./composeFrame.js";
-import { samePoseValue as n } from "./poseSnapshot.js";
-import { definesFrame as r, documentPose as i } from "./effectivePose.js";
-import { asRectPose as a } from "./kitRegistry.js";
+import { composeWorldPose, rebaseLocalPose } from "./composeFrame.js";
+import { samePoseValue } from "./poseSnapshot.js";
+import { definesFrame, documentPose } from "./effectivePose.js";
+import { carriedDescendants } from "./carryDescendants.js";
+import { asRectPose } from "./kitRegistry.js";
+
 //#region src/core/scene/layoutPass.ts
-function o(e) {
+/**
+* The one computation behind a scene's container layouts: given the
+* containers one edit changed, the pose writes their layouts ask for.
+*
+* A container that lost children and whose strategy has `depart` rearranges
+* the rest through it (and may shrink). One that gained children and whose
+* strategy has `arrive` then places them through it (and may refuse, or
+* grow). Any other changed container — one that reordered children, was
+* resized, had a child moved, or gained or lost children with neither hook —
+* is put back in its resting arrangement, `childPoses`.
+*
+* `LayoutStrategy` is world-framed, so each pose is composed to world before
+* a strategy sees it and each result is rebased into its node's parent frame
+* after. A child already where the strategy puts it is left out, so a pass
+* that changes nothing writes nothing. A child the pass moves takes its own
+* descendants along (`carriedDescendants`). A container this pass resizes is
+* arranged in turn, so nested layouts settle in the same edit.
+*/
+function resolveLayoutFrame(frame) {
 	return {
-		bounds: e?.bounds ?? ((e) => {
-			let t = a(e);
-			return t === null ? null : {
-				x: t.x,
-				y: t.y,
-				width: t.width,
-				height: t.height
+		bounds: frame?.bounds ?? ((pose) => {
+			const r = asRectPose(pose);
+			return r === null ? null : {
+				x: r.x,
+				y: r.y,
+				width: r.width,
+				height: r.height
 			};
 		}),
-		remap: e?.remap ?? ((e, t, n) => ({
-			...e,
-			...n
+		remap: frame?.remap ?? ((pose, _from, to) => ({
+			...pose,
+			...to
 		}))
 	};
 }
-function s(e, t, n, r) {
-	let i = e.bounds(n, t), a = e.bounds(r, t);
-	return i === null || a === null ? i !== a : i.width !== a.width || i.height !== a.height;
+/** Whether a node going from `from` to `to` changed size. */
+function resized(frame, id, from, to) {
+	const a = frame.bounds(from, id);
+	const b = frame.bounds(to, id);
+	if (a === null || b === null) return a !== b;
+	return a.width !== b.width || a.height !== b.height;
 }
-var c = 16;
-function l(a, o, l, u, d, f = /* @__PURE__ */ new Map()) {
-	let p = /* @__PURE__ */ new Map(), m = (e) => p.get(e) ?? i(a, a.get(e)), h = {
-		getPose: (e) => m(e),
-		getParent: (e) => a.get(e)?.parent ?? null,
-		definesFrame: (e) => {
-			let t = a.get(e);
-			return t === void 0 || r(t);
+/** How many times one pass may arrange a container before giving up on it —
+*  only nested layouts that keep resizing each other get close. */
+var MAX_PASSES = 16;
+function runLayoutPass(source, layoutOf, arrivals, changed, frame, departures = /* @__PURE__ */ new Map()) {
+	const out = /* @__PURE__ */ new Map();
+	const poseOf = (id) => out.get(id) ?? documentPose(source, source.get(id));
+	const pa = {
+		getPose: (id) => poseOf(id),
+		getParent: (id) => source.get(id)?.parent ?? null,
+		definesFrame: (id) => {
+			const node = source.get(id);
+			return node === void 0 || definesFrame(node);
 		}
-	}, { compose: g, decompose: _ } = a.composition, v = (t) => e(h, t, g), y = [.../* @__PURE__ */ new Set([...l.keys(), ...u])], b = /* @__PURE__ */ new Map(), x = (e, t) => {
-		let r = a.get(e), i = m(e);
-		n(i, t) || (p.set(e, t), e !== S && r.kind === "container" && o(e) !== null && s(d, e, i, t) && y.push(e));
-	}, S = null, C = (e) => {
-		let t = v(e), n = d.bounds(t, e);
-		if (n === null) return null;
-		let r = a.childrenOf(e).map((e) => ({
-			id: e,
-			pose: v(e)
+	};
+	const { compose, decompose } = source.composition;
+	const world = (id) => composeWorldPose(pa, id, compose);
+	const queue = [.../* @__PURE__ */ new Set([...arrivals.keys(), ...changed])];
+	const passes = /* @__PURE__ */ new Map();
+	const write = (id, pose) => {
+		const node = source.get(id);
+		const before = poseOf(id);
+		if (samePoseValue(before, pose)) return;
+		out.set(id, pose);
+		if (id !== current && node.kind === "container" && layoutOf(id) !== null && resized(frame, id, before, pose)) queue.push(id);
+	};
+	let current = null;
+	/** The container and its children as the strategy sees them, in world,
+	*  with every write this pass has made so far folded in. */
+	const frameOf = (containerId) => {
+		const pose = world(containerId);
+		const bounds = frame.bounds(pose, containerId);
+		if (bounds === null) return null;
+		const children = source.childrenOf(containerId).map((cid) => ({
+			id: cid,
+			pose: world(cid)
 		}));
 		return {
-			world: t,
+			world: pose,
 			container: {
-				id: e,
-				bounds: n
+				id: containerId,
+				bounds
 			},
-			children: r
+			children
 		};
-	}, w = (e, n, r) => {
-		if (r.bounds) {
-			let i = a.get(e), o = d.remap(n.world, n.container.bounds, r.bounds, e);
-			x(e, t(h, o, i.parent, g, _));
+	};
+	const apply = (containerId, at, result) => {
+		if (result.bounds) {
+			const node = source.get(containerId);
+			const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);
+			write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));
 		}
-		for (let [n, i] of r.poses) {
-			let r = n;
-			a.get(r)?.parent === e && x(r, t(h, i, e, g, _));
+		for (const [cid, pose] of result.poses) {
+			const id = cid;
+			if (source.get(id)?.parent !== containerId) continue;
+			const before = frame.bounds(world(id), id);
+			write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));
+			carry(id, before);
 		}
 	};
-	for (; y.length > 0;) {
-		let e = y.shift();
-		S = e;
-		let t = (b.get(e) ?? 0) + 1;
-		if (b.set(e, t), t > c) continue;
-		let n = o(e);
-		if (n === null || a.get(e) === void 0) continue;
-		let r = t === 1 ? l.get(e) : void 0, i = t === 1 ? f.get(e) : void 0, s = !1;
-		if (i !== void 0 && n.depart) {
-			let t = C(e);
-			if (t === null) continue;
-			let a = new Set(r ?? []), o = t.children.filter((e) => !a.has(e.id));
-			w(e, t, n.depart(t.container, o, new Set(i))), s = !0;
+	/** Moves `id`'s descendants by however far its write just moved it from `before`. */
+	const carry = (id, before) => {
+		const after = frame.bounds(world(id), id);
+		if (before === null || after === null) return;
+		const dx = after.x - before.x;
+		const dy = after.y - before.y;
+		if (dx === 0 && dy === 0) return;
+		const carried = carriedDescendants({
+			childrenOf: (cid) => source.childrenOf(cid),
+			poses: pa,
+			composition: source.composition
+		}, id, (pose, cid) => {
+			const b = frame.bounds(pose, cid);
+			return b === null ? null : frame.remap(pose, b, {
+				...b,
+				x: b.x + dx,
+				y: b.y + dy
+			}, cid);
+		});
+		for (const [cid, pose] of carried) write(cid, pose);
+	};
+	while (queue.length > 0) {
+		const containerId = queue.shift();
+		current = containerId;
+		const n = (passes.get(containerId) ?? 0) + 1;
+		passes.set(containerId, n);
+		if (n > MAX_PASSES) continue;
+		const layout = layoutOf(containerId);
+		if (layout === null || source.get(containerId) === void 0) continue;
+		const joined = n === 1 ? arrivals.get(containerId) : void 0;
+		const left = n === 1 ? departures.get(containerId) : void 0;
+		let arranged = false;
+		if (left !== void 0 && layout.depart) {
+			const at = frameOf(containerId);
+			if (at === null) continue;
+			const joinedSet = new Set(joined ?? []);
+			const staying = at.children.filter((c) => !joinedSet.has(c.id));
+			apply(containerId, at, layout.depart(at.container, staying, new Set(left)));
+			arranged = true;
 		}
-		if (r !== void 0 && n.arrive) {
-			let t = C(e);
-			if (t === null) continue;
-			let i = n.arrive(t.container, t.children, new Set(r));
-			if (i === null) return null;
-			w(e, t, i);
-		} else if (!s || r !== void 0) {
-			let t = C(e);
-			if (t === null) continue;
-			w(e, t, { poses: n.childPoses(t.container, t.children) });
+		if (joined !== void 0 && layout.arrive) {
+			const at = frameOf(containerId);
+			if (at === null) continue;
+			const result = layout.arrive(at.container, at.children, new Set(joined));
+			if (result === null) return null;
+			apply(containerId, at, result);
+		} else if (!arranged || joined !== void 0) {
+			const at = frameOf(containerId);
+			if (at === null) continue;
+			apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });
 		}
 	}
-	return p;
+	return out;
 }
-//#endregion
-export { s as resized, o as resolveLayoutFrame, l as runLayoutPass };
 
+//#endregion
+export { resized, resolveLayoutFrame, runLayoutPass };
 //# sourceMappingURL=layoutPass.js.map

package/dist/core/scene/layoutPass.js.map

@@ -1 +1 @@
-{"version":3,"file":"layoutPass.js","names":["resolveLayoutFrame","frame","r","asRectPose","pose","to","resized","a","from","id","b","MAX_PASSES","runLayoutPass","out","poseOf","documentPose","source","pa","node","definesFrame","world","composeWorldPose","compose","queue","arrivals","changed","passes","write","before","samePoseValue","current","layoutOf","frameOf","containerId","bounds","children","cid","apply","result","sized","at","rebaseLocalPose","decompose","n","layout","joined","left","departures","arranged","joinedSet","staying","c"],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, or gained or lost children with neither hook — is put back in its\n * resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n  readonly composition: PoseComposition<TPose>;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = source.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n    }\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":"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"}
+{"version":3,"file":"layoutPass.js","names":[],"sources":["../../../src/core/scene/layoutPass.ts"],"sourcesContent":["/**\n * The one computation behind a scene's container layouts: given the\n * containers one edit changed, the pose writes their layouts ask for.\n *\n * A container that lost children and whose strategy has `depart` rearranges\n * the rest through it (and may shrink). One that gained children and whose\n * strategy has `arrive` then places them through it (and may refuse, or\n * grow). Any other changed container — one that reordered children, was\n * resized, had a child moved, or gained or lost children with neither hook —\n * is put back in its resting arrangement, `childPoses`.\n *\n * `LayoutStrategy` is world-framed, so each pose is composed to world before\n * a strategy sees it and each result is rebased into its node's parent frame\n * after. A child already where the strategy puts it is left out, so a pass\n * that changes nothing writes nothing. A child the pass moves takes its own\n * descendants along (`carriedDescendants`). A container this pass resizes is\n * arranged in turn, so nested layouts settle in the same edit.\n */\nimport {\n  composeWorldPose,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseComposition,\n} from './composeFrame';\nimport type { ContainerBounds, LayoutArrival, LayoutChild, LayoutStrategy } from '../../layout/types';\nimport { carriedDescendants } from './carryDescendants';\nimport { definesFrame, documentPose, type PoseSource, type PosedNode } from './effectivePose';\nimport { asRectPose } from './kitRegistry';\nimport { samePoseValue } from './poseSnapshot';\nimport type { LayoutFrame, NodeId } from './types';\n\n/** What the pass reads a scene through. */\nexport interface LayoutPassSource<TPose> extends PoseSource<TPose> {\n  get(id: NodeId): (PosedNode<TPose> & { parent: NodeId | null }) | undefined;\n  readonly composition: PoseComposition<TPose>;\n}\n\n/** How the pass measures and resizes poses, with every default filled. */\nexport interface ResolvedLayoutFrame<TPose> {\n  bounds(pose: TPose, id: NodeId): ContainerBounds | null;\n  remap(pose: TPose, from: ContainerBounds, to: ContainerBounds, id: NodeId): TPose;\n}\n\n/** The pose writes one edit's layouts ask for, or `null` when a strategy\n *  refused the children that joined it. */\nexport type LayoutPassResult<TPose> = Map<NodeId, TPose> | null;\n\nexport function resolveLayoutFrame<TPose>(frame: LayoutFrame<TPose> | undefined): ResolvedLayoutFrame<TPose> {\n  return {\n    bounds: frame?.bounds ?? ((pose) => {\n      const r = asRectPose(pose);\n      return r === null ? null : { x: r.x, y: r.y, width: r.width, height: r.height };\n    }),\n    remap: frame?.remap ?? ((pose, _from, to) => ({ ...(pose as object), ...to }) as TPose),\n  };\n}\n\n/** Whether a node going from `from` to `to` changed size. */\nexport function resized<TPose>(frame: ResolvedLayoutFrame<TPose>, id: NodeId, from: TPose, to: TPose): boolean {\n  const a = frame.bounds(from, id);\n  const b = frame.bounds(to, id);\n  if (a === null || b === null) return a !== b;\n  return a.width !== b.width || a.height !== b.height;\n}\n\n/** How many times one pass may arrange a container before giving up on it —\n *  only nested layouts that keep resizing each other get close. */\nconst MAX_PASSES = 16;\n\nexport function runLayoutPass<TPose>(\n  source: LayoutPassSource<TPose>,\n  layoutOf: (id: NodeId) => LayoutStrategy<TPose> | null,\n  arrivals: ReadonlyMap<NodeId, readonly NodeId[]>,\n  changed: ReadonlySet<NodeId>,\n  frame: ResolvedLayoutFrame<TPose>,\n  departures: ReadonlyMap<NodeId, readonly NodeId[]> = new Map(),\n): LayoutPassResult<TPose> {\n  // Poses already decided in this pass, so a container resized here is the\n  // frame its children are rebased into.\n  const out = new Map<NodeId, TPose>();\n  const poseOf = (id: NodeId): TPose => out.get(id) ?? documentPose(source, source.get(id)!);\n  const pa: PoseAdapter<TPose> = {\n    getPose: (id) => poseOf(id as NodeId),\n    getParent: (id) => source.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = source.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n  const { compose, decompose } = source.composition;\n  const world = (id: NodeId): TPose => composeWorldPose(pa, id, compose);\n\n  const queue: NodeId[] = [...new Set<NodeId>([...arrivals.keys(), ...changed])];\n  const passes = new Map<NodeId, number>();\n  const write = (id: NodeId, pose: TPose): void => {\n    const node = source.get(id)!;\n    const before = poseOf(id);\n    if (samePoseValue(before, pose)) return;\n    out.set(id, pose);\n    // A container its own `depart` or `arrive` resized is arranged already.\n    if (id !== current && node.kind === 'container' && layoutOf(id) !== null\n      && resized(frame, id, before, pose)) queue.push(id);\n  };\n  let current: NodeId | null = null;\n\n  /** The container and its children as the strategy sees them, in world,\n   *  with every write this pass has made so far folded in. */\n  const frameOf = (containerId: NodeId) => {\n    const pose = world(containerId);\n    const bounds = frame.bounds(pose, containerId);\n    if (bounds === null) return null;\n    const children: LayoutChild<TPose>[] = source.childrenOf(containerId).map((cid) => ({\n      id: cid as string,\n      pose: world(cid),\n    }));\n    return { world: pose, container: { id: containerId as string, bounds }, children };\n  };\n  const apply = (\n    containerId: NodeId,\n    at: NonNullable<ReturnType<typeof frameOf>>,\n    result: LayoutArrival<TPose>,\n  ): void => {\n    if (result.bounds) {\n      const node = source.get(containerId)!;\n      const sized = frame.remap(at.world, at.container.bounds, result.bounds, containerId);\n      write(containerId, rebaseLocalPose(pa, sized, node.parent, compose, decompose));\n    }\n    for (const [cid, pose] of result.poses) {\n      const id = cid as NodeId;\n      if (source.get(id)?.parent !== containerId) continue;\n      const before = frame.bounds(world(id), id);\n      write(id, rebaseLocalPose(pa, pose, containerId, compose, decompose));\n      carry(id, before);\n    }\n  };\n  /** Moves `id`'s descendants by however far its write just moved it from `before`. */\n  const carry = (id: NodeId, before: ContainerBounds | null): void => {\n    const after = frame.bounds(world(id), id);\n    if (before === null || after === null) return;\n    const dx = after.x - before.x;\n    const dy = after.y - before.y;\n    if (dx === 0 && dy === 0) return;\n    const carried = carriedDescendants(\n      { childrenOf: (cid) => source.childrenOf(cid), poses: pa, composition: source.composition },\n      id,\n      (pose, cid) => {\n        const b = frame.bounds(pose, cid);\n        return b === null ? null : frame.remap(pose, b, { ...b, x: b.x + dx, y: b.y + dy }, cid);\n      },\n    );\n    for (const [cid, pose] of carried) write(cid, pose);\n  };\n\n  while (queue.length > 0) {\n    const containerId = queue.shift()!;\n    current = containerId;\n    const n = (passes.get(containerId) ?? 0) + 1;\n    passes.set(containerId, n);\n    if (n > MAX_PASSES) continue;\n    const layout = layoutOf(containerId);\n    if (layout === null || source.get(containerId) === undefined) continue;\n    const joined = n === 1 ? arrivals.get(containerId) : undefined;\n    const left = n === 1 ? departures.get(containerId) : undefined;\n    let arranged = false;\n    if (left !== undefined && layout.depart) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const joinedSet = new Set<string>(joined ?? []);\n      const staying = at.children.filter((c) => !joinedSet.has(c.id));\n      apply(containerId, at, layout.depart(at.container, staying, new Set<string>(left)));\n      arranged = true;\n    }\n    if (joined !== undefined && layout.arrive) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      const result = layout.arrive(at.container, at.children, new Set<string>(joined));\n      if (result === null) return null;\n      apply(containerId, at, result);\n    } else if (!arranged || joined !== undefined) {\n      const at = frameOf(containerId);\n      if (at === null) continue;\n      apply(containerId, at, { poses: layout.childPoses(at.container, at.children) });\n    }\n  }\n  return out;\n}\n"],"mappings":"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"}