@weasel-js/core 1.10.0 → 1.11.0

package/dist/core/scene/poseSnapshot.js

@@ -1,54 +1,75 @@
-import { isPlainObject as e, isPlainPrototype as t } from "../isPlainObject.js";
+import { isPlainObject, isPlainPrototype } from "../isPlainObject.js";
+
 //#region src/core/scene/poseSnapshot.ts
-var n = 4;
-function r(e) {
-	return ArrayBuffer.isView(e) && !(e instanceof DataView);
+/**
+* Comparing a pose against what it was, by value.
+*
+* For readers that cannot be told when a pose moved: a pose override mutates
+* its buffer in place, so comparing references sees nothing.
+*
+* `TPose` is opaque to the kit, so both sides walk plain objects, arrays, and
+* typed arrays, and fall back to reference identity for anything else (a
+* class instance, a `Map`). A pose of that shape mutated in place still needs
+* the scene's pushed invalidation.
+*/
+/** How deep the walk goes before it stops copying and keeps the reference.
+*  A pose is a handful of numbers; nothing legitimate is nested this far. */
+var DEPTH = 4;
+function isTypedArray(v) {
+	return ArrayBuffer.isView(v) && !(v instanceof DataView);
 }
-function i(t, a = n) {
-	if (a <= 0) return t;
-	if (Array.isArray(t)) return t.map((e) => i(e, a - 1));
-	if (r(t)) return t.slice();
-	if (e(t)) {
-		let e = { ...t };
-		for (let t in e) {
-			let n = e[t];
-			typeof n == "object" && n && (e[t] = i(n, a - 1));
+/** A copy of `value` that later mutation of `value` cannot reach. */
+function snapshotPose(value, depth = DEPTH) {
+	if (depth <= 0) return value;
+	if (Array.isArray(value)) return value.map((v) => snapshotPose(v, depth - 1));
+	if (isTypedArray(value)) return value.slice();
+	if (isPlainObject(value)) {
+		const out = { ...value };
+		for (const key in out) {
+			const field = out[key];
+			if (typeof field === "object" && field !== null) out[key] = snapshotPose(field, depth - 1);
 		}
-		return e;
+		return out;
 	}
-	return t;
+	return value;
 }
-function a(e, i, o = n) {
-	if (e === i) return !0;
-	if (typeof e != "object" || !e || typeof i != "object" || !i) return Object.is(e, i);
-	if (o <= 0) return !1;
-	let s = Object.getPrototypeOf(e);
-	if (t(s)) {
-		if (!t(Object.getPrototypeOf(i))) return !1;
-		let n = e, r = i, s = 0;
-		for (let e in n) {
-			s++;
-			let t = n[e], i = r[e];
-			if (t === i) {
-				if (i === void 0 && !(e in r)) return !1;
+/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates
+*  nothing, and takes the plain-object branch first: this runs per dependency
+*  per frame, and a pose is an object of numbers nearly every time. */
+function samePoseValue(snapshot, value, depth = DEPTH) {
+	if (snapshot === value) return true;
+	if (typeof snapshot !== "object" || snapshot === null || typeof value !== "object" || value === null) return Object.is(snapshot, value);
+	if (depth <= 0) return false;
+	const proto = Object.getPrototypeOf(snapshot);
+	if (isPlainPrototype(proto)) {
+		if (!isPlainPrototype(Object.getPrototypeOf(value))) return false;
+		const a = snapshot;
+		const b = value;
+		let count = 0;
+		for (const key in a) {
+			count++;
+			const left = a[key];
+			const right = b[key];
+			if (left === right) {
+				if (right === void 0 && !(key in b)) return false;
 				continue;
 			}
-			if (!a(t, i, o - 1)) return !1;
+			if (!samePoseValue(left, right, depth - 1)) return false;
 		}
-		for (let e in r) if (--s < 0) return !1;
-		return !0;
+		for (const _key in b) if (--count < 0) return false;
+		return true;
 	}
-	if (Array.isArray(e) || r(e)) {
-		let t = e;
-		if (!(Array.isArray(i) || r(i))) return !1;
-		let n = i;
-		if (t.length !== n.length) return !1;
-		for (let e = 0; e < t.length; e++) if (!a(t[e], n[e], o - 1)) return !1;
-		return !0;
+	if (Array.isArray(snapshot) || isTypedArray(snapshot)) {
+		const a = snapshot;
+		if (!(Array.isArray(value) || isTypedArray(value))) return false;
+		const b = value;
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!samePoseValue(a[i], b[i], depth - 1)) return false;
+		return true;
 	}
-	return !1;
+	return false;
 }
-//#endregion
-export { a as samePoseValue, i as snapshotPose };
 
+//#endregion
+export { samePoseValue, snapshotPose };
 //# sourceMappingURL=poseSnapshot.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"poseSnapshot.js","names":["DEPTH","isTypedArray","v","snapshotPose","depth","value","isPlainObject","out","key","field","samePoseValue","snapshot","proto","isPlainPrototype","a","b","count","left","right","_key","i"],"sources":["../../../src/core/scene/poseSnapshot.ts"],"sourcesContent":["import { isPlainObject, isPlainPrototype } from '../isPlainObject';\n/**\n * Comparing a pose against what it was, by value.\n *\n * For readers that cannot be told when a pose moved: a pose override mutates\n * its buffer in place, so comparing references sees nothing.\n *\n * `TPose` is opaque to the kit, so both sides walk plain objects, arrays, and\n * typed arrays, and fall back to reference identity for anything else (a\n * class instance, a `Map`). A pose of that shape mutated in place still needs\n * the scene's pushed invalidation.\n */\n\n/** How deep the walk goes before it stops copying and keeps the reference.\n *  A pose is a handful of numbers; nothing legitimate is nested this far. */\nconst DEPTH = 4;\n\nfunction isTypedArray(v: unknown): v is ArrayLike<number> & { slice(): unknown } {\n  return ArrayBuffer.isView(v) && !(v instanceof DataView);\n}\n\n/** A copy of `value` that later mutation of `value` cannot reach. */\nexport function snapshotPose<T>(value: T, depth = DEPTH): T {\n  if (depth <= 0) return value;\n  if (Array.isArray(value)) {\n    return value.map((v) => snapshotPose(v, depth - 1)) as unknown as T;\n  }\n  if (isTypedArray(value)) return value.slice() as unknown as T;\n  if (isPlainObject(value)) {\n    // Spread first, then replace only the fields that need a copy of their\n    // own: a built-up object lands in a different hidden class than the pose\n    // it mirrors, which costs the per-frame compare several times over.\n    const out: Record<string, unknown> = { ...value };\n    for (const key in out) {\n      const field = out[key];\n      if (typeof field === 'object' && field !== null) out[key] = snapshotPose(field, depth - 1);\n    }\n    return out as unknown as T;\n  }\n  return value;\n}\n\n/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates\n *  nothing, and takes the plain-object branch first: this runs per dependency\n *  per frame, and a pose is an object of numbers nearly every time. */\nexport function samePoseValue(snapshot: unknown, value: unknown, depth = DEPTH): boolean {\n  if (snapshot === value) return true;\n  if (typeof snapshot !== 'object' || snapshot === null\n    || typeof value !== 'object' || value === null) return Object.is(snapshot, value);\n  if (depth <= 0) return false;\n\n  const proto = Object.getPrototypeOf(snapshot) as object | null;\n  if (isPlainPrototype(proto)) {\n    if (!isPlainPrototype(Object.getPrototypeOf(value) as object | null)) return false;\n    const a = snapshot as Record<string, unknown>;\n    const b = value as Record<string, unknown>;\n    let count = 0;\n    for (const key in a) {\n      count++;\n      const left = a[key];\n      const right = b[key];\n      if (left === right) {\n        if (right === undefined && !(key in b)) return false;\n        continue;\n      }\n      if (!samePoseValue(left, right, depth - 1)) return false;\n    }\n    // A field `value` gained is a change too, and the key counts are what say so.\n    for (const _key in b) if (--count < 0) return false;\n    return true;\n  }\n\n  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {\n    const a = snapshot as ArrayLike<unknown>;\n    if (!(Array.isArray(value) || isTypedArray(value))) return false;\n    const b = value as ArrayLike<unknown>;\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!samePoseValue(a[i], b[i], depth - 1)) return false;\n    }\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;AAeA,IAAMA,IAAQ;AAEd,SAASC,EAAa,GAA2D;CAC/E,OAAO,YAAY,OAAOC,CAAC,KAAK,EAAEA,aAAa;AACjD;AAGA,SAAgBC,EAAgB,GAAU,IAAQH,GAAU;CAC1D,IAAII,KAAS,GAAG,OAAOC;CACvB,IAAI,MAAM,QAAQA,CAAK,GACrB,OAAOA,EAAM,KAAK,MAAMF,EAAaD,GAAGE,IAAQ,CAAC,CAAC;CAEpD,IAAIH,EAAaI,CAAK,GAAG,OAAOA,EAAM,MAAM;CAC5C,IAAIC,EAAcD,CAAK,GAAG;EAIxB,IAAME,IAA+B,EAAE,GAAGF,EAAM;EAChD,KAAK,IAAMG,KAAOD,GAAK;GACrB,IAAME,IAAQF,EAAIC;GAClB,AAAI,OAAOC,KAAU,YAAYA,MAAgB,EAAID,KAAOL,EAAaM,GAAOL,IAAQ,CAAC;EAC3F;EACA,OAAOG;CACT;CACA,OAAOF;AACT;AAKA,SAAgBK,EAAc,GAAmB,GAAgB,IAAQV,GAAgB;CACvF,IAAIW,MAAaN,GAAO,OAAO;CAC/B,IAAI,OAAOM,KAAa,aAAYA,KAC/B,OAAON,KAAU,aAAYA,GAAgB,OAAO,OAAO,GAAGM,GAAUN,CAAK;CAClF,IAAID,KAAS,GAAG,OAAO;CAEvB,IAAMQ,IAAQ,OAAO,eAAeD,CAAQ;CAC5C,IAAIE,EAAiBD,CAAK,GAAG;EAC3B,IAAI,CAACC,EAAiB,OAAO,eAAeR,CAAK,CAAkB,GAAG,OAAO;EAC7E,IAAMS,IAAIH,GACJI,IAAIV,GACNW,IAAQ;EACZ,KAAK,IAAMR,KAAOM,GAAG;GACnB;GACA,IAAMG,IAAOH,EAAEN,IACTU,IAAQH,EAAEP;GAChB,IAAIS,MAASC,GAAO;IAClB,IAAIA,MAAU,KAAA,KAAa,EAAEV,KAAOO,IAAI,OAAO;IAC/C;GACF;GACA,IAAI,CAACL,EAAcO,GAAMC,GAAOd,IAAQ,CAAC,GAAG,OAAO;EACrD;EAEA,KAAK,IAAMe,KAAQJ,GAAG,IAAI,EAAEC,IAAQ,GAAG,OAAO;EAC9C,OAAO;CACT;CAEA,IAAI,MAAM,QAAQL,CAAQ,KAAKV,EAAaU,CAAQ,GAAG;EACrD,IAAMG,IAAIH;EACV,IAAI,EAAE,MAAM,QAAQN,CAAK,KAAKJ,EAAaI,CAAK,IAAI,OAAO;EAC3D,IAAMU,IAAIV;EACV,IAAIS,EAAE,WAAWC,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAIK,IAAI,GAAGA,IAAIN,EAAE,QAAQ,KAC5B,IAAI,CAACJ,EAAcI,EAAEM,IAAIL,EAAEK,IAAIhB,IAAQ,CAAC,GAAG,OAAO;EAEpD,OAAO;CACT;CACA,OAAO;AACT"}
+{"version":3,"file":"poseSnapshot.js","names":[],"sources":["../../../src/core/scene/poseSnapshot.ts"],"sourcesContent":["import { isPlainObject, isPlainPrototype } from '../isPlainObject';\n/**\n * Comparing a pose against what it was, by value.\n *\n * For readers that cannot be told when a pose moved: a pose override mutates\n * its buffer in place, so comparing references sees nothing.\n *\n * `TPose` is opaque to the kit, so both sides walk plain objects, arrays, and\n * typed arrays, and fall back to reference identity for anything else (a\n * class instance, a `Map`). A pose of that shape mutated in place still needs\n * the scene's pushed invalidation.\n */\n\n/** How deep the walk goes before it stops copying and keeps the reference.\n *  A pose is a handful of numbers; nothing legitimate is nested this far. */\nconst DEPTH = 4;\n\nfunction isTypedArray(v: unknown): v is ArrayLike<number> & { slice(): unknown } {\n  return ArrayBuffer.isView(v) && !(v instanceof DataView);\n}\n\n/** A copy of `value` that later mutation of `value` cannot reach. */\nexport function snapshotPose<T>(value: T, depth = DEPTH): T {\n  if (depth <= 0) return value;\n  if (Array.isArray(value)) {\n    return value.map((v) => snapshotPose(v, depth - 1)) as unknown as T;\n  }\n  if (isTypedArray(value)) return value.slice() as unknown as T;\n  if (isPlainObject(value)) {\n    // Spread first, then replace only the fields that need a copy of their\n    // own: a built-up object lands in a different hidden class than the pose\n    // it mirrors, which costs the per-frame compare several times over.\n    const out: Record<string, unknown> = { ...value };\n    for (const key in out) {\n      const field = out[key];\n      if (typeof field === 'object' && field !== null) out[key] = snapshotPose(field, depth - 1);\n    }\n    return out as unknown as T;\n  }\n  return value;\n}\n\n/** Whether `value` still holds what {@link snapshotPose} recorded. Allocates\n *  nothing, and takes the plain-object branch first: this runs per dependency\n *  per frame, and a pose is an object of numbers nearly every time. */\nexport function samePoseValue(snapshot: unknown, value: unknown, depth = DEPTH): boolean {\n  if (snapshot === value) return true;\n  if (typeof snapshot !== 'object' || snapshot === null\n    || typeof value !== 'object' || value === null) return Object.is(snapshot, value);\n  if (depth <= 0) return false;\n\n  const proto = Object.getPrototypeOf(snapshot) as object | null;\n  if (isPlainPrototype(proto)) {\n    if (!isPlainPrototype(Object.getPrototypeOf(value) as object | null)) return false;\n    const a = snapshot as Record<string, unknown>;\n    const b = value as Record<string, unknown>;\n    let count = 0;\n    for (const key in a) {\n      count++;\n      const left = a[key];\n      const right = b[key];\n      if (left === right) {\n        if (right === undefined && !(key in b)) return false;\n        continue;\n      }\n      if (!samePoseValue(left, right, depth - 1)) return false;\n    }\n    // A field `value` gained is a change too, and the key counts are what say so.\n    for (const _key in b) if (--count < 0) return false;\n    return true;\n  }\n\n  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {\n    const a = snapshot as ArrayLike<unknown>;\n    if (!(Array.isArray(value) || isTypedArray(value))) return false;\n    const b = value as ArrayLike<unknown>;\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!samePoseValue(a[i], b[i], depth - 1)) return false;\n    }\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,IAAM,QAAQ;AAEd,SAAS,aAAa,GAA2D;CAC/E,OAAO,YAAY,OAAO,CAAC,KAAK,EAAE,aAAa;AACjD;;AAGA,SAAgB,aAAgB,OAAU,QAAQ,OAAU;CAC1D,IAAI,SAAS,GAAG,OAAO;CACvB,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,KAAK,MAAM,aAAa,GAAG,QAAQ,CAAC,CAAC;CAEpD,IAAI,aAAa,KAAK,GAAG,OAAO,MAAM,MAAM;CAC5C,IAAI,cAAc,KAAK,GAAG;EAIxB,MAAM,MAA+B,EAAE,GAAG,MAAM;EAChD,KAAK,MAAM,OAAO,KAAK;GACrB,MAAM,QAAQ,IAAI;GAClB,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,IAAI,OAAO,aAAa,OAAO,QAAQ,CAAC;EAC3F;EACA,OAAO;CACT;CACA,OAAO;AACT;;;;AAKA,SAAgB,cAAc,UAAmB,OAAgB,QAAQ,OAAgB;CACvF,IAAI,aAAa,OAAO,OAAO;CAC/B,IAAI,OAAO,aAAa,YAAY,aAAa,QAC5C,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO,OAAO,GAAG,UAAU,KAAK;CAClF,IAAI,SAAS,GAAG,OAAO;CAEvB,MAAM,QAAQ,OAAO,eAAe,QAAQ;CAC5C,IAAI,iBAAiB,KAAK,GAAG;EAC3B,IAAI,CAAC,iBAAiB,OAAO,eAAe,KAAK,CAAkB,GAAG,OAAO;EAC7E,MAAM,IAAI;EACV,MAAM,IAAI;EACV,IAAI,QAAQ;EACZ,KAAK,MAAM,OAAO,GAAG;GACnB;GACA,MAAM,OAAO,EAAE;GACf,MAAM,QAAQ,EAAE;GAChB,IAAI,SAAS,OAAO;IAClB,IAAI,UAAU,UAAa,EAAE,OAAO,IAAI,OAAO;IAC/C;GACF;GACA,IAAI,CAAC,cAAc,MAAM,OAAO,QAAQ,CAAC,GAAG,OAAO;EACrD;EAEA,KAAK,MAAM,QAAQ,GAAG,IAAI,EAAE,QAAQ,GAAG,OAAO;EAC9C,OAAO;CACT;CAEA,IAAI,MAAM,QAAQ,QAAQ,KAAK,aAAa,QAAQ,GAAG;EACrD,MAAM,IAAI;EACV,IAAI,EAAE,MAAM,QAAQ,KAAK,KAAK,aAAa,KAAK,IAAI,OAAO;EAC3D,MAAM,IAAI;EACV,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;EAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAC5B,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,IAAI,QAAQ,CAAC,GAAG,OAAO;EAEpD,OAAO;CACT;CACA,OAAO;AACT"}

package/dist/core/scene/poseWrites.js

@@ -0,0 +1,151 @@
+import { createRemovalLog } from "./poseRemovals.js";
+import { createEmitter, deepEqual } from "@weasel-js/registry";
+
+//#region src/core/scene/poseWrites.ts
+/**
+* What a scene reports about the poses it writes: each change's net pose per
+* node, the nodes it removed as they were last shown, and where each came
+* from, handed to `onPoseWrite` once the change reaches the scene's
+* subscribers.
+*/
+function createPoseWriteLog(env) {
+	const listeners = createEmitter();
+	const pending = /* @__PURE__ */ new Map();
+	const removals = createRemovalLog(env.shown);
+	let edit = null;
+	let replays = 0;
+	let layouts = 0;
+	let quiets = 0;
+	let listening = 0;
+	const collecting = () => listening > 0 && quiets === 0;
+	function stamp(reverted) {
+		if (replays > 0) return { origin: reverted ? "undo" : "redo" };
+		if (layouts > 0) return { origin: "layout" };
+		if (env.untracked()) return { origin: "untracked" };
+		return edit ? {
+			origin: edit.via,
+			label: edit.label
+		} : { origin: "call" };
+	}
+	function noteSet(id, from, to, reverted) {
+		if (!collecting()) return;
+		const held = pending.get(id);
+		if (held) held.to = to;
+		else pending.set(id, {
+			id,
+			from,
+			to,
+			...stamp(reverted)
+		});
+	}
+	function noteAdded(nodes, reverted) {
+		if (!collecting()) return;
+		for (const n of nodes) pending.set(n.id, {
+			id: n.id,
+			from: removals.takeBack(n.id),
+			to: n.pose,
+			...stamp(reverted)
+		});
+	}
+	const seeOff = (roots, nodes, reverted) => collecting() ? removals.seeOff(roots, nodes, stamp(reverted), pending) : () => {};
+	function around(fn, enter, leave) {
+		enter();
+		try {
+			return fn();
+		} finally {
+			leave();
+		}
+	}
+	const wrap = {
+		"kit:setPose": (h) => ({
+			...h,
+			apply: (p) => {
+				h.apply(p);
+				const s = p;
+				noteSet(s.id, s.from, s.to, false);
+			},
+			revert: (p) => {
+				h.revert(p);
+				const s = p;
+				noteSet(s.id, s.to, s.from, true);
+			}
+		}),
+		"kit:add": (h) => ({
+			...h,
+			apply: (p) => {
+				h.apply(p);
+				noteAdded([p], false);
+			},
+			revert: (p) => {
+				const done = seeOff([p], [p], true);
+				h.revert(p);
+				done();
+			}
+		}),
+		"kit:remove": (h) => ({
+			...h,
+			apply: (p) => {
+				const r = p;
+				const done = seeOff(r.detached, r.nodes, false);
+				h.apply(p);
+				done();
+			},
+			revert: (p) => {
+				h.revert(p);
+				noteAdded(p.nodes, true);
+			}
+		})
+	};
+	function flush() {
+		const removed = removals.drain();
+		if (pending.size === 0 && removed.length === 0) return;
+		const writes = [...pending.values()].filter((w) => !deepEqual(w.from, w.to));
+		pending.clear();
+		if (writes.length > 0 || removed.length > 0) listeners.emit(writes, removed);
+	}
+	env.changes.subscribe(flush);
+	return {
+		subscribe(listener) {
+			const off = listeners.subscribe(listener);
+			listening++;
+			let on = true;
+			return () => {
+				if (!on) return;
+				on = false;
+				listening--;
+				off();
+			};
+		},
+		labeled(label, via, fn) {
+			if (edit) return fn();
+			return around(fn, () => {
+				edit = {
+					label,
+					via
+				};
+			}, () => {
+				edit = null;
+			});
+		},
+		replaying: (fn) => around(fn, () => {
+			replays++;
+		}, () => {
+			replays--;
+		}),
+		layout: (fn) => around(fn, () => {
+			layouts++;
+		}, () => {
+			layouts--;
+		}),
+		quiet: (fn) => around(fn, () => {
+			quiets++;
+		}, () => {
+			quiets--;
+		}),
+		reporting: (register) => (kind, handler) => register(kind, wrap[kind]?.(handler) ?? handler)
+	};
+}
+
+//#endregion
+export { createPoseWriteLog };
+//# sourceMappingURL=poseWrites.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poseWrites.js","names":[],"sources":["../../../src/core/scene/poseWrites.ts"],"sourcesContent":["/**\n * What a scene reports about the poses it writes: each change's net pose per\n * node, the nodes it removed as they were last shown, and where each came\n * from, handed to `onPoseWrite` once the change reaches the scene's\n * subscribers.\n */\nimport { createEmitter, deepEqual } from '@weasel-js/registry';\nimport { createRemovalLog } from './poseRemovals';\nimport type { RegisteredOp } from './types';\nimport type { LayoutMove } from './layoutTypes';\nimport type { NodeId } from '@weasel-js/routing';\n\n/**\n * Where a reported pose write came from.\n *\n * - `'call'` — a scene method called directly, alone or inside `scene.batch`:\n *   a button's `scene.setPose`, a `scene.add`.\n * - `'ops'` — ops applied as one edit through `applyBatch` or `history.apply`,\n *   which is how actions commit: a drag's release, a resize, a nudge, an align.\n * - `'undo'` / `'redo'` — a history step, a jump through the history included.\n * - `'layout'` — a container's layout arranging what a live edit changed; also\n *   reported to `onReflow`.\n * - `'untracked'` — a write inside `scene.untracked`, such as a pose target\n *   committing an animation's destination.\n */\nexport type PoseWriteOrigin = 'call' | 'ops' | 'undo' | 'redo' | 'layout' | 'untracked';\n\n/** One node's pose as a scene change left it, in the node's stored frame. */\nexport interface PoseWrite<TPose> {\n  id: NodeId;\n  /** The pose before the change; `undefined` for a node the change added. */\n  from: TPose | undefined;\n  to: TPose;\n  origin: PoseWriteOrigin;\n  /** The edit's label (`'setPose'`, a batch's, an action's `'Move'`) for\n   *  `'call'` and `'ops'`; `undefined` otherwise. */\n  label?: string;\n}\n\n/** A removed node as it was last shown, with the descendants it took along. */\nexport interface RemovedNode<TPose, TNode = unknown> {\n  /** The node as it stood before the change removed it. */\n  node: TNode;\n  /** Where it was shown, override included, in its stored frame. */\n  pose: TPose;\n  children: readonly RemovedNode<TPose, TNode>[];\n}\n\n/** One node a scene change removed, a removal's root: its descendants ride\n *  beneath it rather than being reported apart. */\nexport interface PoseRemoval<TPose, TNode = unknown> extends RemovedNode<TPose, TNode> {\n  id: NodeId;\n  /** The parent it was removed from, which may still be in the scene. */\n  parent: NodeId | null;\n  origin: PoseWriteOrigin;\n  label?: string;\n}\n\n/** What a scene reports about the poses its edits write. */\nexport interface ScenePoseReports<TPose, TNode = unknown> {\n  /** Called with the poses each live edit's layout pass wrote, after the\n   *  edit lands — never for an undo or redo, which restore poses rather than\n   *  arrange them. What a reflow animation glides from. */\n  onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;\n  /** Called once per change, before the scene's subscribers hear of it, with\n   *  every node whose pose the change wrote or that it added, and every node\n   *  it removed — an undone add among them. A node written back to the pose\n   *  it had, or both added and removed by the change, is left out of both.\n   *  Not called for `loadState` or the scene's initial nodes. */\n  onPoseWrite(\n    listener: (writes: readonly PoseWrite<TPose>[], removed: readonly PoseRemoval<TPose, TNode>[]) => void,\n  ): () => void;\n}\n\n/** What the log reads of the scene it reports for. */\nexport interface PoseWriteEnv<TPose, TNode> {\n  /** A node still in the scene, with the pose it is shown at. */\n  shown(id: NodeId): { node: TNode; pose: TPose } | undefined;\n  /** Whether the edit running now is inside `scene.untracked`. */\n  untracked(): boolean;\n  /** The scene's change notice. The log reports on it, subscribed before\n   *  anyone else so a change's writes arrive ahead of its re-reads. */\n  changes: { subscribe(listener: () => void): () => void };\n}\n\nexport interface PoseWriteLog<TPose, TNode = unknown> {\n  subscribe: ScenePoseReports<TPose, TNode>['onPoseWrite'];\n  /** Run `fn` as an edit labeled `label`; an enclosing edit's label stands. */\n  labeled<T>(label: string, via: 'call' | 'ops', fn: () => T): T;\n  /** Run `fn` as a history step replaying recorded ops. */\n  replaying<T>(fn: () => T): T;\n  /** Run `fn` as a layout pass writing arranged poses. */\n  layout<T>(fn: () => T): T;\n  /** Run `fn` with nothing it writes reported. */\n  quiet<T>(fn: () => T): T;\n  /** `register` with the kit's pose-bearing ops reporting what they write. */\n  reporting(register: (kind: string, handler: RegisteredOp<unknown>) => void):\n    (kind: string, handler: RegisteredOp<unknown>) => void;\n}\n\ninterface Posed<TPose> { id: NodeId; pose: TPose }\ninterface Parented { id: NodeId; parent: NodeId | null }\n\nexport function createPoseWriteLog<TPose, TNode = unknown>(env: PoseWriteEnv<TPose, TNode>): PoseWriteLog<TPose, TNode> {\n  const listeners = createEmitter<[writes: readonly PoseWrite<TPose>[], removed: readonly PoseRemoval<TPose, TNode>[]]>();\n  const pending = new Map<NodeId, PoseWrite<TPose>>();\n  const removals = createRemovalLog<TPose, TNode>(env.shown);\n  let edit: { label: string; via: 'call' | 'ops' } | null = null;\n  let replays = 0;\n  let layouts = 0;\n  let quiets = 0;\n  let listening = 0;\n\n  const collecting = (): boolean => listening > 0 && quiets === 0;\n\n  function stamp(reverted: boolean): Pick<PoseWrite<TPose>, 'origin' | 'label'> {\n    if (replays > 0) return { origin: reverted ? 'undo' : 'redo' };\n    if (layouts > 0) return { origin: 'layout' };\n    if (env.untracked()) return { origin: 'untracked' };\n    return edit ? { origin: edit.via, label: edit.label } : { origin: 'call' };\n  }\n\n  function noteSet(id: NodeId, from: TPose, to: TPose, reverted: boolean): void {\n    if (!collecting()) return;\n    const held = pending.get(id);\n    if (held) held.to = to;\n    else pending.set(id, { id, from, to, ...stamp(reverted) });\n  }\n\n  function noteAdded(nodes: readonly Posed<TPose>[], reverted: boolean): void {\n    if (!collecting()) return;\n    for (const n of nodes) {\n      // Removed and back within one change: it moved, if anything.\n      pending.set(n.id, { id: n.id, from: removals.takeBack(n.id), to: n.pose, ...stamp(reverted) });\n    }\n  }\n\n  const seeOff = (roots: readonly Parented[], nodes: readonly Parented[], reverted: boolean): () => void =>\n    collecting() ? removals.seeOff(roots, nodes, stamp(reverted), pending) : () => {};\n\n  function around<T>(fn: () => T, enter: () => void, leave: () => void): T {\n    enter();\n    try {\n      return fn();\n    } finally {\n      leave();\n    }\n  }\n\n  type SetPayload = { id: NodeId; from: TPose; to: TPose };\n  type AddPayload = Posed<TPose> & Parented;\n  type RemovePayload = { nodes: readonly (Posed<TPose> & Parented)[]; detached: readonly Parented[] };\n  const wrap: Record<string, (h: RegisteredOp<unknown>) => RegisteredOp<unknown>> = {\n    'kit:setPose': (h) => ({\n      ...h,\n      apply: (p) => { h.apply(p); const s = p as SetPayload; noteSet(s.id, s.from, s.to, false); },\n      revert: (p) => { h.revert(p); const s = p as SetPayload; noteSet(s.id, s.to, s.from, true); },\n    }),\n    'kit:add': (h) => ({\n      ...h,\n      apply: (p) => { h.apply(p); noteAdded([p as AddPayload], false); },\n      revert: (p) => { const done = seeOff([p as AddPayload], [p as AddPayload], true); h.revert(p); done(); },\n    }),\n    'kit:remove': (h) => ({\n      ...h,\n      apply: (p) => {\n        const r = p as RemovePayload;\n        const done = seeOff(r.detached, r.nodes, false);\n        h.apply(p);\n        done();\n      },\n      revert: (p) => { h.revert(p); noteAdded((p as RemovePayload).nodes, true); },\n    }),\n  };\n\n  function flush(): void {\n    const removed = removals.drain();\n    if (pending.size === 0 && removed.length === 0) return;\n    const writes = [...pending.values()].filter((w) => !deepEqual(w.from, w.to));\n    pending.clear();\n    if (writes.length > 0 || removed.length > 0) listeners.emit(writes, removed);\n  }\n  env.changes.subscribe(flush);\n\n  return {\n    subscribe(listener) {\n      const off = listeners.subscribe(listener);\n      listening++;\n      let on = true;\n      return () => {\n        if (!on) return;\n        on = false;\n        listening--;\n        off();\n      };\n    },\n    labeled(label, via, fn) {\n      if (edit) return fn();\n      return around(fn, () => { edit = { label, via }; }, () => { edit = null; });\n    },\n    replaying: (fn) => around(fn, () => { replays++; }, () => { replays--; }),\n    layout: (fn) => around(fn, () => { layouts++; }, () => { layouts--; }),\n    quiet: (fn) => around(fn, () => { quiets++; }, () => { quiets--; }),\n    reporting: (register) => (kind, handler) => register(kind, wrap[kind]?.(handler) ?? handler),\n  };\n}\n"],"mappings":"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"}

package/dist/core/scene/reconcileSpecs.js

@@ -1,48 +1,77 @@
-import { isPlainObject as e } from "../isPlainObject.js";
+import { isPlainObject } from "../isPlainObject.js";
+
 //#region src/core/scene/reconcileSpecs.ts
-function t(e, t, a) {
-	let o = n(t), s = n(a), c = [];
-	for (let [e, t] of o) {
-		let n = s.get(e);
-		(n === void 0 || r(t, n)) && c.push(e);
+/**
+* Bring `scene` from `prev` to `next`: add what `next` gained, remove what it
+* lost, and write only the fields that changed between the two.
+*
+* The diff is spec against spec, not spec against scene, so whatever the scene
+* did since `prev` — a node dragged, an edge authored by a gesture — survives
+* unless `next` changes that same field. The writes are untracked: syncing to
+* outside data is not an undo step.
+*
+* Every spec needs an `id`, and `next` must be in an order `createScene` would
+* accept — parents and dependencies before what names them. A node whose
+* `kind` or derive functions change is removed and added again, along with
+* everything its removal takes with it, and stays selected if it was.
+*/
+function reconcileSpecs(scene, prev, next) {
+	const prevById = byId(prev);
+	const nextById = byId(next);
+	const gone = [];
+	for (const [id, before] of prevById) {
+		const after = nextById.get(id);
+		if (after === void 0 || needsReplace(before, after)) gone.push(id);
 	}
-	let l = e.removalClosure(c.filter((t) => e.get(t) !== void 0)), u = new Set(l), d = e.getSelection();
-	e.untracked(() => {
-		e.removeMany(l);
-		for (let t of a) {
-			let n = t.id, r = o.get(n);
-			if (e.get(n) === void 0 || r === void 0 || u.has(n)) {
-				e.add(t);
+	const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== void 0));
+	const removed = new Set(removing);
+	const selected = scene.getSelection();
+	scene.untracked(() => {
+		scene.removeMany(removing);
+		for (const spec of next) {
+			const id = spec.id;
+			const before = prevById.get(id);
+			if (scene.get(id) === void 0 || before === void 0 || removed.has(id)) {
+				scene.add(spec);
 				continue;
 			}
-			let a = t.parent ?? null;
-			a !== (r.parent ?? null) && e.move(n, a), t.layer !== r.layer && e.setLayer(n, t.layer), i(t.data, r.data) || e.update(n, { data: t.data }), i(t.dependsOn, r.dependsOn) || e.setDependsOn(n, t.dependsOn), t.kind === "container" && !i(t.units, r.units) && e.setUnits(n, t.units ?? null), i(t.pose, r.pose) || e.setPose(n, t.pose);
+			if (before.locked === true && spec.locked !== true) scene.setLocked(id, false);
+			const parent = spec.parent ?? null;
+			if (parent !== (before.parent ?? null)) scene.move(id, parent);
+			if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);
+			if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });
+			if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);
+			if (spec.kind === "container" && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);
+			if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);
+			if (spec.hidden === true !== (before.hidden === true)) scene.setHidden(id, spec.hidden === true);
+			if (spec.locked === true && before.locked !== true) scene.setLocked(id, true);
 		}
-		d.some((e) => u.has(e)) && e.setSelection(d.filter((t) => e.get(t) !== void 0));
+		if (selected.some((id) => removed.has(id))) scene.setSelection(selected.filter((id) => scene.get(id) !== void 0));
 	});
 }
-function n(e) {
-	let t = /* @__PURE__ */ new Map();
-	for (let n of e) {
-		if (n.id === void 0) throw Error("reconcileSpecs: every spec needs an id");
-		if (t.has(n.id)) throw Error(`reconcileSpecs: id "${n.id}" appears more than once`);
-		t.set(n.id, n);
+function byId(specs) {
+	const out = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		if (spec.id === void 0) throw new Error("reconcileSpecs: every spec needs an id");
+		if (out.has(spec.id)) throw new Error(`reconcileSpecs: id "${spec.id}" appears more than once`);
+		out.set(spec.id, spec);
 	}
-	return t;
+	return out;
 }
-function r(e, t) {
-	return e.kind !== t.kind || e.pickable !== t.pickable || e.derivePath !== t.derivePath || e.derivePose !== t.derivePose || e.clipFromPose !== t.clipFromPose || e.layout !== t.layout;
+function needsReplace(a, b) {
+	return a.kind !== b.kind || a.pickable !== b.pickable || a.derivePath !== b.derivePath || a.derivePose !== b.derivePose || a.clipFromPose !== b.clipFromPose || a.copiesFromPose !== b.copiesFromPose || a.layout !== b.layout;
 }
-function i(t, n) {
-	if (Object.is(t, n)) return !0;
-	if (Array.isArray(t) && Array.isArray(n)) return t.length === n.length && t.every((e, t) => i(e, n[t]));
-	if (e(t) && e(n)) {
-		let e = Object.keys(t);
-		return e.length === Object.keys(n).length && e.every((e) => e in n && i(t[e], n[e]));
+/** Structural equality over plain objects and arrays; anything else by identity. */
+function same(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => same(v, b[i]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ka = Object.keys(a);
+		return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));
 	}
-	return !1;
+	return false;
 }
-//#endregion
-export { t as reconcileSpecs };
 
+//#endregion
+export { reconcileSpecs };
 //# sourceMappingURL=reconcileSpecs.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"reconcileSpecs.js","names":["reconcileSpecs","prevById","byId","prev","nextById","next","gone","id","before","after","needsReplace","removing","scene","removed","selected","spec","parent","same","out","specs","a","b","v","i","isPlainObject","ka","k"],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\nimport type { AddNodeSpec, NodeId, Scene } from './types';\n\n/**\n * Bring `scene` from `prev` to `next`: add what `next` gained, remove what it\n * lost, and write only the fields that changed between the two.\n *\n * The diff is spec against spec, not spec against scene, so whatever the scene\n * did since `prev` — a node dragged, an edge authored by a gesture — survives\n * unless `next` changes that same field. The writes are untracked: syncing to\n * outside data is not an undo step.\n *\n * Every spec needs an `id`, and `next` must be in an order `createScene` would\n * accept — parents and dependencies before what names them. A node whose\n * `kind` or derive functions change is removed and added again, along with\n * everything its removal takes with it, and stays selected if it was.\n */\nexport function reconcileSpecs<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  prev: readonly AddNodeSpec<TData, TLayer, TPose>[],\n  next: readonly AddNodeSpec<TData, TLayer, TPose>[],\n): void {\n  const prevById = byId(prev);\n  const nextById = byId(next);\n  const gone: NodeId[] = [];\n  for (const [id, before] of prevById) {\n    const after = nextById.get(id);\n    if (after === undefined || needsReplace(before, after)) gone.push(id);\n  }\n  const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== undefined));\n  const removed = new Set(removing);\n\n  // A replaced node is the same node to whoever selected it.\n  const selected = scene.getSelection();\n\n  scene.untracked(() => {\n    scene.removeMany(removing);\n    for (const spec of next) {\n      const id = spec.id!;\n      const before = prevById.get(id);\n      if (scene.get(id) === undefined || before === undefined || removed.has(id)) {\n        scene.add(spec);\n        continue;\n      }\n      const parent = spec.parent ?? null;\n      if (parent !== (before.parent ?? null)) scene.move(id, parent);\n      if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);\n      if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });\n      if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);\n      if (spec.kind === 'container' && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n    }\n    if (selected.some((id) => removed.has(id))) {\n      scene.setSelection(selected.filter((id) => scene.get(id) !== undefined));\n    }\n  });\n}\n\nfunction byId<T extends { id?: NodeId }>(specs: readonly T[]): Map<NodeId, T> {\n  const out = new Map<NodeId, T>();\n  for (const spec of specs) {\n    if (spec.id === undefined) throw new Error('reconcileSpecs: every spec needs an id');\n    if (out.has(spec.id)) throw new Error(`reconcileSpecs: id \"${spec.id}\" appears more than once`);\n    out.set(spec.id, spec);\n  }\n  return out;\n}\n\nfunction needsReplace<TData, TLayer extends string, TPose>(\n  a: AddNodeSpec<TData, TLayer, TPose>,\n  b: AddNodeSpec<TData, TLayer, TPose>,\n): boolean {\n  return a.kind !== b.kind\n    || a.pickable !== b.pickable\n    || a.derivePath !== b.derivePath\n    || a.derivePose !== b.derivePose\n    || a.clipFromPose !== b.clipFromPose\n    || a.layout !== b.layout;\n}\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nfunction same(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((v, i) => same(v, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const ka = Object.keys(a);\n    return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":"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"}
+{"version":3,"file":"reconcileSpecs.js","names":[],"sources":["../../../src/core/scene/reconcileSpecs.ts"],"sourcesContent":["import { isPlainObject } from '../isPlainObject';\nimport type { AddNodeSpec, NodeId, Scene } from './types';\n\n/**\n * Bring `scene` from `prev` to `next`: add what `next` gained, remove what it\n * lost, and write only the fields that changed between the two.\n *\n * The diff is spec against spec, not spec against scene, so whatever the scene\n * did since `prev` — a node dragged, an edge authored by a gesture — survives\n * unless `next` changes that same field. The writes are untracked: syncing to\n * outside data is not an undo step.\n *\n * Every spec needs an `id`, and `next` must be in an order `createScene` would\n * accept — parents and dependencies before what names them. A node whose\n * `kind` or derive functions change is removed and added again, along with\n * everything its removal takes with it, and stays selected if it was.\n */\nexport function reconcileSpecs<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  prev: readonly AddNodeSpec<TData, TLayer, TPose>[],\n  next: readonly AddNodeSpec<TData, TLayer, TPose>[],\n): void {\n  const prevById = byId(prev);\n  const nextById = byId(next);\n  const gone: NodeId[] = [];\n  for (const [id, before] of prevById) {\n    const after = nextById.get(id);\n    if (after === undefined || needsReplace(before, after)) gone.push(id);\n  }\n  const removing = scene.removalClosure(gone.filter((id) => scene.get(id) !== undefined));\n  const removed = new Set(removing);\n\n  // A replaced node is the same node to whoever selected it.\n  const selected = scene.getSelection();\n\n  scene.untracked(() => {\n    scene.removeMany(removing);\n    for (const spec of next) {\n      const id = spec.id!;\n      const before = prevById.get(id);\n      if (scene.get(id) === undefined || before === undefined || removed.has(id)) {\n        scene.add(spec);\n        continue;\n      }\n      // An unlock goes first and a lock last, so the writes between can land.\n      if (before.locked === true && spec.locked !== true) scene.setLocked(id, false);\n      const parent = spec.parent ?? null;\n      if (parent !== (before.parent ?? null)) scene.move(id, parent);\n      if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);\n      if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });\n      if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);\n      if (spec.kind === 'container' && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);\n      if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);\n      if ((spec.hidden === true) !== (before.hidden === true)) scene.setHidden(id, spec.hidden === true);\n      if (spec.locked === true && before.locked !== true) scene.setLocked(id, true);\n    }\n    if (selected.some((id) => removed.has(id))) {\n      scene.setSelection(selected.filter((id) => scene.get(id) !== undefined));\n    }\n  });\n}\n\nfunction byId<T extends { id?: NodeId }>(specs: readonly T[]): Map<NodeId, T> {\n  const out = new Map<NodeId, T>();\n  for (const spec of specs) {\n    if (spec.id === undefined) throw new Error('reconcileSpecs: every spec needs an id');\n    if (out.has(spec.id)) throw new Error(`reconcileSpecs: id \"${spec.id}\" appears more than once`);\n    out.set(spec.id, spec);\n  }\n  return out;\n}\n\nfunction needsReplace<TData, TLayer extends string, TPose>(\n  a: AddNodeSpec<TData, TLayer, TPose>,\n  b: AddNodeSpec<TData, TLayer, TPose>,\n): boolean {\n  return a.kind !== b.kind\n    || a.pickable !== b.pickable\n    || a.derivePath !== b.derivePath\n    || a.derivePose !== b.derivePose\n    || a.clipFromPose !== b.clipFromPose\n    || a.copiesFromPose !== b.copiesFromPose\n    || a.layout !== b.layout;\n}\n\n/** Structural equality over plain objects and arrays; anything else by identity. */\nfunction same(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((v, i) => same(v, b[i]));\n  }\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const ka = Object.keys(a);\n    return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));\n  }\n  return false;\n}\n"],"mappings":"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"}