@weasel-js/core 1.10.1 → 1.11.1

package/dist/core/ops/reorder/index.js

@@ -1,139 +1,179 @@
-import { registerOpFactory as e } from "../registry.js";
-import { bringForward as t, bringToFront as n, canBringForward as r, canSendBackward as i, moveToIndex as a, sendBackward as o, sendToBack as s } from "./algorithms.js";
-import { createSetChildOrderOp as c } from "./setChildOrder.js";
+import { registerOpFactory } from "../registry.js";
+import { bringForward, bringToFront, canBringForward, canSendBackward, moveToIndex, sendBackward, sendToBack } from "./algorithms.js";
+import { createSetChildOrderOp } from "./setChildOrder.js";
+
 //#region src/core/ops/reorder/index.ts
-function l(e, t) {
-	if (e.length !== t.length) return !1;
-	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
-	return !0;
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
 }
-function u(e) {
-	let { ids: t, direction: n, fn: r, label: i, prevOrders: a } = e, o = {
-		ids: t,
-		direction: n,
-		label: i,
-		prevOrders: a ? a.map((e) => ({
+/**
+* Build an op that, on apply, partitions `ids` by their current parent,
+* runs `fn(currentChildren, idsForParent)` per parent, and writes the
+* result back via setChildOrder. Records before-state per parent so invert
+* is exact.
+*
+* `prevOrders` is that before-state, mirrored into the op's serialized args
+* on first apply. A deserialized op has never run its own `apply`, so its
+* invert has nothing to capture — reading it back from the args is what lets
+* a reorder survive a reload, the same trick `createMoveToIndexOp` uses.
+*/
+function createPartitionedReorderOp(args) {
+	const { ids, direction, fn, label, prevOrders } = args;
+	const argsForSerial = {
+		ids,
+		direction,
+		label,
+		prevOrders: prevOrders ? prevOrders.map((e) => ({
 			...e,
 			before: e.before.slice()
 		})) : void 0
-	}, s = a ? a.map((e) => ({
+	};
+	let restore = prevOrders ? prevOrders.map((e) => ({
 		...e,
 		before: e.before.slice()
 	})) : null;
 	return {
 		name: "reorder",
-		args: o,
-		label: i,
-		apply(e) {
-			let n = e, i = /* @__PURE__ */ new Map();
-			for (let e of t) {
-				let t = n.getParent(e), r = i.get(t) ?? [];
-				r.push(e), i.set(t, r);
+		args: argsForSerial,
+		label,
+		apply(adapter) {
+			const a = adapter;
+			const byParent = /* @__PURE__ */ new Map();
+			for (const id of ids) {
+				const parent = a.getParent(id);
+				const list = byParent.get(parent) ?? [];
+				list.push(id);
+				byParent.set(parent, list);
 			}
-			let a = [], c = !1;
-			for (let [e, t] of i) {
-				let i = n.getChildren(e), o = r(i, t);
-				l(i, o) || (a.push({
-					parentId: e,
-					before: i.slice()
-				}), n.setChildOrder(e, o), c = !0);
+			const snapshots = [];
+			let mutated = false;
+			for (const [parentId, parentIds] of byParent) {
+				const before = a.getChildren(parentId);
+				const after = fn(before, parentIds);
+				if (arraysEqual(before, after)) continue;
+				snapshots.push({
+					parentId,
+					before: before.slice()
+				});
+				a.setChildOrder(parentId, after);
+				mutated = true;
 			}
-			return s = a, o.prevOrders = a.map((e) => ({
+			restore = snapshots;
+			argsForSerial.prevOrders = snapshots.map((e) => ({
 				...e,
 				before: e.before.slice()
-			})), c;
+			}));
+			return mutated;
 		},
 		invert() {
-			let e = s;
+			const captured = restore;
 			return {
-				...c({
-					orders: (e ?? []).map((e) => ({
+				...createSetChildOrderOp({
+					orders: (captured ?? []).map((e) => ({
 						parentId: e.parentId,
 						ids: e.before
 					})),
-					label: i
+					label
 				}),
-				invert: () => u({
-					ids: t,
-					direction: n,
-					fn: r,
-					label: i,
-					prevOrders: e ?? void 0
+				invert: () => createPartitionedReorderOp({
+					ids,
+					direction,
+					fn,
+					label,
+					prevOrders: captured ?? void 0
 				})
 			};
 		}
 	};
 }
-var d = {
+var REORDER_DIRECTIONS = {
 	forward: {
-		fn: t,
+		fn: bringForward,
 		defaultLabel: "Bring forward"
 	},
 	backward: {
-		fn: o,
+		fn: sendBackward,
 		defaultLabel: "Send backward"
 	},
 	front: {
-		fn: n,
+		fn: bringToFront,
 		defaultLabel: "Bring to front"
 	},
 	back: {
-		fn: s,
+		fn: sendToBack,
 		defaultLabel: "Send to back"
 	}
 };
-function f(e) {
-	let { ids: t, direction: n, label: r, prevOrders: i } = e, { fn: a, defaultLabel: o } = d[n];
-	return u({
-		ids: t,
-		direction: n,
-		fn: a,
-		label: r ?? o,
-		prevOrders: i
+/**
+* Op: shift each id within its parent's child order per `direction`:
+*   - `'forward'`  — bump one step toward the top
+*   - `'backward'` — bump one step toward the bottom
+*   - `'front'`    — move to the top, preserving relative order
+*   - `'back'`     — move to the bottom, preserving relative order
+*/
+function createReorderOp(args) {
+	const { ids, direction, label, prevOrders } = args;
+	const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];
+	return createPartitionedReorderOp({
+		ids,
+		direction,
+		fn,
+		label: label ?? defaultLabel,
+		prevOrders
 	});
 }
-e("reorder", (e) => f(e));
-function p(e) {
-	let { ids: t, parentId: n, index: r, label: i } = e, o = {
-		ids: t,
-		parentId: n,
-		index: r,
-		label: i,
-		prevPositions: e.prevPositions ? e.prevPositions.slice() : void 0
-	}, s = e.prevPositions ? e.prevPositions.slice() : null;
+registerOpFactory("reorder", (args) => createReorderOp(args));
+/** Op: move all `ids` to a contiguous block starting at `index` within `parentId`'s child order. */
+function createMoveToIndexOp(args) {
+	const { ids, parentId, index, label } = args;
+	const argsForSerial = {
+		ids,
+		parentId,
+		index,
+		label,
+		prevPositions: args.prevPositions ? args.prevPositions.slice() : void 0
+	};
+	let before = args.prevPositions ? args.prevPositions.slice() : null;
 	return {
 		name: "moveToIndex",
-		args: o,
-		label: i ?? "Move to index",
-		apply(e) {
-			let i = e, c = t.filter((e) => i.getParent(e) === n), l = i.getChildren(n);
-			s === null && (s = l.slice(), o.prevPositions = s.slice());
-			let u = a(l, c, r);
-			i.setChildOrder(n, u);
+		args: argsForSerial,
+		label: label ?? "Move to index",
+		apply(adapter) {
+			const a = adapter;
+			const eligible = ids.filter((id) => a.getParent(id) === parentId);
+			const current = a.getChildren(parentId);
+			if (before === null) {
+				before = current.slice();
+				argsForSerial.prevPositions = before.slice();
+			}
+			const after = moveToIndex(current, eligible, index);
+			a.setChildOrder(parentId, after);
 		},
 		invert() {
-			let e = s;
+			const captured = before;
 			return {
-				...c({
-					orders: e ? [{
-						parentId: n,
-						ids: e
+				...createSetChildOrderOp({
+					orders: captured ? [{
+						parentId,
+						ids: captured
 					}] : [],
-					label: i
+					label
 				}),
-				invert: () => p({
-					ids: t,
-					parentId: n,
-					index: r,
-					label: i,
-					prevPositions: e ?? void 0
+				invert: () => createMoveToIndexOp({
+					ids,
+					parentId,
+					index,
+					label,
+					prevPositions: captured ?? void 0
 				})
 			};
 		}
 	};
 }
-e("moveToIndex", (e) => p(e));
-//#endregion
-export { r as canBringForward, i as canSendBackward, p as createMoveToIndexOp, f as createReorderOp, c as createSetChildOrderOp };
+registerOpFactory("moveToIndex", (args) => createMoveToIndexOp(args));
 
+//#endregion
+export { canBringForward, canSendBackward, createMoveToIndexOp, createReorderOp, createSetChildOrderOp };
 //# sourceMappingURL=index.js.map

package/dist/core/ops/reorder/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["arraysEqual","a","b","i","createPartitionedReorderOp","args","argsForSerial","prevOrders","restore","adapter","byParent","id","ids","parent","list","snapshots","mutated","parentId","parentIds","before","after","fn","captured","createSetChildOrderOp","REORDER_DIRECTIONS","bringForward","sendBackward","bringToFront","sendToBack","createReorderOp","direction","label","defaultLabel","registerOpFactory","createMoveToIndexOp","eligible","current","moveToIndex","index","canBringForward","canSendBackward"],"sources":["../../../../src/core/ops/reorder/index.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\nimport {\n  bringForward,\n  sendBackward,\n  bringToFront,\n  sendToBack,\n  moveToIndex,\n} from './algorithms';\n\nimport { createSetChildOrderOp } from './setChildOrder';\n\nexport { canBringForward, canSendBackward } from './algorithms';\nexport { createSetChildOrderOp, type ChildOrder, type SetChildOrderArgs } from './setChildOrder';\n\ninterface ReorderAdapter {\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\ntype ReorderFn = (list: string[], ids: string[]) => string[];\n\nfunction arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n\n/** One parent's child order before a reorder, kept so undo can restore it. */\nexport interface ReorderRestoreEntry {\n  parentId: string | null;\n  before: string[];\n}\n\n/** Arguments to {@link createReorderOp}: move `ids` in paint order, one step or to the front/back. */\nexport interface ReorderArgs {\n  ids: string[];\n  direction: ReorderDirection;\n  label?: string;\n  /** Pre-mutation child order per touched parent. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ReorderRestoreEntry[];\n}\n\n/**\n * Build an op that, on apply, partitions `ids` by their current parent,\n * runs `fn(currentChildren, idsForParent)` per parent, and writes the\n * result back via setChildOrder. Records before-state per parent so invert\n * is exact.\n *\n * `prevOrders` is that before-state, mirrored into the op's serialized args\n * on first apply. A deserialized op has never run its own `apply`, so its\n * invert has nothing to capture — reading it back from the args is what lets\n * a reorder survive a reload, the same trick `createMoveToIndexOp` uses.\n */\nfunction createPartitionedReorderOp(args: {\n  ids: string[];\n  direction: ReorderDirection;\n  fn: ReorderFn;\n  label?: string;\n  prevOrders?: ReorderRestoreEntry[];\n}): Op {\n  const { ids, direction, fn, label, prevOrders } = args;\n  const argsForSerial: ReorderArgs = {\n    ids,\n    direction,\n    label,\n    prevOrders: prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : undefined,\n  };\n  let restore: ReorderRestoreEntry[] | null =\n    prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : null;\n\n  return {\n    name: 'reorder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Partition ids by current parent.\n      const byParent = new Map<string | null, string[]>();\n      for (const id of ids) {\n        const parent = a.getParent(id);\n        const list = byParent.get(parent) ?? [];\n        list.push(id);\n        byParent.set(parent, list);\n      }\n      const snapshots: ReorderRestoreEntry[] = [];\n      let mutated = false;\n      for (const [parentId, parentIds] of byParent) {\n        const before = a.getChildren(parentId);\n        const after = fn(before, parentIds);\n        if (arraysEqual(before, after)) continue; // already at the desired order\n        snapshots.push({ parentId, before: before.slice() });\n        a.setChildOrder(parentId, after);\n        mutated = true;\n      }\n      restore = snapshots;\n      argsForSerial.prevOrders = snapshots.map((e) => ({ ...e, before: e.before.slice() }));\n      return mutated;\n    },\n    invert() {\n      const captured = restore;\n      return {\n        ...createSetChildOrderOp({\n          orders: (captured ?? []).map((e) => ({ parentId: e.parentId, ids: e.before })),\n          label,\n        }),\n        invert: () =>\n          createPartitionedReorderOp({\n            ids, direction, fn, label, prevOrders: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\n/** Direction of a sibling z-order reorder. */\nexport type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';\n\nconst REORDER_DIRECTIONS: Record<ReorderDirection, { fn: ReorderFn; defaultLabel: string }> = {\n  forward:  { fn: bringForward,  defaultLabel: 'Bring forward' },\n  backward: { fn: sendBackward,  defaultLabel: 'Send backward' },\n  front:    { fn: bringToFront,  defaultLabel: 'Bring to front' },\n  back:     { fn: sendToBack,    defaultLabel: 'Send to back' },\n};\n\n/**\n * Op: shift each id within its parent's child order per `direction`:\n *   - `'forward'`  — bump one step toward the top\n *   - `'backward'` — bump one step toward the bottom\n *   - `'front'`    — move to the top, preserving relative order\n *   - `'back'`     — move to the bottom, preserving relative order\n */\nexport function createReorderOp(args: ReorderArgs): Op {\n  const { ids, direction, label, prevOrders } = args;\n  const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];\n  return createPartitionedReorderOp({\n    ids, direction, fn, label: label ?? defaultLabel, prevOrders,\n  });\n}\n\nregisterOpFactory<ReorderArgs>('reorder', (args) => createReorderOp(args));\n\n/** Arguments to {@link createMoveToIndexOp}: move `ids` to `index` under `parentId`. */\nexport interface MoveToIndexArgs {\n  ids: string[];\n  parentId: string | null;\n  index: number;\n  label?: string;\n  /** Optional pre-mutation child order for the parent. When present, the op\n   *  uses it as the invert target instead of capturing at apply time — this\n   *  is how a deserialized op (whose original `apply` already ran in a prior\n   *  session) restores its invert behavior across an IDB round-trip. */\n  prevPositions?: string[];\n}\n\n/** Op: move all `ids` to a contiguous block starting at `index` within `parentId`'s child order. */\nexport function createMoveToIndexOp(args: MoveToIndexArgs): Op {\n  const { ids, parentId, index, label } = args;\n  // Outer args record we'll mutate so the captured `before` lands in the\n  // serialized form. `prevPositions` arrives populated when reconstructed\n  // from a snapshot; otherwise it's filled in on first apply.\n  const argsForSerial: MoveToIndexArgs = {\n    ids,\n    parentId,\n    index,\n    label,\n    prevPositions: args.prevPositions ? args.prevPositions.slice() : undefined,\n  };\n  let before: string[] | null = args.prevPositions ? args.prevPositions.slice() : null;\n\n  return {\n    name: 'moveToIndex',\n    args: argsForSerial,\n    label: label ?? 'Move to index',\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => a.getParent(id) === parentId);\n      const current = a.getChildren(parentId);\n      // Only overwrite `before` the first time we apply; redo (a second\n      // apply) must not clobber the originally-captured order, otherwise\n      // invert would replay the post-move state and undo nothing.\n      if (before === null) {\n        before = current.slice();\n        argsForSerial.prevPositions = before.slice();\n      }\n      const after = moveToIndex(current, eligible, index);\n      a.setChildOrder(parentId, after);\n    },\n    invert() {\n      const captured = before;\n      return {\n        ...createSetChildOrderOp({ orders: captured ? [{ parentId, ids: captured }] : [], label }),\n        invert: () =>\n          createMoveToIndexOp({\n            ids, parentId, index, label, prevPositions: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<MoveToIndexArgs>('moveToIndex', (args) => createMoveToIndexOp(args));\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/core/ops/reorder/index.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\nimport {\n  bringForward,\n  sendBackward,\n  bringToFront,\n  sendToBack,\n  moveToIndex,\n} from './algorithms';\n\nimport { createSetChildOrderOp } from './setChildOrder';\n\nexport { canBringForward, canSendBackward } from './algorithms';\nexport { createSetChildOrderOp, type ChildOrder, type SetChildOrderArgs } from './setChildOrder';\n\ninterface ReorderAdapter {\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\ntype ReorderFn = (list: string[], ids: string[]) => string[];\n\nfunction arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n\n/** One parent's child order before a reorder, kept so undo can restore it. */\nexport interface ReorderRestoreEntry {\n  parentId: string | null;\n  before: string[];\n}\n\n/** Arguments to {@link createReorderOp}: move `ids` in paint order, one step or to the front/back. */\nexport interface ReorderArgs {\n  ids: string[];\n  direction: ReorderDirection;\n  label?: string;\n  /** Pre-mutation child order per touched parent. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ReorderRestoreEntry[];\n}\n\n/**\n * Build an op that, on apply, partitions `ids` by their current parent,\n * runs `fn(currentChildren, idsForParent)` per parent, and writes the\n * result back via setChildOrder. Records before-state per parent so invert\n * is exact.\n *\n * `prevOrders` is that before-state, mirrored into the op's serialized args\n * on first apply. A deserialized op has never run its own `apply`, so its\n * invert has nothing to capture — reading it back from the args is what lets\n * a reorder survive a reload, the same trick `createMoveToIndexOp` uses.\n */\nfunction createPartitionedReorderOp(args: {\n  ids: string[];\n  direction: ReorderDirection;\n  fn: ReorderFn;\n  label?: string;\n  prevOrders?: ReorderRestoreEntry[];\n}): Op {\n  const { ids, direction, fn, label, prevOrders } = args;\n  const argsForSerial: ReorderArgs = {\n    ids,\n    direction,\n    label,\n    prevOrders: prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : undefined,\n  };\n  let restore: ReorderRestoreEntry[] | null =\n    prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : null;\n\n  return {\n    name: 'reorder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Partition ids by current parent.\n      const byParent = new Map<string | null, string[]>();\n      for (const id of ids) {\n        const parent = a.getParent(id);\n        const list = byParent.get(parent) ?? [];\n        list.push(id);\n        byParent.set(parent, list);\n      }\n      const snapshots: ReorderRestoreEntry[] = [];\n      let mutated = false;\n      for (const [parentId, parentIds] of byParent) {\n        const before = a.getChildren(parentId);\n        const after = fn(before, parentIds);\n        if (arraysEqual(before, after)) continue; // already at the desired order\n        snapshots.push({ parentId, before: before.slice() });\n        a.setChildOrder(parentId, after);\n        mutated = true;\n      }\n      restore = snapshots;\n      argsForSerial.prevOrders = snapshots.map((e) => ({ ...e, before: e.before.slice() }));\n      return mutated;\n    },\n    invert() {\n      const captured = restore;\n      return {\n        ...createSetChildOrderOp({\n          orders: (captured ?? []).map((e) => ({ parentId: e.parentId, ids: e.before })),\n          label,\n        }),\n        invert: () =>\n          createPartitionedReorderOp({\n            ids, direction, fn, label, prevOrders: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\n/** Direction of a sibling z-order reorder. */\nexport type ReorderDirection = 'forward' | 'backward' | 'front' | 'back';\n\nconst REORDER_DIRECTIONS: Record<ReorderDirection, { fn: ReorderFn; defaultLabel: string }> = {\n  forward:  { fn: bringForward,  defaultLabel: 'Bring forward' },\n  backward: { fn: sendBackward,  defaultLabel: 'Send backward' },\n  front:    { fn: bringToFront,  defaultLabel: 'Bring to front' },\n  back:     { fn: sendToBack,    defaultLabel: 'Send to back' },\n};\n\n/**\n * Op: shift each id within its parent's child order per `direction`:\n *   - `'forward'`  — bump one step toward the top\n *   - `'backward'` — bump one step toward the bottom\n *   - `'front'`    — move to the top, preserving relative order\n *   - `'back'`     — move to the bottom, preserving relative order\n */\nexport function createReorderOp(args: ReorderArgs): Op {\n  const { ids, direction, label, prevOrders } = args;\n  const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];\n  return createPartitionedReorderOp({\n    ids, direction, fn, label: label ?? defaultLabel, prevOrders,\n  });\n}\n\nregisterOpFactory<ReorderArgs>('reorder', (args) => createReorderOp(args));\n\n/** Arguments to {@link createMoveToIndexOp}: move `ids` to `index` under `parentId`. */\nexport interface MoveToIndexArgs {\n  ids: string[];\n  parentId: string | null;\n  index: number;\n  label?: string;\n  /** Optional pre-mutation child order for the parent. When present, the op\n   *  uses it as the invert target instead of capturing at apply time — this\n   *  is how a deserialized op (whose original `apply` already ran in a prior\n   *  session) restores its invert behavior across an IDB round-trip. */\n  prevPositions?: string[];\n}\n\n/** Op: move all `ids` to a contiguous block starting at `index` within `parentId`'s child order. */\nexport function createMoveToIndexOp(args: MoveToIndexArgs): Op {\n  const { ids, parentId, index, label } = args;\n  // Outer args record we'll mutate so the captured `before` lands in the\n  // serialized form. `prevPositions` arrives populated when reconstructed\n  // from a snapshot; otherwise it's filled in on first apply.\n  const argsForSerial: MoveToIndexArgs = {\n    ids,\n    parentId,\n    index,\n    label,\n    prevPositions: args.prevPositions ? args.prevPositions.slice() : undefined,\n  };\n  let before: string[] | null = args.prevPositions ? args.prevPositions.slice() : null;\n\n  return {\n    name: 'moveToIndex',\n    args: argsForSerial,\n    label: label ?? 'Move to index',\n    apply(adapter) {\n      const a = adapter as ReorderAdapter;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => a.getParent(id) === parentId);\n      const current = a.getChildren(parentId);\n      // Only overwrite `before` the first time we apply; redo (a second\n      // apply) must not clobber the originally-captured order, otherwise\n      // invert would replay the post-move state and undo nothing.\n      if (before === null) {\n        before = current.slice();\n        argsForSerial.prevPositions = before.slice();\n      }\n      const after = moveToIndex(current, eligible, index);\n      a.setChildOrder(parentId, after);\n    },\n    invert() {\n      const captured = before;\n      return {\n        ...createSetChildOrderOp({ orders: captured ? [{ parentId, ids: captured }] : [], label }),\n        invert: () =>\n          createMoveToIndexOp({\n            ids, parentId, index, label, prevPositions: captured ?? undefined,\n          }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<MoveToIndexArgs>('moveToIndex', (args) => createMoveToIndexOp(args));\n"],"mappings":"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"}

package/dist/core/ops/reorder/setChildOrder.js

@@ -1,32 +1,41 @@
-import { registerOpFactory as e } from "../registry.js";
+import { registerOpFactory } from "../registry.js";
+
 //#region src/core/ops/reorder/setChildOrder.ts
-function t(e) {
-	let { orders: n, label: r } = e, i = {
-		orders: n,
-		label: r,
-		prevOrders: e.prevOrders
-	}, a = e.prevOrders ?? null;
+/** Op: write each listed parent's whole child order; inverts to a write of the
+*  orders it replaced. Where `createMoveToIndexOp` keeps the moved ids in their
+*  current relative order, this states every position. */
+function createSetChildOrderOp(args) {
+	const { orders, label } = args;
+	const argsForSerial = {
+		orders,
+		label,
+		prevOrders: args.prevOrders
+	};
+	let before = args.prevOrders ?? null;
 	return {
 		name: "setChildOrder",
-		args: i,
-		label: r,
-		apply(e) {
-			let t = e;
-			a === null && (a = n.map((e) => ({
-				parentId: e.parentId,
-				ids: t.getChildren(e.parentId).slice()
-			})), i.prevOrders = a);
-			for (let e of n) t.setChildOrder(e.parentId, e.ids.slice());
+		args: argsForSerial,
+		label,
+		apply(adapter) {
+			const a = adapter;
+			if (before === null) {
+				before = orders.map((o) => ({
+					parentId: o.parentId,
+					ids: a.getChildren(o.parentId).slice()
+				}));
+				argsForSerial.prevOrders = before;
+			}
+			for (const o of orders) a.setChildOrder(o.parentId, o.ids.slice());
 		},
-		invert: () => t({
-			orders: a ?? [],
-			label: r,
-			prevOrders: n
+		invert: () => createSetChildOrderOp({
+			orders: before ?? [],
+			label,
+			prevOrders: orders
 		})
 	};
 }
-e("setChildOrder", (e) => t(e));
-//#endregion
-export { t as createSetChildOrderOp };
+registerOpFactory("setChildOrder", (args) => createSetChildOrderOp(args));
 
+//#endregion
+export { createSetChildOrderOp };
 //# sourceMappingURL=setChildOrder.js.map

package/dist/core/ops/reorder/setChildOrder.js.map

@@ -1 +1 @@
-{"version":3,"file":"setChildOrder.js","names":["createSetChildOrderOp","args","argsForSerial","before","a","adapter","orders","o","registerOpFactory"],"sources":["../../../../src/core/ops/reorder/setChildOrder.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\n\ninterface ChildOrderAdapter {\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** One parent's children, in order. */\nexport interface ChildOrder {\n  parentId: string | null;\n  ids: string[];\n}\n\n/** Arguments to {@link createSetChildOrderOp}: the whole child order to write, per parent. */\nexport interface SetChildOrderArgs {\n  orders: ChildOrder[];\n  label?: string;\n  /** Each parent's order before the write. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ChildOrder[];\n}\n\n/** Op: write each listed parent's whole child order; inverts to a write of the\n *  orders it replaced. Where `createMoveToIndexOp` keeps the moved ids in their\n *  current relative order, this states every position. */\nexport function createSetChildOrderOp(args: SetChildOrderArgs): Op {\n  const { orders, label } = args;\n  const argsForSerial: SetChildOrderArgs = { orders, label, prevOrders: args.prevOrders };\n  let before: ChildOrder[] | null = args.prevOrders ?? null;\n  return {\n    name: 'setChildOrder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ChildOrderAdapter;\n      if (before === null) {\n        before = orders.map((o) => ({ parentId: o.parentId, ids: a.getChildren(o.parentId).slice() }));\n        argsForSerial.prevOrders = before;\n      }\n      for (const o of orders) a.setChildOrder(o.parentId, o.ids.slice());\n      return undefined;\n    },\n    invert: () => createSetChildOrderOp({ orders: before ?? [], label, prevOrders: orders }),\n  };\n}\n\nregisterOpFactory<SetChildOrderArgs>('setChildOrder', (args) => createSetChildOrderOp(args));\n"],"mappings":";;AA0BA,SAAgBA,EAAsB,GAA6B;CACjE,IAAM,EAAE,WAAQ,aAAUC,GACpBC,IAAmC;EAAE;EAAQ;EAAO,YAAYD,EAAK;CAAW,GAClFE,IAA8BF,EAAK,cAAc;CACrD,OAAO;EACL,MAAM;EACN,MAAMC;EACN;EACA,MAAM,GAAS;GACb,IAAME,IAAIC;GACV,AAAIF,MAAW,SACb,IAASG,EAAO,KAAK,OAAO;IAAE,UAAUC,EAAE;IAAU,KAAKH,EAAE,YAAYG,EAAE,QAAQ,CAAC,CAAC,MAAM;GAAE,EAAE,GAC7F,EAAc,aAAaJ;GAE7B,KAAK,IAAMI,KAAKD,GAAQ,EAAE,cAAcC,EAAE,UAAUA,EAAE,IAAI,MAAM,CAAC;EAEnE;EACA,cAAcP,EAAsB;GAAE,QAAQG,KAAU,CAAC;GAAG;GAAO,YAAYG;EAAO,CAAC;CACzF;AACF;AAEAE,EAAqC,kBAAkB,MAASR,EAAsBC,CAAI,CAAC"}
+{"version":3,"file":"setChildOrder.js","names":[],"sources":["../../../../src/core/ops/reorder/setChildOrder.ts"],"sourcesContent":["import type { Op } from '../types';\nimport { registerOpFactory } from '../registry';\n\ninterface ChildOrderAdapter {\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** One parent's children, in order. */\nexport interface ChildOrder {\n  parentId: string | null;\n  ids: string[];\n}\n\n/** Arguments to {@link createSetChildOrderOp}: the whole child order to write, per parent. */\nexport interface SetChildOrderArgs {\n  orders: ChildOrder[];\n  label?: string;\n  /** Each parent's order before the write. Filled in on first apply;\n   *  arrives populated when the op is rebuilt from a snapshot. */\n  prevOrders?: ChildOrder[];\n}\n\n/** Op: write each listed parent's whole child order; inverts to a write of the\n *  orders it replaced. Where `createMoveToIndexOp` keeps the moved ids in their\n *  current relative order, this states every position. */\nexport function createSetChildOrderOp(args: SetChildOrderArgs): Op {\n  const { orders, label } = args;\n  const argsForSerial: SetChildOrderArgs = { orders, label, prevOrders: args.prevOrders };\n  let before: ChildOrder[] | null = args.prevOrders ?? null;\n  return {\n    name: 'setChildOrder',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as ChildOrderAdapter;\n      if (before === null) {\n        before = orders.map((o) => ({ parentId: o.parentId, ids: a.getChildren(o.parentId).slice() }));\n        argsForSerial.prevOrders = before;\n      }\n      for (const o of orders) a.setChildOrder(o.parentId, o.ids.slice());\n      return undefined;\n    },\n    invert: () => createSetChildOrderOp({ orders: before ?? [], label, prevOrders: orders }),\n  };\n}\n\nregisterOpFactory<SetChildOrderArgs>('setChildOrder', (args) => createSetChildOrderOp(args));\n"],"mappings":";;;;;;AA0BA,SAAgB,sBAAsB,MAA6B;CACjE,MAAM,EAAE,QAAQ,UAAU;CAC1B,MAAM,gBAAmC;EAAE;EAAQ;EAAO,YAAY,KAAK;CAAW;CACtF,IAAI,SAA8B,KAAK,cAAc;CACrD,OAAO;EACL,MAAM;EACN,MAAM;EACN;EACA,MAAM,SAAS;GACb,MAAM,IAAI;GACV,IAAI,WAAW,MAAM;IACnB,SAAS,OAAO,KAAK,OAAO;KAAE,UAAU,EAAE;KAAU,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC,MAAM;IAAE,EAAE;IAC7F,cAAc,aAAa;GAC7B;GACA,KAAK,MAAM,KAAK,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,MAAM,CAAC;EAEnE;EACA,cAAc,sBAAsB;GAAE,QAAQ,UAAU,CAAC;GAAG;GAAO,YAAY;EAAO,CAAC;CACzF;AACF;AAEA,kBAAqC,kBAAkB,SAAS,sBAAsB,IAAI,CAAC"}

package/dist/core/ops/reparent.js

@@ -1,51 +1,77 @@
-import { registerOpFactory as e } from "./registry.js";
-import { captureSlot as t, resolveSlot as n, slotFromIndex as r } from "./slot.js";
+import { registerOpFactory } from "./registry.js";
+import { captureSlot, resolveSlot, slotFromIndex } from "./slot.js";
+
 //#region src/core/ops/reparent.ts
-function i(e, t, r, i) {
-	let a = e.getChildren(t), o = a.indexOf(r);
-	if (o < 0) return;
-	let s = a.slice();
-	s.splice(o, 1);
-	let c = n(s, i), l = c === void 0 ? s.length : Math.max(0, Math.min(c, s.length));
-	o !== l && (s.splice(l, 0, r), e.setChildOrder(t, s));
+/** Move `id` to `slot` among `parentId`'s children. No-op when `id` isn't
+*  there or is already in place. */
+function placeAt(a, parentId, id, slot) {
+	const current = a.getChildren(parentId);
+	const from = current.indexOf(id);
+	if (from < 0) return;
+	const next = current.slice();
+	next.splice(from, 1);
+	const resolved = resolveSlot(next, slot);
+	const to = resolved === void 0 ? next.length : Math.max(0, Math.min(resolved, next.length));
+	if (from === to) return;
+	next.splice(to, 0, id);
+	a.setChildOrder(parentId, next);
 }
-function a(e, t) {
-	return e || (t === void 0 ? void 0 : r(t));
+/** Present when the caller named a destination at all; `undefined` leaves
+*  placement to the adapter. */
+function optionalSlot(slot, index) {
+	if (slot) return slot;
+	return index === void 0 ? void 0 : slotFromIndex(index);
 }
-function o(e) {
-	let { id: n, fromParentId: r, toParentId: s, label: c = "Reparent", coalesceKey: l = `reparent:${n}` } = e, u = a(e.fromSlot, e.fromIndex), d = a(e.toSlot, e.toIndex), f = {
-		id: n,
-		fromParentId: r,
-		toParentId: s,
-		fromSlot: u,
-		toSlot: d,
-		label: c,
-		coalesceKey: l
+/**
+* Op: change `id`'s parent and sibling slot, inverting back to the prior
+* parent and slot.
+*
+* `coalesceKey` defaults to `reparent:${id}` so successive reparents of the
+* same id batch-merge cleanly.
+*/
+function createReparentOp(args) {
+	const { id, fromParentId, toParentId, label = "Reparent", coalesceKey = `reparent:${id}` } = args;
+	let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);
+	const toSlot = optionalSlot(args.toSlot, args.toIndex);
+	const argsForSerial = {
+		id,
+		fromParentId,
+		toParentId,
+		fromSlot,
+		toSlot,
+		label,
+		coalesceKey
 	};
 	return {
 		name: "reparent",
-		args: f,
-		label: c,
-		coalesceKey: l,
-		apply(e) {
-			let a = e, o = t(a, r, n);
-			o && (u = o, f.fromSlot = o), a.setParent(n, s), d && i(a, s, n, d);
+		args: argsForSerial,
+		label,
+		coalesceKey,
+		apply(adapter) {
+			const a = adapter;
+			const observed = captureSlot(a, fromParentId, id);
+			if (observed) {
+				fromSlot = observed;
+				argsForSerial.fromSlot = observed;
+			}
+			a.setParent(id, toParentId);
+			if (toSlot) placeAt(a, toParentId, id, toSlot);
 		},
 		invert() {
-			return o({
-				id: n,
-				fromParentId: s,
-				toParentId: r,
-				fromSlot: d,
-				toSlot: u,
-				label: c,
-				coalesceKey: l
+			return createReparentOp({
+				id,
+				fromParentId: toParentId,
+				toParentId: fromParentId,
+				fromSlot: toSlot,
+				toSlot: fromSlot,
+				label,
+				coalesceKey
 			});
 		}
 	};
 }
-e("reparent", (e) => o(e));
-//#endregion
-export { o as createReparentOp };
+registerOpFactory("reparent", (args) => createReparentOp(args));
 
+//#endregion
+export { createReparentOp };
 //# sourceMappingURL=reparent.js.map

package/dist/core/ops/reparent.js.map

@@ -1 +1 @@
-{"version":3,"file":"reparent.js","names":["placeAt","current","a","parentId","from","id","next","resolved","resolveSlot","slot","to","optionalSlot","index","slotFromIndex","createReparentOp","args","fromSlot","toSlot","argsForSerial","adapter","observed","captureSlot","fromParentId","toParentId","registerOpFactory"],"sources":["../../../src/core/ops/reparent.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface ReparentAdapter extends OrderedReader {\n  setParent(id: string, parentId: string | null): void;\n  /** Sibling-order write, paired with `getChildren`. */\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** Arguments to {@link createReparentOp}: move node `id` from one parent to another. */\nexport interface ReparentArgs {\n  id: string;\n  fromParentId: string | null;\n  toParentId: string | null;\n  /** Sibling ordinal under the old parent. Sugar for `fromSlot: { index }`,\n   *  and only a seed: `apply` re-observes the node's full slot through the\n   *  adapter and that observation supersedes this. */\n  fromIndex?: number;\n  /** Sibling ordinal under the new parent. Sugar for `toSlot: { index }`.\n   *  Omit to append. */\n  toIndex?: number;\n  /** Slot under the old parent, anchor included. `invert()` forwards it as\n   *  the destination slot; without it undo re-parents with no position and\n   *  the node lands last, quietly changing paint order. */\n  fromSlot?: SiblingSlot;\n  /** Slot under the new parent, anchor included. Omit to append. */\n  toSlot?: SiblingSlot;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Move `id` to `slot` among `parentId`'s children. No-op when `id` isn't\n *  there or is already in place. */\nfunction placeAt(\n  a: ReparentAdapter,\n  parentId: string | null,\n  id: string,\n  slot: SiblingSlot,\n): void {\n  const current = a.getChildren(parentId);\n  const from = current.indexOf(id);\n  if (from < 0) return;\n  const next = current.slice();\n  next.splice(from, 1);\n  const resolved = resolveSlot(next, slot);\n  const to = resolved === undefined ? next.length : Math.max(0, Math.min(resolved, next.length));\n  if (from === to) return;\n  next.splice(to, 0, id);\n  a.setChildOrder(parentId, next);\n}\n\n/** Present when the caller named a destination at all; `undefined` leaves\n *  placement to the adapter. */\nfunction optionalSlot(slot: SiblingSlot | undefined, index: number | undefined): SiblingSlot | undefined {\n  if (slot) return slot;\n  return index === undefined ? undefined : slotFromIndex(index);\n}\n\n/**\n * Op: change `id`'s parent and sibling slot, inverting back to the prior\n * parent and slot.\n *\n * `coalesceKey` defaults to `reparent:${id}` so successive reparents of the\n * same id batch-merge cleanly.\n */\nexport function createReparentOp(args: ReparentArgs): Op {\n  const {\n    id, fromParentId, toParentId,\n    label = 'Reparent', coalesceKey = `reparent:${id}`,\n  } = args;\n  let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);\n  const toSlot = optionalSlot(args.toSlot, args.toIndex);\n  const argsForSerial: ReparentArgs = {\n    id, fromParentId, toParentId, fromSlot, toSlot, label, coalesceKey,\n  };\n  return {\n    name: 'reparent',\n    args: argsForSerial,\n    label,\n    coalesceKey,\n    apply(adapter) {\n      const a = adapter as ReparentAdapter;\n      const observed = captureSlot(a, fromParentId, id);\n      if (observed) {\n        fromSlot = observed;\n        argsForSerial.fromSlot = observed;\n      }\n      a.setParent(id, toParentId);\n      if (toSlot) placeAt(a, toParentId, id, toSlot);\n    },\n    invert() {\n      return createReparentOp({\n        id,\n        fromParentId: toParentId,\n        toParentId: fromParentId,\n        fromSlot: toSlot,\n        toSlot: fromSlot,\n        label,\n        coalesceKey,\n      });\n    },\n  };\n}\n\nregisterOpFactory<ReparentArgs>('reparent', (args) => createReparentOp(args));\n"],"mappings":";;;AAkCA,SAASA,EACP,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAUC,EAAE,YAAYC,CAAQ,GAChCC,IAAOH,EAAQ,QAAQI,CAAE;CAC/B,IAAID,IAAO,GAAG;CACd,IAAME,IAAOL,EAAQ,MAAM;CAC3B,EAAK,OAAOG,GAAM,CAAC;CACnB,IAAMG,IAAWC,EAAYF,GAAMG,CAAI,GACjCC,IAAKH,MAAa,KAAA,IAAYD,EAAK,SAAS,KAAK,IAAI,GAAG,KAAK,IAAIC,GAAUD,EAAK,MAAM,CAAC;CAC7F,AAAIF,MAASM,MACbJ,EAAK,OAAOI,GAAI,GAAGL,CAAE,GACrBH,EAAE,cAAcC,GAAUG,CAAI;AAChC;AAIA,SAASK,EAAa,GAA+B,GAAoD;CAEvG,OADIF,MACGG,MAAU,KAAA,IAAY,KAAA,IAAYC,EAAcD,CAAK;AAC9D;AASA,SAAgBE,EAAiB,GAAwB;CACvD,IAAM,EACJ,OAAI,iBAAc,eAClB,WAAQ,YAAY,iBAAc,YAAYT,QAC5CU,GACAC,IAAWL,EAAaI,EAAK,UAAUA,EAAK,SAAS,GACnDE,IAASN,EAAaI,EAAK,QAAQA,EAAK,OAAO,GAC/CG,IAA8B;EAClC;EAAI;EAAc;EAAY;EAAU;EAAQ;EAAO;CACzD;CACA,OAAO;EACL,MAAM;EACN,MAAMA;EACN;EACA;EACA,MAAM,GAAS;GACb,IAAM,IAAIC,GACJC,IAAWC,EAAY,GAAGC,GAAcjB,CAAE;GAMhD,AALIe,MACF,IAAWA,GACX,EAAc,WAAWA,IAE3B,EAAE,UAAUf,GAAIkB,CAAU,GACtBN,KAAQjB,EAAQ,GAAGuB,GAAYlB,GAAIY,CAAM;EAC/C;EACA,SAAS;GACP,OAAOH,EAAiB;IACtB;IACA,cAAcS;IACd,YAAYD;IACZ,UAAUL;IACV,QAAQD;IACR;IACA;GACF,CAAC;EACH;CACF;AACF;AAEAQ,EAAgC,aAAa,MAASV,EAAiBC,CAAI,CAAC"}
+{"version":3,"file":"reparent.js","names":[],"sources":["../../../src/core/ops/reparent.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface ReparentAdapter extends OrderedReader {\n  setParent(id: string, parentId: string | null): void;\n  /** Sibling-order write, paired with `getChildren`. */\n  setChildOrder(parentId: string | null, ids: string[]): void;\n}\n\n/** Arguments to {@link createReparentOp}: move node `id` from one parent to another. */\nexport interface ReparentArgs {\n  id: string;\n  fromParentId: string | null;\n  toParentId: string | null;\n  /** Sibling ordinal under the old parent. Sugar for `fromSlot: { index }`,\n   *  and only a seed: `apply` re-observes the node's full slot through the\n   *  adapter and that observation supersedes this. */\n  fromIndex?: number;\n  /** Sibling ordinal under the new parent. Sugar for `toSlot: { index }`.\n   *  Omit to append. */\n  toIndex?: number;\n  /** Slot under the old parent, anchor included. `invert()` forwards it as\n   *  the destination slot; without it undo re-parents with no position and\n   *  the node lands last, quietly changing paint order. */\n  fromSlot?: SiblingSlot;\n  /** Slot under the new parent, anchor included. Omit to append. */\n  toSlot?: SiblingSlot;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Move `id` to `slot` among `parentId`'s children. No-op when `id` isn't\n *  there or is already in place. */\nfunction placeAt(\n  a: ReparentAdapter,\n  parentId: string | null,\n  id: string,\n  slot: SiblingSlot,\n): void {\n  const current = a.getChildren(parentId);\n  const from = current.indexOf(id);\n  if (from < 0) return;\n  const next = current.slice();\n  next.splice(from, 1);\n  const resolved = resolveSlot(next, slot);\n  const to = resolved === undefined ? next.length : Math.max(0, Math.min(resolved, next.length));\n  if (from === to) return;\n  next.splice(to, 0, id);\n  a.setChildOrder(parentId, next);\n}\n\n/** Present when the caller named a destination at all; `undefined` leaves\n *  placement to the adapter. */\nfunction optionalSlot(slot: SiblingSlot | undefined, index: number | undefined): SiblingSlot | undefined {\n  if (slot) return slot;\n  return index === undefined ? undefined : slotFromIndex(index);\n}\n\n/**\n * Op: change `id`'s parent and sibling slot, inverting back to the prior\n * parent and slot.\n *\n * `coalesceKey` defaults to `reparent:${id}` so successive reparents of the\n * same id batch-merge cleanly.\n */\nexport function createReparentOp(args: ReparentArgs): Op {\n  const {\n    id, fromParentId, toParentId,\n    label = 'Reparent', coalesceKey = `reparent:${id}`,\n  } = args;\n  let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);\n  const toSlot = optionalSlot(args.toSlot, args.toIndex);\n  const argsForSerial: ReparentArgs = {\n    id, fromParentId, toParentId, fromSlot, toSlot, label, coalesceKey,\n  };\n  return {\n    name: 'reparent',\n    args: argsForSerial,\n    label,\n    coalesceKey,\n    apply(adapter) {\n      const a = adapter as ReparentAdapter;\n      const observed = captureSlot(a, fromParentId, id);\n      if (observed) {\n        fromSlot = observed;\n        argsForSerial.fromSlot = observed;\n      }\n      a.setParent(id, toParentId);\n      if (toSlot) placeAt(a, toParentId, id, toSlot);\n    },\n    invert() {\n      return createReparentOp({\n        id,\n        fromParentId: toParentId,\n        toParentId: fromParentId,\n        fromSlot: toSlot,\n        toSlot: fromSlot,\n        label,\n        coalesceKey,\n      });\n    },\n  };\n}\n\nregisterOpFactory<ReparentArgs>('reparent', (args) => createReparentOp(args));\n"],"mappings":";;;;;;AAkCA,SAAS,QACP,GACA,UACA,IACA,MACM;CACN,MAAM,UAAU,EAAE,YAAY,QAAQ;CACtC,MAAM,OAAO,QAAQ,QAAQ,EAAE;CAC/B,IAAI,OAAO,GAAG;CACd,MAAM,OAAO,QAAQ,MAAM;CAC3B,KAAK,OAAO,MAAM,CAAC;CACnB,MAAM,WAAW,YAAY,MAAM,IAAI;CACvC,MAAM,KAAK,aAAa,SAAY,KAAK,SAAS,KAAK,IAAI,GAAG,KAAK,IAAI,UAAU,KAAK,MAAM,CAAC;CAC7F,IAAI,SAAS,IAAI;CACjB,KAAK,OAAO,IAAI,GAAG,EAAE;CACrB,EAAE,cAAc,UAAU,IAAI;AAChC;;;AAIA,SAAS,aAAa,MAA+B,OAAoD;CACvG,IAAI,MAAM,OAAO;CACjB,OAAO,UAAU,SAAY,SAAY,cAAc,KAAK;AAC9D;;;;;;;;AASA,SAAgB,iBAAiB,MAAwB;CACvD,MAAM,EACJ,IAAI,cAAc,YAClB,QAAQ,YAAY,cAAc,YAAY,SAC5C;CACJ,IAAI,WAAW,aAAa,KAAK,UAAU,KAAK,SAAS;CACzD,MAAM,SAAS,aAAa,KAAK,QAAQ,KAAK,OAAO;CACrD,MAAM,gBAA8B;EAClC;EAAI;EAAc;EAAY;EAAU;EAAQ;EAAO;CACzD;CACA,OAAO;EACL,MAAM;EACN,MAAM;EACN;EACA;EACA,MAAM,SAAS;GACb,MAAM,IAAI;GACV,MAAM,WAAW,YAAY,GAAG,cAAc,EAAE;GAChD,IAAI,UAAU;IACZ,WAAW;IACX,cAAc,WAAW;GAC3B;GACA,EAAE,UAAU,IAAI,UAAU;GAC1B,IAAI,QAAQ,QAAQ,GAAG,YAAY,IAAI,MAAM;EAC/C;EACA,SAAS;GACP,OAAO,iBAAiB;IACtB;IACA,cAAc;IACd,YAAY;IACZ,UAAU;IACV,QAAQ;IACR;IACA;GACF,CAAC;EACH;CACF;AACF;AAEA,kBAAgC,aAAa,SAAS,iBAAiB,IAAI,CAAC"}

package/dist/core/ops/select.js

@@ -1,34 +1,37 @@
-import { registerOpFactory as e } from "./registry.js";
+import { registerOpFactory } from "./registry.js";
+
 //#region src/core/ops/select.ts
-function t(e) {
-	let { from: r, to: i, label: a } = e;
+/** Op: replace the current selection with `to`; inverts back to `from`. */
+function createSetSelectionOp(args) {
+	const { from, to, label } = args;
 	return {
 		name: "setSelection",
 		args: {
-			from: r,
-			to: i,
-			label: a
+			from,
+			to,
+			label
 		},
-		label: a,
-		apply(e) {
-			if (e.setSelection([...i]), n(r, i)) return !1;
+		label,
+		apply(adapter) {
+			adapter.setSelection([...to]);
+			if (sequenceEqual(from, to)) return false;
 		},
 		invert() {
-			return t({
-				from: i,
-				to: r,
-				label: a
+			return createSetSelectionOp({
+				from: to,
+				to: from,
+				label
 			});
 		}
 	};
 }
-e("setSelection", (e) => t(e));
-function n(e, t) {
-	if (e.length !== t.length) return !1;
-	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
-	return !0;
+registerOpFactory("setSelection", (args) => createSetSelectionOp(args));
+function sequenceEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
 }
-//#endregion
-export { t as createSetSelectionOp };
 
+//#endregion
+export { createSetSelectionOp };
 //# sourceMappingURL=select.js.map

package/dist/core/ops/select.js.map

@@ -1 +1 @@
-{"version":3,"file":"select.js","names":["createSetSelectionOp","args","adapter","to","sequenceEqual","from","registerOpFactory","a","b","i"],"sources":["../../../src/core/ops/select.ts"],"sourcesContent":["import type { NodeId } from '../scene/types';\nimport type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface SelectionAdapter {\n  setSelection(ids: NodeId[]): void;\n}\n\n/** Arguments to {@link createSetSelectionOp}: replace the selection `from` → `to`. */\nexport interface SetSelectionArgs {\n  from: readonly NodeId[];\n  to: readonly NodeId[];\n  label?: string;\n}\n\n/** Op: replace the current selection with `to`; inverts back to `from`. */\nexport function createSetSelectionOp(args: SetSelectionArgs): Op {\n  const { from, to, label } = args;\n  return {\n    name: 'setSelection',\n    args: { from, to, label },\n    label,\n    apply(adapter) {\n      // Always call setSelection so consumers that inspect op behavior\n      // (tests, overlays) see a consistent \"this op writes `to`\" signal.\n      // When from and to are sequence-equal, additionally report a no-op\n      // to history so the entry can be skipped from the undo stack.\n      // setSelection with the same value is idempotent.\n      (adapter as SelectionAdapter).setSelection([...to]);\n      if (sequenceEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createSetSelectionOp({ from: to, to: from, label });\n    },\n  };\n}\n\nregisterOpFactory<SetSelectionArgs>('setSelection', (args) => createSetSelectionOp(args));\n\nfunction sequenceEqual(a: readonly NodeId[], b: readonly NodeId[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";;AAgBA,SAAgBA,EAAqB,GAA4B;CAC/D,IAAM,EAAE,SAAM,OAAI,aAAUC;CAC5B,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAI;EAAM;EACxB;EACA,MAAM,GAAS;GAOb,IADAC,EAA8B,aAAa,CAAC,GAAGC,CAAE,CAAC,GAC9CC,EAAcC,GAAMF,CAAE,GAAG,OAAO;EAEtC;EACA,SAAS;GACP,OAAOH,EAAqB;IAAE,MAAMG;IAAI,IAAIE;IAAM;GAAM,CAAC;EAC3D;CACF;AACF;AAEAC,EAAoC,iBAAiB,MAASN,EAAqBC,CAAI,CAAC;AAExF,SAASG,EAAc,GAAsB,GAA+B;CAC1E,IAAIG,EAAE,WAAWC,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAIC,IAAI,GAAGA,IAAIF,EAAE,QAAQ,KAAK,IAAIA,EAAEE,OAAOD,EAAEC,IAAI,OAAO;CAC7D,OAAO;AACT"}
+{"version":3,"file":"select.js","names":[],"sources":["../../../src/core/ops/select.ts"],"sourcesContent":["import type { NodeId } from '../scene/types';\nimport type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface SelectionAdapter {\n  setSelection(ids: NodeId[]): void;\n}\n\n/** Arguments to {@link createSetSelectionOp}: replace the selection `from` → `to`. */\nexport interface SetSelectionArgs {\n  from: readonly NodeId[];\n  to: readonly NodeId[];\n  label?: string;\n}\n\n/** Op: replace the current selection with `to`; inverts back to `from`. */\nexport function createSetSelectionOp(args: SetSelectionArgs): Op {\n  const { from, to, label } = args;\n  return {\n    name: 'setSelection',\n    args: { from, to, label },\n    label,\n    apply(adapter) {\n      // Always call setSelection so consumers that inspect op behavior\n      // (tests, overlays) see a consistent \"this op writes `to`\" signal.\n      // When from and to are sequence-equal, additionally report a no-op\n      // to history so the entry can be skipped from the undo stack.\n      // setSelection with the same value is idempotent.\n      (adapter as SelectionAdapter).setSelection([...to]);\n      if (sequenceEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createSetSelectionOp({ from: to, to: from, label });\n    },\n  };\n}\n\nregisterOpFactory<SetSelectionArgs>('setSelection', (args) => createSetSelectionOp(args));\n\nfunction sequenceEqual(a: readonly NodeId[], b: readonly NodeId[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";;;;AAgBA,SAAgB,qBAAqB,MAA4B;CAC/D,MAAM,EAAE,MAAM,IAAI,UAAU;CAC5B,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAI;EAAM;EACxB;EACA,MAAM,SAAS;GAMb,QAA8B,aAAa,CAAC,GAAG,EAAE,CAAC;GAClD,IAAI,cAAc,MAAM,EAAE,GAAG,OAAO;EAEtC;EACA,SAAS;GACP,OAAO,qBAAqB;IAAE,MAAM;IAAI,IAAI;IAAM;GAAM,CAAC;EAC3D;CACF;AACF;AAEA,kBAAoC,iBAAiB,SAAS,qBAAqB,IAAI,CAAC;AAExF,SAAS,cAAc,GAAsB,GAA+B;CAC1E,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO;CAC7D,OAAO;AACT"}