@weasel-js/core 1.10.0 → 1.10.1

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      if (!a.getChildren || !a.setChildOrder) return false; // graceful no-op\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 ? a.getParent(id) : null;\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      if (!a.getChildren || !a.setChildOrder) return;\n      // Filter to ids whose current parent matches target parent.\n      const eligible = ids.filter((id) => {\n        const p = a.getParent ? a.getParent(id) : null;\n        return p === parentId;\n      });\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":["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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"}

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

@@ -12,11 +12,9 @@ function t(e) {
 		label: r,
 		apply(e) {
 			let t = e;
-			if (!t.setChildOrder) return !1;
-			let { getChildren: r } = t;
-			a === null && r && (a = n.map((e) => ({
+			a === null && (a = n.map((e) => ({
 				parentId: e.parentId,
-				ids: r.call(t, e.parentId).slice()
+				ids: t.getChildren(e.parentId).slice()
 			})), i.prevOrders = a);
 			for (let e of n) t.setChildOrder(e.parentId, e.ids.slice());
 		},

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

@@ -1 +1 @@
-{"version":3,"file":"setChildOrder.js","names":["createSetChildOrderOp","args","argsForSerial","before","a","adapter","getChildren","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 (!a.setChildOrder) return false;\n      const { getChildren } = a;\n      if (before === null && getChildren) {\n        before = orders.map((o) => ({ parentId: o.parentId, ids: getChildren.call(a, 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,IAAI,CAACD,EAAE,eAAe,OAAO;GAC7B,IAAM,EAAE,mBAAgBA;GACxB,AAAID,MAAW,QAAQG,MACrB,IAASC,EAAO,KAAK,OAAO;IAAE,UAAUC,EAAE;IAAU,KAAKF,EAAY,KAAKF,GAAGI,EAAE,QAAQ,CAAC,CAAC,MAAM;GAAE,EAAE,GACnG,EAAc,aAAaL;GAE7B,KAAK,IAAMK,KAAKD,GAAQ,EAAE,cAAcC,EAAE,UAAUA,EAAE,IAAI,MAAM,CAAC;EAEnE;EACA,cAAcR,EAAsB;GAAE,QAAQG,KAAU,CAAC;GAAG;GAAO,YAAYI;EAAO,CAAC;CACzF;AACF;AAEAE,EAAqC,kBAAkB,MAAST,EAAsBC,CAAI,CAAC"}
+{"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"}

package/dist/core/ops/reparent.js

@@ -2,7 +2,6 @@ import { registerOpFactory as e } from "./registry.js";
 import { captureSlot as t, resolveSlot as n, slotFromIndex as r } from "./slot.js";
 //#region src/core/ops/reparent.ts
 function i(e, t, r, i) {
-	if (!e.getChildren || !e.setChildOrder) return;
 	let a = e.getChildren(t), o = a.indexOf(r);
 	if (o < 0) return;
 	let s = a.slice();

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

@@ -1 +1 @@
-{"version":3,"file":"reparent.js","names":["placeAt","a","current","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`. Optional: an adapter\n   *  without both silently ignores slots and appends. */\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 the adapter\n *  has no ordering seam, when `id` isn't there, or when it's already in\n *  place. */\nfunction placeAt(\n  a: ReparentAdapter,\n  parentId: string | null,\n  id: string,\n  slot: SiblingSlot,\n): void {\n  if (!a.getChildren || !a.setChildOrder) return;\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":";;;AAoCA,SAASA,EACP,GACA,GACA,GACA,GACM;CACN,IAAI,CAACC,EAAE,eAAe,CAACA,EAAE,eAAe;CACxC,IAAMC,IAAUD,EAAE,YAAYE,CAAQ,GAChCC,IAAOF,EAAQ,QAAQG,CAAE;CAC/B,IAAID,IAAO,GAAG;CACd,IAAME,IAAOJ,EAAQ,MAAM;CAC3B,EAAK,OAAOE,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,GACrBJ,EAAE,cAAcE,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":["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"}

package/dist/core/ops/slot.js

@@ -1,8 +1,6 @@
 //#region src/core/ops/slot.ts
 function e(e, t, n) {
-	let r = e.getChildren?.(t);
-	if (!r) return null;
-	let i = r.indexOf(n);
+	let r = e.getChildren(t), i = r.indexOf(n);
 	return i < 0 ? null : {
 		index: i,
 		before: i + 1 < r.length ? r[i + 1] : null
@@ -10,7 +8,7 @@ function e(e, t, n) {
 }
 function t(e, t) {
 	if (t.before !== null) {
-		if (t.before !== void 0 && e) {
+		if (t.before !== void 0) {
 			let n = e.indexOf(t.before);
 			if (n >= 0) return n;
 		}
@@ -18,8 +16,7 @@ function t(e, t) {
 	}
 }
 function n(e, t) {
-	if (!e.getChildren) return null;
-	let n = e.getParent ? e.getParent(t) : null, r = e.getChildren(n).indexOf(t);
+	let n = e.getParent(t), r = e.getChildren(n).indexOf(t);
 	return r < 0 ? null : {
 		parentId: n,
 		index: r

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

@@ -1 +1 @@
-{"version":3,"file":"slot.js","names":["captureSlot","siblings","a","parentId","id","resolveSlot","slot","at","locateChild","index","slotFromIndex","parentOf","node"],"sources":["../../../src/core/ops/slot.ts"],"sourcesContent":["/** Sibling-order read seam. Optional everywhere: a flat adapter has none. */\nexport interface OrderedReader {\n  getChildren?(parentId: string | null): string[];\n}\n\n/**\n * A node's position among its siblings, recorded so an op can put it back.\n *\n * Recorded as an anchor (`before`) plus an ordinal (`index`). The anchor is\n * the source of truth: `History` replays a batch's inverses in reverse order,\n * so an ordinal captured before the mutation is replayed against a list that\n * has not been refilled yet and clamps to the end, while \"put this back before\n * `e`\" stays true however much else has already moved. The ordinal is the\n * fallback for the cases the anchor cannot cover — an adapter with no\n * `getChildren` seam, or an anchor that is itself gone by replay time.\n */\nexport interface SiblingSlot {\n  /** Ordinal among the siblings. `-1` means \"nowhere in particular\". */\n  index: number;\n  /** Id of the sibling that followed at capture time; `null` when the node\n   *  was last. Absent when nothing observed it — `null` survives JSON and\n   *  `undefined` does not, so the two stay distinguishable across a\n   *  serialize/restore round trip. */\n  before?: string | null;\n}\n\n/** Observe `id`'s slot among `parentId`'s children. `null` when the adapter\n *  has no ordering seam or `id` isn't there — callers keep whatever weaker\n *  slot they already had rather than overwriting it with a guess. */\nexport function captureSlot(\n  a: OrderedReader,\n  parentId: string | null,\n  id: string,\n): SiblingSlot | null {\n  const siblings = a.getChildren?.(parentId);\n  if (!siblings) return null;\n  const i = siblings.indexOf(id);\n  if (i < 0) return null;\n  return { index: i, before: i + 1 < siblings.length ? siblings[i + 1]! : null };\n}\n\n/**\n * Index `slot` denotes in `siblings`, which must NOT contain the node being\n * placed. `undefined` means \"no position\" — the caller appends, or lets the\n * adapter's default placement stand.\n */\nexport function resolveSlot(\n  siblings: readonly string[] | undefined,\n  slot: SiblingSlot,\n): number | undefined {\n  if (slot.before === null) return undefined;\n  if (slot.before !== undefined && siblings) {\n    const at = siblings.indexOf(slot.before);\n    if (at >= 0) return at;\n  }\n  return slot.index >= 0 ? slot.index : undefined;\n}\n\n/** The reads that locate a live node: its parent, and that parent's children. */\nexport interface ParentedReader {\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n}\n\n/** A node's parent (`null` at the top level) and its ordinal among that\n *  parent's children — the position a replacement takes to keep its z-order. */\nexport interface ChildPosition {\n  parentId: string | null;\n  index: number;\n}\n\n/** Where `id` sits under its parent. An adapter with no `getParent` is flat,\n *  as the reorder ops read it. `null` when there is no `getChildren` or it\n *  does not list `id`. */\nexport function locateChild(a: ParentedReader, id: string): ChildPosition | null {\n  if (!a.getChildren) return null;\n  const parentId = a.getParent ? a.getParent(id) : null;\n  const index = a.getChildren(parentId).indexOf(id);\n  return index < 0 ? null : { parentId, index };\n}\n\n/** Normalize the `index` sugar every op factory accepts into a slot. */\nexport function slotFromIndex(index: number | undefined): SiblingSlot {\n  return { index: index ?? -1 };\n}\n\n/** The parent a node claims. Nodes in a flat adapter have none. */\nexport function parentOf(node: object): string | null {\n  return ((node as { parent?: unknown }).parent ?? null) as string | null;\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACA,GACA,GACoB;CACpB,IAAMC,IAAWC,EAAE,cAAcC,CAAQ;CACzC,IAAI,CAACF,GAAU,OAAO;CACtB,IAAM,IAAIA,EAAS,QAAQG,CAAE;CAE7B,OADI,IAAI,IAAU,OACX;EAAE,OAAO;EAAG,QAAQ,IAAI,IAAIH,EAAS,SAASA,EAAS,IAAI,KAAM;CAAK;AAC/E;AAOA,SAAgBI,EACd,GACA,GACoB;CACpB,IAAIC,EAAK,WAAW,MACpB;MAAIA,EAAK,WAAW,KAAA,KAAaL,GAAU;GACzC,IAAMM,IAAKN,EAAS,QAAQK,EAAK,MAAM;GACvC,IAAIC,KAAM,GAAG,OAAOA;EACtB;EACA,OAAOD,EAAK,SAAS,IAAIA,EAAK,QAAQ,KAAA;CADtC;AAEF;AAkBA,SAAgBE,EAAY,GAAmB,GAAkC;CAC/E,IAAI,CAACN,EAAE,aAAa,OAAO;CAC3B,IAAMC,IAAWD,EAAE,YAAYA,EAAE,UAAUE,CAAE,IAAI,MAC3CK,IAAQP,EAAE,YAAYC,CAAQ,CAAC,CAAC,QAAQC,CAAE;CAChD,OAAOK,IAAQ,IAAI,OAAO;EAAE;EAAU;CAAM;AAC9C;AAGA,SAAgBC,EAAc,GAAwC;CACpE,OAAO,EAAE,OAAOD,KAAS,GAAG;AAC9B;AAGA,SAAgBE,EAAS,GAA6B;CACpD,OAASC,EAA8B,UAAU;AACnD"}
+{"version":3,"file":"slot.js","names":["captureSlot","siblings","a","parentId","id","resolveSlot","slot","at","locateChild","index","slotFromIndex","parentOf","node"],"sources":["../../../src/core/ops/slot.ts"],"sourcesContent":["/** The sibling-order read: `parentId`'s children, bottom first. */\nexport interface OrderedReader {\n  getChildren(parentId: string | null): string[];\n}\n\n/**\n * A node's position among its siblings, recorded so an op can put it back.\n *\n * Recorded as an anchor (`before`) plus an ordinal (`index`). The anchor is\n * the source of truth: `History` replays a batch's inverses in reverse order,\n * so an ordinal captured before the mutation is replayed against a list that\n * has not been refilled yet and clamps to the end, while \"put this back before\n * `e`\" stays true however much else has already moved. The ordinal is the\n * fallback for the case the anchor cannot cover: an anchor that is itself\n * gone by replay time.\n */\nexport interface SiblingSlot {\n  /** Ordinal among the siblings. `-1` means \"nowhere in particular\". */\n  index: number;\n  /** Id of the sibling that followed at capture time; `null` when the node\n   *  was last. Absent when nothing observed it — `null` survives JSON and\n   *  `undefined` does not, so the two stay distinguishable across a\n   *  serialize/restore round trip. */\n  before?: string | null;\n}\n\n/** Observe `id`'s slot among `parentId`'s children. `null` when `id` isn't\n *  there — callers keep whatever weaker slot they already had rather than\n *  overwriting it with a guess. */\nexport function captureSlot(\n  a: OrderedReader,\n  parentId: string | null,\n  id: string,\n): SiblingSlot | null {\n  const siblings = a.getChildren(parentId);\n  const i = siblings.indexOf(id);\n  if (i < 0) return null;\n  return { index: i, before: i + 1 < siblings.length ? siblings[i + 1]! : null };\n}\n\n/**\n * Index `slot` denotes in `siblings`, which must NOT contain the node being\n * placed. `undefined` means \"no position\" — the caller appends, or lets the\n * adapter's default placement stand.\n */\nexport function resolveSlot(\n  siblings: readonly string[],\n  slot: SiblingSlot,\n): number | undefined {\n  if (slot.before === null) return undefined;\n  if (slot.before !== undefined) {\n    const at = siblings.indexOf(slot.before);\n    if (at >= 0) return at;\n  }\n  return slot.index >= 0 ? slot.index : undefined;\n}\n\n/** The reads that locate a live node: its parent, and that parent's children. */\nexport interface ParentedReader {\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): readonly string[];\n}\n\n/** A node's parent (`null` at the top level) and its ordinal among that\n *  parent's children — the position a replacement takes to keep its z-order. */\nexport interface ChildPosition {\n  parentId: string | null;\n  index: number;\n}\n\n/** Where `id` sits under its parent. `null` when the parent's children do\n *  not list `id`. */\nexport function locateChild(a: ParentedReader, id: string): ChildPosition | null {\n  const parentId = a.getParent(id);\n  const index = a.getChildren(parentId).indexOf(id);\n  return index < 0 ? null : { parentId, index };\n}\n\n/** Normalize the `index` sugar every op factory accepts into a slot. */\nexport function slotFromIndex(index: number | undefined): SiblingSlot {\n  return { index: index ?? -1 };\n}\n\n/** The parent a node claims; `null` for a root. */\nexport function parentOf(node: object): string | null {\n  return ((node as { parent?: unknown }).parent ?? null) as string | null;\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACA,GACA,GACoB;CACpB,IAAMC,IAAWC,EAAE,YAAYC,CAAQ,GACjC,IAAIF,EAAS,QAAQG,CAAE;CAE7B,OADI,IAAI,IAAU,OACX;EAAE,OAAO;EAAG,QAAQ,IAAI,IAAIH,EAAS,SAASA,EAAS,IAAI,KAAM;CAAK;AAC/E;AAOA,SAAgBI,EACd,GACA,GACoB;CACpB,IAAIC,EAAK,WAAW,MACpB;MAAIA,EAAK,WAAW,KAAA,GAAW;GAC7B,IAAMC,IAAKN,EAAS,QAAQK,EAAK,MAAM;GACvC,IAAIC,KAAM,GAAG,OAAOA;EACtB;EACA,OAAOD,EAAK,SAAS,IAAIA,EAAK,QAAQ,KAAA;CADtC;AAEF;AAiBA,SAAgBE,EAAY,GAAmB,GAAkC;CAC/E,IAAML,IAAWD,EAAE,UAAUE,CAAE,GACzBK,IAAQP,EAAE,YAAYC,CAAQ,CAAC,CAAC,QAAQC,CAAE;CAChD,OAAOK,IAAQ,IAAI,OAAO;EAAE;EAAU;CAAM;AAC9C;AAGA,SAAgBC,EAAc,GAAwC;CACpE,OAAO,EAAE,OAAOD,KAAS,GAAG;AAC9B;AAGA,SAAgBE,EAAS,GAA6B;CACpD,OAASC,EAA8B,UAAU;AACnD"}

package/dist/core/pages/fitViewToPage.js

@@ -0,0 +1,15 @@
+import { fitViewToBounds as e } from "../viewport/fitViewToBounds.js";
+//#region src/core/pages/fitViewToPage.ts
+function t(t, n, r, i) {
+	let { x: a, y: o, width: s, height: c } = t;
+	return e({
+		x: a,
+		y: o,
+		width: s,
+		height: c
+	}, n, r, i);
+}
+//#endregion
+export { t as fitViewToPage };
+
+//# sourceMappingURL=fitViewToPage.js.map

package/dist/core/pages/fitViewToPage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fitViewToPage.js","names":["fitViewToPage","page","fitViewToBounds","viewportDims","currentView","options"],"sources":["../../../src/core/pages/fitViewToPage.ts"],"sourcesContent":["import {\n  fitViewToBounds,\n  type FitViewToBoundsOptions,\n  type ViewportDims,\n} from '../viewport/fitViewToBounds';\nimport type { View } from '../viewport/view';\nimport type { PlacedPage } from './pages';\n\n/** The view that shows one placed page whole: `fitViewToBounds` on its rect. */\nexport function fitViewToPage(\n  page: PlacedPage,\n  viewportDims: ViewportDims,\n  currentView: View,\n  options?: FitViewToBoundsOptions,\n): View {\n  const { x, y, width, height } = page;\n  return fitViewToBounds({ x, y, width, height }, viewportDims, currentView, options);\n}\n"],"mappings":";;AASA,SAAgBA,EACd,GACA,GACA,GACA,GACM;CACN,IAAM,EAAE,MAAG,MAAG,UAAO,cAAWC;CAChC,OAAOC,EAAgB;EAAE;EAAG;EAAG;EAAO;CAAO,GAAGC,GAAcC,GAAaC,CAAO;AACpF"}

package/dist/core/pages/pages.js

@@ -0,0 +1,65 @@
+//#region src/core/pages/pages.ts
+var e = {
+	start: 0,
+	center: .5,
+	end: 1
+};
+function t(t, n = {}) {
+	let { direction: r = "row", gap: i = 40, align: a = "start", origin: o = {
+		x: 0,
+		y: 0
+	} } = n, s = r === "row", c = Math.max(0, ...t.map((e) => s ? e.height : e.width)), l = /* @__PURE__ */ new Set(), u = 0;
+	return t.map((t, n) => {
+		if (l.has(t.id)) throw Error(`layoutPages: two pages have the id "${t.id}"`);
+		l.add(t.id);
+		let r = (c - (s ? t.height : t.width)) * e[a], d = {
+			...t,
+			x: o.x + (s ? u : r),
+			y: o.y + (s ? r : u),
+			index: n
+		};
+		return u += (s ? t.width : t.height) + i, d;
+	});
+}
+function n(e, t) {
+	return i(e, {
+		x: t.x,
+		y: t.y,
+		width: 0,
+		height: 0
+	});
+}
+function r(e, t) {
+	let n = Math.min(e.x + e.width, t.x + t.width) - Math.max(e.x, t.x), r = Math.min(e.y + e.height, t.y + t.height) - Math.max(e.y, t.y);
+	return n < 0 || r < 0 ? null : n * r;
+}
+function i(e, t) {
+	let n = null, i = -1;
+	for (let a of e) {
+		let e = r(a, t);
+		e !== null && e > i && (n = a, i = e);
+	}
+	return n;
+}
+function a(e, t, n, r = {}) {
+	let i = e.length;
+	if (i === 0) return null;
+	let a = e.findIndex((e) => e.id === t);
+	if (a < 0) return e[n < 0 ? i - 1 : 0] ?? null;
+	let o = a + n;
+	return e[r.wrap ? (o % i + i) % i : o] ?? null;
+}
+function o(e) {
+	if (e.length === 0) return null;
+	let t = Math.min(...e.map((e) => e.x)), n = Math.min(...e.map((e) => e.y));
+	return {
+		x: t,
+		y: n,
+		width: Math.max(...e.map((e) => e.x + e.width)) - t,
+		height: Math.max(...e.map((e) => e.y + e.height)) - n
+	};
+}
+//#endregion
+export { a as adjacentPage, t as layoutPages, n as pageAt, i as pageOfBounds, o as pagesBounds };
+
+//# sourceMappingURL=pages.js.map

package/dist/core/pages/pages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages.js","names":["ALIGN","layoutPages","options","row","direction","across","pages","p","seen","along","page","offset","align","placed","origin","gap","pageAt","pageOfBounds","point","overlap","w","b","h","best","most","area","bounds","adjacentPage","n","at","current","step","to","pagesBounds","x","y"],"sources":["../../../src/core/pages/pages.ts"],"sourcesContent":["import type { Bounds } from '@weasel-js/routing';\n\n/** One page of a document: a sheet of a fixed size, in world units. */\nexport interface Page {\n  readonly id: string;\n  readonly name?: string;\n  readonly width: number;\n  readonly height: number;\n}\n\n/** A page and where it sits in world space. */\nexport interface PlacedPage extends Page {\n  readonly x: number;\n  readonly y: number;\n  /** Its place in the document's page order. */\n  readonly index: number;\n}\n\n/** Options for {@link layoutPages}. */\nexport interface PageLayoutOptions {\n  /** Which way the pages run. Default `'row'`. */\n  direction?: 'row' | 'column';\n  /** World units between neighbors. Default 40. */\n  gap?: number;\n  /** Where a page sits across the run, against the largest page. Default `'start'`. */\n  align?: 'start' | 'center' | 'end';\n  /** Where the first page's run starts. Default the world origin. */\n  origin?: { readonly x: number; readonly y: number };\n}\n\nconst ALIGN = { start: 0, center: 0.5, end: 1 } as const;\n\n/**\n * Place a document's pages in one world space, in order, so a single scene,\n * view, and history serve all of them. With the defaults the first page's\n * top-left corner is the world origin, where a one-page document's page is.\n * Throws on two pages with one id.\n */\nexport function layoutPages(pages: readonly Page[], options: PageLayoutOptions = {}): PlacedPage[] {\n  const { direction = 'row', gap = 40, align = 'start', origin = { x: 0, y: 0 } } = options;\n  const row = direction === 'row';\n  const across = Math.max(0, ...pages.map((p) => (row ? p.height : p.width)));\n  const seen = new Set<string>();\n  let along = 0;\n  return pages.map((page, index) => {\n    if (seen.has(page.id)) throw new Error(`layoutPages: two pages have the id \"${page.id}\"`);\n    seen.add(page.id);\n    const offset = (across - (row ? page.height : page.width)) * ALIGN[align];\n    const placed = {\n      ...page,\n      x: origin.x + (row ? along : offset),\n      y: origin.y + (row ? offset : along),\n      index,\n    };\n    along += (row ? page.width : page.height) + gap;\n    return placed;\n  });\n}\n\n/** The page under a world point, or `null` between and outside them. A point on an edge is on the page. */\nexport function pageAt(\n  pages: readonly PlacedPage[],\n  point: { readonly x: number; readonly y: number },\n): PlacedPage | null {\n  return pageOfBounds(pages, { x: point.x, y: point.y, width: 0, height: 0 });\n}\n\nfunction overlap(page: PlacedPage, b: Bounds): number | null {\n  const w = Math.min(page.x + page.width, b.x + b.width) - Math.max(page.x, b.x);\n  const h = Math.min(page.y + page.height, b.y + b.height) - Math.max(page.y, b.y);\n  return w < 0 || h < 0 ? null : w * h;\n}\n\n/**\n * The page a world-space box belongs to: the one it overlaps most, the earlier\n * of two it overlaps equally, and `null` when it touches none. This is the\n * rule that says which page an object is on.\n */\nexport function pageOfBounds(pages: readonly PlacedPage[], bounds: Bounds): PlacedPage | null {\n  let best: PlacedPage | null = null;\n  let most = -1;\n  for (const page of pages) {\n    const area = overlap(page, bounds);\n    if (area !== null && area > most) {\n      best = page;\n      most = area;\n    }\n  }\n  return best;\n}\n\n/**\n * The page `step` places along the page order from the one with id `current`:\n * the next slide is `1`, the one before is `-1`. `null` past either end, unless\n * `wrap`. With no current page in the list, a step forward starts at the first\n * page and a step back at the last.\n */\nexport function adjacentPage(\n  pages: readonly PlacedPage[],\n  current: string | null,\n  step: number,\n  options: { wrap?: boolean } = {},\n): PlacedPage | null {\n  const n = pages.length;\n  if (n === 0) return null;\n  const at = pages.findIndex((p) => p.id === current);\n  if (at < 0) return pages[step < 0 ? n - 1 : 0] ?? null;\n  const to = at + step;\n  return pages[options.wrap ? ((to % n) + n) % n : to] ?? null;\n}\n\n/** The box around every page, or `null` for a document with none. */\nexport function pagesBounds(pages: readonly PlacedPage[]): Bounds | null {\n  if (pages.length === 0) return null;\n  const x = Math.min(...pages.map((p) => p.x));\n  const y = Math.min(...pages.map((p) => p.y));\n  return {\n    x,\n    y,\n    width: Math.max(...pages.map((p) => p.x + p.width)) - x,\n    height: Math.max(...pages.map((p) => p.y + p.height)) - y,\n  };\n}\n"],"mappings":";AA8BA,IAAMA,IAAQ;CAAE,OAAO;CAAG,QAAQ;CAAK,KAAK;AAAE;AAQ9C,SAAgBC,EAAY,GAAwB,IAA6B,CAAC,GAAiB;CACjG,IAAM,EAAE,eAAY,OAAO,SAAM,IAAI,WAAQ,SAAS,YAAS;EAAE,GAAG;EAAG,GAAG;CAAE,MAAMC,GAC5EC,IAAMC,MAAc,OACpBC,IAAS,KAAK,IAAI,GAAG,GAAGC,EAAM,KAAK,MAAOH,IAAMI,EAAE,SAASA,EAAE,KAAM,CAAC,GACpEC,oBAAO,IAAI,IAAY,GACzBC,IAAQ;CACZ,OAAOH,EAAM,KAAK,GAAM,MAAU;EAChC,IAAIE,EAAK,IAAIE,EAAK,EAAE,GAAG,MAAU,MAAM,uCAAuCA,EAAK,GAAG,EAAE;EACxF,EAAK,IAAIA,EAAK,EAAE;EAChB,IAAMC,KAAUN,KAAUF,IAAMO,EAAK,SAASA,EAAK,UAAUV,EAAMY,IAC7DC,IAAS;GACb,GAAGH;GACH,GAAGI,EAAO,KAAKX,IAAMM,IAAQE;GAC7B,GAAGG,EAAO,KAAKX,IAAMQ,IAASF;GAC9B;EACF;EAEA,OADA,MAAUN,IAAMO,EAAK,QAAQA,EAAK,UAAUK,GACrCF;CACT,CAAC;AACH;AAGA,SAAgBG,EACd,GACA,GACmB;CACnB,OAAOC,EAAaX,GAAO;EAAE,GAAGY,EAAM;EAAG,GAAGA,EAAM;EAAG,OAAO;EAAG,QAAQ;CAAE,CAAC;AAC5E;AAEA,SAASC,EAAQ,GAAkB,GAA0B;CAC3D,IAAMC,IAAI,KAAK,IAAIV,EAAK,IAAIA,EAAK,OAAOW,EAAE,IAAIA,EAAE,KAAK,IAAI,KAAK,IAAIX,EAAK,GAAGW,EAAE,CAAC,GACvEC,IAAI,KAAK,IAAIZ,EAAK,IAAIA,EAAK,QAAQW,EAAE,IAAIA,EAAE,MAAM,IAAI,KAAK,IAAIX,EAAK,GAAGW,EAAE,CAAC;CAC/E,OAAOD,IAAI,KAAKE,IAAI,IAAI,OAAOF,IAAIE;AACrC;AAOA,SAAgBL,EAAa,GAA8B,GAAmC;CAC5F,IAAIM,IAA0B,MAC1BC,IAAO;CACX,KAAK,IAAMd,KAAQJ,GAAO;EACxB,IAAMmB,IAAON,EAAQT,GAAMgB,CAAM;EACjC,AAAID,MAAS,QAAQA,IAAOD,MAC1B,IAAOd,GACP,IAAOe;CAEX;CACA,OAAOF;AACT;AAQA,SAAgBI,EACd,GACA,GACA,GACA,IAA8B,CAAC,GACZ;CACnB,IAAMC,IAAItB,EAAM;CAChB,IAAIsB,MAAM,GAAG,OAAO;CACpB,IAAMC,IAAKvB,EAAM,WAAW,MAAMC,EAAE,OAAOuB,CAAO;CAClD,IAAID,IAAK,GAAG,OAAOvB,EAAMyB,IAAO,IAAIH,IAAI,IAAI,MAAM;CAClD,IAAMI,IAAKH,IAAKE;CAChB,OAAOzB,EAAMJ,EAAQ,QAAS8B,IAAKJ,IAAKA,KAAKA,IAAII,MAAO;AAC1D;AAGA,SAAgBC,EAAY,GAA6C;CACvE,IAAI3B,EAAM,WAAW,GAAG,OAAO;CAC/B,IAAM4B,IAAI,KAAK,IAAI,GAAG5B,EAAM,KAAK,MAAMC,EAAE,CAAC,CAAC,GACrC4B,IAAI,KAAK,IAAI,GAAG7B,EAAM,KAAK,MAAMC,EAAE,CAAC,CAAC;CAC3C,OAAO;EACL;EACA;EACA,OAAO,KAAK,IAAI,GAAGD,EAAM,KAAK,MAAMC,EAAE,IAAIA,EAAE,KAAK,CAAC,IAAI2B;EACtD,QAAQ,KAAK,IAAI,GAAG5B,EAAM,KAAK,MAAMC,EAAE,IAAIA,EAAE,MAAM,CAAC,IAAI4B;CAC1D;AACF"}

package/dist/core/pages/pagesLayer.js

@@ -0,0 +1,27 @@
+//#region src/core/pages/pagesLayer.ts
+function e(e, t) {
+	let { fill: n, id: r = "pages", label: i = "Pages" } = t, a = typeof n == "function" ? n : () => n;
+	return {
+		id: r,
+		label: i,
+		deps: () => [e, n],
+		draw: () => e.map((e) => ({
+			kind: "path",
+			path: {
+				kind: "rect",
+				x: e.x,
+				y: e.y,
+				width: e.width,
+				height: e.height
+			},
+			fill: { paint: {
+				kind: "solid",
+				color: a(e)
+			} }
+		}))
+	};
+}
+//#endregion
+export { e as pagesLayer };
+
+//# sourceMappingURL=pagesLayer.js.map

package/dist/core/pages/pagesLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagesLayer.js","names":["pagesLayer","options","colorOf","fill","pages","page"],"sources":["../../../src/core/pages/pagesLayer.ts"],"sourcesContent":["import type { RenderLayer } from '../layers/render';\nimport type { PlacedPage } from './pages';\n\n/** Options for {@link pagesLayer}. */\nexport interface PagesLayerOptions {\n  /** Each page's color: one for all, or one per page. */\n  fill: string | ((page: PlacedPage) => string);\n  /** Default `'pages'`. */\n  id?: string;\n  /** Default `'Pages'`. */\n  label?: string;\n}\n\n/**\n * The sheets themselves: a world-space layer that paints each placed page as a\n * filled rect, to sit under the scene. Build it again when the pages or the\n * fill change; its commands are cached on both.\n */\nexport function pagesLayer(pages: readonly PlacedPage[], options: PagesLayerOptions): RenderLayer<unknown> {\n  const { fill, id = 'pages', label = 'Pages' } = options;\n  const colorOf = typeof fill === 'function' ? fill : () => fill;\n  return {\n    id,\n    label,\n    deps: () => [pages, fill],\n    draw: () =>\n      pages.map((page) => ({\n        kind: 'path' as const,\n        path: { kind: 'rect' as const, x: page.x, y: page.y, width: page.width, height: page.height },\n        fill: { paint: { kind: 'solid' as const, color: colorOf(page) } },\n      })),\n  };\n}\n"],"mappings":";AAkBA,SAAgBA,EAAW,GAA8B,GAAkD;CACzG,IAAM,EAAE,SAAM,QAAK,SAAS,WAAQ,YAAYC,GAC1CC,IAAU,OAAOC,KAAS,aAAaA,UAAaA;CAC1D,OAAO;EACL;EACA;EACA,YAAY,CAACC,GAAOD,CAAI;EACxB,YACEC,EAAM,KAAK,OAAU;GACnB,MAAM;GACN,MAAM;IAAE,MAAM;IAAiB,GAAGC,EAAK;IAAG,GAAGA,EAAK;IAAG,OAAOA,EAAK;IAAO,QAAQA,EAAK;GAAO;GAC5F,MAAM,EAAE,OAAO;IAAE,MAAM;IAAkB,OAAOH,EAAQG,CAAI;GAAE,EAAE;EAClE,EAAE;CACN;AACF"}

package/dist/core/paint/meshKindLazy.js

@@ -591,7 +591,7 @@ const NAMED_COLORS = (() => {
 	return out;
 })();
 //#endregion
-//#region ../geom/src/mat3.ts
+//#region ../geom/src/affine.ts
 /**
 * 2D affine transforms in canvas/DOMMatrix order: [a, b, c, d, e, f].
 *   x' = a·x + c·y + e
@@ -726,7 +726,7 @@ function minScaleOf(m) {
 }
 /** The renderer's 3x3 matrix operations, as one namespace. These work on the
 *  9-element form the GL uniform upload wants — distinct from the 6-element
-*  affine `Mat3`, though the logical element order is the same. */
+*  `Affine`, though the logical element order is the same. */
 const mat3 = {
 	identity,
 	toAffine,