@weasel-js/core 1.10.0 → 1.10.1

package/dist/clipboard.d.ts

@@ -1,5 +1,5 @@
 import { NodeId } from '@weasel-js/routing';
-import { d as PasteOmission, j as ClipboardSnapshot, I as InsertAdapter } from './types-CIKDwlsP.js';
+import { d as PasteOmission, j as ClipboardSnapshot, I as InsertAdapter } from './types-DBbbCy0i.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 import './poseDescriptor-Bqk-11Rl.js';

package/dist/{clone-2a5hVbBd.d.ts → clone-C0eADtS0.d.ts}

@@ -1,4 +1,4 @@
-import { a as PlaneMap, S as SnapTarget, M as MoveAdapter } from './types-CIKDwlsP.js';
+import { a as PlaneMap, S as SnapTarget, M as MoveAdapter } from './types-DBbbCy0i.js';
 import { Op } from '@weasel-js/history';
 import { Bounds, ModifierState, View, ResizeAnchor } from '@weasel-js/routing';
 
@@ -66,6 +66,15 @@ interface GestureContext<TPose, TNode extends {
      * the gesture's poses: an insert's points, a lasso's.
      */
     frames?: GestureFrames<TPose>;
+    /**
+     * The translation that carries one pose's bounds onto another's, measured by
+     * the canvas's pose descriptor. Set by move; a behavior that knows where a
+     * node should land returns it as its `transform`.
+     */
+    offset?: (from: TPose, to: TPose) => {
+        dx: number;
+        dy: number;
+    };
     adapter: MoveAdapter<TNode, TPose>;
     /**
      * Per-gesture mutable store. Keys should be namespaced by behavior name to avoid
@@ -150,19 +159,12 @@ type GroupTransform = {
     angle: number;
 };
 /**
- * Per-frame result a `MoveBehavior.onMove` can return.
- *
- * `pose` is the legacy channel: a primary-id-only override, routed through
- * a back-compat shim that derives a `translate` transform from the pose diff
- * against `origin.get(primaryId)`. Prefer `transform`.
- *
- * `snap` announces a visual snap target.
+ * Per-frame result a `MoveBehavior.onMove` can return. `snap` announces a
+ * visual snap target.
  */
 interface BehaviorResult<TPose> {
     /** Replace the proposed transform. Applied uniformly to every id. */
     transform?: GroupTransform;
-    /** @deprecated Return `transform` instead. Legacy primary-only pose override; supported via internal shim. */
-    pose?: TPose;
     /** Preview poses for individual ids, each in its node's stored frame. For
      *  a dragged id the pose replaces the group transform this frame: a
      *  behavior that will commit its nodes where one translation cannot put
@@ -178,8 +180,6 @@ interface BehaviorResult<TPose> {
     opaque?: Iterable<string>;
     snap?: SnapTarget<TPose> | null;
 }
-/** @deprecated Renamed to `BehaviorResult`. Kept as an alias for one release cycle. */
-type BehaviorMoveResult<TPose> = BehaviorResult<TPose>;
 /** What a move behavior's `onEnd` is told. */
 interface MoveEnd extends BehaviorEnd {
     /** The action's default translate commit for the dragged roots in `ids`
@@ -379,4 +379,4 @@ type CloneBehaviorResult<TPose> = Pick<BehaviorResult<TPose>, 'transform' | 'sna
  */
 type CloneBehavior<TPose> = ActionBehavior<TPose, GroupTransform, CloneBehaviorResult<TPose>>;
 
-export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, AreaSelectOverlay as a, BehaviorEnd as b, BehaviorMoveResult as c, BehaviorResult as d, CloneBehaviorResult as e, GestureFrames as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, MoveEnd as p, PointSnapContext as q, PointSnapFrame as r, PointSnapResult as s, PointerState as t, ResizeMoveResult as u, ResizeOverlay as v, ResizeProposed as w, RotateMoveResult as x, RotateOverlay as y, RotateProposed as z };
+export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, AreaSelectOverlay as a, BehaviorEnd as b, BehaviorResult as c, CloneBehaviorResult as d, GestureFrames as e, GroupTransform as f, InsertMoveResult as g, InsertOverlay as h, InsertPoint as i, InsertProposed as j, LassoSelectMoveResult as k, LassoSelectOverlay as l, LassoSelectPose as m, LassoSelectProposed as n, MoveEnd as o, PointSnapContext as p, PointSnapFrame as q, PointSnapResult as r, PointerState as s, ResizeMoveResult as t, ResizeOverlay as u, ResizeProposed as v, RotateMoveResult as w, RotateOverlay as x, RotateProposed as y };

package/dist/clone.d.ts

@@ -1,5 +1,5 @@
-export { C as CloneBehavior, e as CloneBehaviorResult } from './clone-2a5hVbBd.js';
-import './types-CIKDwlsP.js';
+export { C as CloneBehavior, d as CloneBehaviorResult } from './clone-C0eADtS0.js';
+import './types-DBbbCy0i.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 import '@weasel-js/routing';

package/dist/core/geometry/poseDescriptor.js

@@ -1,10 +1,10 @@
 import { axisAlignedBounds as e } from "./unionBounds.js";
-import { poseLinearOf as t } from "@weasel-js/geom";
+import { multiply as t, poseLinearOf as n, rotate as r } from "@weasel-js/geom";
 //#region src/core/geometry/poseDescriptor.ts
-function n(e, t) {
+function i(e, t) {
 	return e.forNode?.(t) ?? e;
 }
-var r = {
+var a = {
 	getBounds: (e) => e,
 	remapBounds: (e, t, n) => {
 		let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height;
@@ -85,12 +85,12 @@ var r = {
 		...e,
 		rotation: t
 	})
-}, i = {
-	getBounds: r.getBounds,
-	remapBounds: r.remapBounds,
-	translate: r.translate,
-	lerp: r.lerp,
-	axes: r.axes,
+}, o = {
+	getBounds: a.getBounds,
+	remapBounds: a.remapBounds,
+	translate: a.translate,
+	lerp: a.lerp,
+	axes: a.axes,
 	fromBounds: (e) => ({
 		x: e.x,
 		y: e.y,
@@ -104,29 +104,55 @@ var r = {
 		rotation: t
 	})
 };
-function a(e, t, n) {
-	let r = t.width === 0 ? 1 : n.width / t.width, i = t.height === 0 ? 1 : n.height / t.height, a = e.rotation ?? 0, o = Math.cos(a), s = Math.sin(a), c = r * o, l = i * s, u = -r * s, d = i * o, f = e.width * Math.hypot(c, l), p = e.height * Math.hypot(u, d), m = Math.atan2(l, c), h = n.x + (e.x + e.width / 2 - t.x) * r, g = n.y + (e.y + e.height / 2 - t.y) * i;
-	return {
+function s(e, i, a) {
+	let o = i.width === 0 ? 1 : a.width / i.width, s = i.height === 0 ? 1 : a.height / i.height, c = e.rotation ?? 0, l = Math.cos(c), u = Math.sin(c), d = o * l, f = s * u, p = -o * u, m = s * l, h = Math.hypot(d, f), g = Math.hypot(p, m), _ = e.width * h, v = e.height * g, y = Math.atan2(f, d), b = a.x + (e.x + e.width / 2 - i.x) * o, x = a.y + (e.y + e.height / 2 - i.y) * s, S = {
 		...e,
-		x: h - f / 2,
-		y: g - p / 2,
-		width: f,
-		height: p,
-		rotation: m
+		x: b - _ / 2,
+		y: x - v / 2,
+		width: _,
+		height: v,
+		rotation: y
 	};
+	if (h === 0 || g === 0) return S;
+	let [C, w, T, E] = n(e) ?? [
+		1,
+		0,
+		0,
+		1
+	], [D, O, k, A] = t(t(r(-y), [
+		d,
+		f,
+		p,
+		m,
+		0,
+		0
+	]), [
+		C / h,
+		w / h,
+		T / g,
+		E / g,
+		0,
+		0
+	]);
+	return Math.abs(D - 1) < 1e-12 && Math.abs(O) < 1e-12 && Math.abs(k) < 1e-12 && Math.abs(A - 1) < 1e-12 ? delete S.transform : S.transform = [
+		D,
+		O,
+		k,
+		A
+	], S;
 }
-function o(t, n) {
-	return e(s(t, n));
+function c(t, n) {
+	return e(l(t, n));
 }
-function s(e, n) {
-	let r = n.getBounds(e), i = n.getRotation?.(e) ?? r.rotation ?? 0, a = t(e) ?? t(r);
+function l(e, t) {
+	let r = t.getBounds(e), i = t.getRotation?.(e) ?? r.rotation ?? 0, a = n(e) ?? n(r);
 	return !i && !a ? r : {
 		...r,
 		...i ? { rotation: i } : {},
 		...a ? { transform: a } : {}
 	};
 }
-function c(e, t, n, r) {
+function u(e, t, n, r) {
 	if (r.translate) return r.translate(e, t, n);
 	let i = r.getBounds(e), a = {
 		x: i.x + t,
@@ -137,6 +163,6 @@ function c(e, t, n, r) {
 	return r.remapBounds(e, i, a);
 }
 //#endregion
-export { r as RECT_POSE_DESCRIPTOR, i as ROTATED_POSE_DESCRIPTOR, s as framedBounds, n as poseDescriptorForNode, a as remapRotatedLeaf, c as translatePoseViaDescriptor, o as visualBoundsViaDescriptor };
+export { a as RECT_POSE_DESCRIPTOR, o as ROTATED_POSE_DESCRIPTOR, l as framedBounds, i as poseDescriptorForNode, s as remapRotatedLeaf, u as translatePoseViaDescriptor, c as visualBoundsViaDescriptor };
 
 //# sourceMappingURL=poseDescriptor.js.map

package/dist/core/geometry/poseDescriptor.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseDescriptor.js","names":["poseDescriptorForNode","descriptor","node","RECT_POSE_DESCRIPTOR","p","sx","src","dst","sy","b","dx","dy","a","t","like","n","pose","d","rotation","at","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","cos","sin","ux","uy","vx","vy","width","height","cxNew","cyNew","visualBoundsViaDescriptor","axisAlignedBounds","framedBounds","geometry","transform","poseLinearOf","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport { poseLinearOf } from '@weasel-js/geom';\nimport type { TargetAxes } from '@weasel-js/animator';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the kit's bounds-driven math: bounds\n * are read via `getBounds`, and `remapBounds` projects a result back into\n * TPose.\n *\n * `remapBounds(pose, src, dst)` subsumes both \"set my own AABB to dst\"\n * (single-leaf resize) and \"scale me as a leaf inside parent's src→dst rect\"\n * (group resize) — they're the same affine map.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** How a pose of `like`'s kind maps to the flat numbers an animation moves, and which of them\n   *  are angles. `from` keeps the fields of `like` that are not axes. Null for a pose this\n   *  descriptor cannot map; absent, a pose animates by its flat numeric fields. */\n  axes?(like: TPose): TargetAxes<TPose> | null;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation; the rotation affordance\n   *  hides when it is `false`. When omitted, the kit assumes `true`, so a\n   *  descriptor whose poses cannot rotate (e.g. polygon Paths) should\n   *  return `false`. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type are indistinguishable to them.\n   * Implement this to read `node.data` once and hand back a descriptor that\n   * knows which shape it is describing. Callers reach it through\n   * {@link poseDescriptorForNode}; sites with only an id keep using the\n   * unspecialized descriptor.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  axes: (like) => {\n    const flat = [like.x, like.y, like.width, like.height];\n    if (!flat.every((n) => typeof n === 'number')) return null;\n    return {\n      count: 5,\n      names: ['x', 'y', 'width', 'height', 'rotation'],\n      angles: [4],\n      to: (p) => [p.x, p.y, p.width, p.height, p.rotation ?? 0],\n      from: (a) => {\n        const pose = { ...like, x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! };\n        if (like.rotation !== undefined || a[4] !== 0) pose.rotation = a[4]!;\n        return pose;\n      },\n      add: (p, d) => {\n        const pose = { ...p, x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]! };\n        const rotation = (p.rotation ?? 0) + d[4]!;\n        if (p.rotation !== undefined || rotation !== 0) pose.rotation = rotation;\n        return pose;\n      },\n      write: (p, out, at) => {\n        out[at] = p.x;\n        out[at + 1] = p.y;\n        out[at + 2] = p.width;\n        out[at + 3] = p.height;\n        out[at + 4] = p.rotation ?? 0;\n      },\n    };\n  },\n  // `withRotation` writes into `Bounds`' optional `rotation`, so this reads\n  // the same channel, or a pose reports itself unrotated while painting rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,\n *  with a required `rotation`. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  axes: RECT_POSE_DESCRIPTOR.axes as PoseDescriptor<RotatedPose>['axes'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are expressed in the leaf's own frame. In a group\n * resize they are world-frame: at 90° a horizontal stretch should grow the\n * leaf's `height`, and the naive map grows its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model cannot represent the parallelogram\n * a non-uniform scale of a rotated box produces. The center moves exactly;\n * each local axis takes the length of its own image; the rotation follows the\n * image of the local x-axis.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n\n/** The pose's visual bounds: its box expanded to cover the box as drawn\n *  under its rotation and `transform`, so a turned or skewed shape reports\n *  the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  return axisAlignedBounds(framedBounds(pose, geometry));\n}\n\n/** The pose's box with the rotation and `transform` it is drawn in: what\n *  `poseFrameOf` reads, for a pose only its descriptor can read. */\nexport function framedBounds<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;\n  const transform = poseLinearOf(pose) ?? poseLinearOf(b);\n  if (!rotation && !transform) return b;\n  return { ...b, ...(rotation ? { rotation } : {}), ...(transform ? { transform } : {}) };\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":";;;AA6DA,SAAgBA,EACd,GACA,GAC8B;CAC9B,OAAOC,EAAW,UAAUC,CAAI,KAAKD;AACvC;AAIA,IAAaE,IAA+C;CAC1D,YAAY,MAAMC;CAClB,cAAc,GAAG,GAAK,MAAQ;EAC5B,IAAMC,IAAKC,EAAI,UAAU,IAAI,IAAIC,EAAI,QAAQD,EAAI,OAC3CE,IAAKF,EAAI,WAAW,IAAI,IAAIC,EAAI,SAASD,EAAI;EACnD,OAAO;GACL,GAAGF;GACH,GAAGG,EAAI,KAAKH,EAAE,IAAIE,EAAI,KAAKD;GAC3B,GAAGE,EAAI,KAAKH,EAAE,IAAIE,EAAI,KAAKE;GAC3B,OAAOJ,EAAE,QAAQC;GACjB,QAAQD,EAAE,SAASI;EACrB;CACF;CACA,aAAa,OAAO;EAAE,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CACvE,YAAY,GAAG,GAAI,OAAQ;EAAE,GAAGL;EAAG,GAAGA,EAAE,IAAIM;EAAI,GAAGN,EAAE,IAAIO;CAAG;CAC5D,OAAO,GAAG,GAAG,OAAO;EAClB,GAAGC;EACH,GAAGA,EAAE,KAAKH,EAAE,IAAIG,EAAE,KAAKC;EACvB,GAAGD,EAAE,KAAKH,EAAE,IAAIG,EAAE,KAAKC;EACvB,OAAOD,EAAE,SAASH,EAAE,QAAQG,EAAE,SAASC;EACvC,QAAQD,EAAE,UAAUH,EAAE,SAASG,EAAE,UAAUC;CAC7C;CACA,OAAO,MAEA;EADSC,EAAK;EAAGA,EAAK;EAAGA,EAAK;EAAOA,EAAK;CAC1C,CAAA,CAAK,OAAO,MAAM,OAAOC,KAAM,QAAQ,IACrC;EACL,OAAO;EACP,OAAO;GAAC;GAAK;GAAK;GAAS;GAAU;EAAU;EAC/C,QAAQ,CAAC,CAAC;EACV,KAAK,MAAM;GAACX,EAAE;GAAGA,EAAE;GAAGA,EAAE;GAAOA,EAAE;GAAQA,EAAE,YAAY;EAAC;EACxD,OAAO,MAAM;GACX,IAAMY,IAAO;IAAE,GAAGF;IAAM,GAAGF,EAAE;IAAK,GAAGA,EAAE;IAAK,OAAOA,EAAE;IAAK,QAAQA,EAAE;GAAI;GAExE,QADIE,EAAK,aAAa,KAAA,KAAaF,EAAE,OAAO,OAAG,EAAK,WAAWA,EAAE,KAC1DI;EACT;EACA,MAAM,GAAG,MAAM;GACb,IAAMA,IAAO;IAAE,GAAGZ;IAAG,GAAGA,EAAE,IAAIa,EAAE;IAAK,GAAGb,EAAE,IAAIa,EAAE;IAAK,OAAOb,EAAE,QAAQa,EAAE;IAAK,QAAQb,EAAE,SAASa,EAAE;GAAI,GAChGC,KAAYd,EAAE,YAAY,KAAKa,EAAE;GAEvC,QADIb,EAAE,aAAa,KAAA,KAAac,MAAa,OAAG,EAAK,WAAWA,IACzDF;EACT;EACA,QAAQ,GAAG,GAAK,MAAO;GAKrB,AAJA,EAAIG,KAAMf,EAAE,GACZ,EAAIe,IAAK,KAAKf,EAAE,GAChB,EAAIe,IAAK,KAAKf,EAAE,OAChB,EAAIe,IAAK,KAAKf,EAAE,QAChB,EAAIe,IAAK,KAAKf,EAAE,YAAY;EAC9B;CACF,IAxBsD;CA4BxD,cAAc,MAAMA,EAAE,YAAY;CAClC,eAAe,GAAG,OAAc;EAAE,GAAGA;EAAG;CAAS;AACnD,GAIagB,IAAuD;CAClE,WAAWjB,EAAqB;CAChC,aAAaA,EAAqB;CAClC,WAAWA,EAAqB;CAChC,MAAMA,EAAqB;CAC3B,MAAMA,EAAqB;CAC3B,aAAa,OAAO;EAAE,GAAGM,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;EAAQ,UAAU;CAAE;CACpF,cAAc,MAAML,EAAE;CACtB,eAAe,GAAG,OAAc;EAAE,GAAGA;EAAG;CAAS;AACnD;AAiBA,SAAgBiB,EACd,GACA,GACA,GACO;CACP,IAAMhB,IAAKC,EAAI,UAAU,IAAI,IAAIC,EAAI,QAAQD,EAAI,OAC3CE,IAAKF,EAAI,WAAW,IAAI,IAAIC,EAAI,SAASD,EAAI,QAC7CgB,IAAQN,EAAK,YAAY,GACzBO,IAAM,KAAK,IAAID,CAAK,GACpBE,IAAM,KAAK,IAAIF,CAAK,GAGpBG,IAAKpB,IAAKkB,GAAKG,IAAKlB,IAAKgB,GACzBG,IAAK,CAACtB,IAAKmB,GAAKI,IAAKpB,IAAKe,GAE1BM,IAAQb,EAAK,QAAQ,KAAK,MAAMS,GAAIC,CAAE,GACtCI,IAASd,EAAK,SAAS,KAAK,MAAMW,GAAIC,CAAE,GACxCV,IAAW,KAAK,MAAMQ,GAAID,CAAE,GAG5BM,IAAQxB,EAAI,KAAKS,EAAK,IAAIA,EAAK,QAAQ,IAAIV,EAAI,KAAKD,GACpD2B,IAAQzB,EAAI,KAAKS,EAAK,IAAIA,EAAK,SAAS,IAAIV,EAAI,KAAKE;CAE3D,OAAO;EACL,GAAGQ;EACH,GAAGe,IAAQF,IAAQ;EACnB,GAAGG,IAAQF,IAAS;EACpB;EACA;EACA;CACF;AACF;AAKA,SAAgBG,EACd,GACA,GACQ;CACR,OAAOC,EAAkBC,EAAanB,GAAMoB,CAAQ,CAAC;AACvD;AAIA,SAAgBD,EAAoB,GAAa,GAAyC;CACxF,IAAM1B,IAAI2B,EAAS,UAAUpB,CAAI,GAC3BE,IAAWkB,EAAS,cAAcpB,CAAI,KAAKP,EAAE,YAAY,GACzD4B,IAAYC,EAAatB,CAAI,KAAKsB,EAAa7B,CAAC;CAEtD,OADI,CAACS,KAAY,CAACmB,IAAkB5B,IAC7B;EAAE,GAAGA;EAAG,GAAIS,IAAW,EAAE,YAAS,IAAI,CAAC;EAAI,GAAImB,IAAY,EAAE,aAAU,IAAI,CAAC;CAAG;AACxF;AAIA,SAAgBE,EACd,GACA,GACA,GACA,GACO;CACP,IAAIH,EAAS,WAAW,OAAOA,EAAS,UAAUpB,GAAMN,GAAIC,CAAE;CAC9D,IAAML,IAAM8B,EAAS,UAAUpB,CAAI,GAC7BT,IAAM;EAAE,GAAGD,EAAI,IAAII;EAAI,GAAGJ,EAAI,IAAIK;EAAI,OAAOL,EAAI;EAAO,QAAQA,EAAI;CAAO;CACjF,OAAO8B,EAAS,YAAYpB,GAAMV,GAAKC,CAAG;AAC5C"}
+{"version":3,"file":"poseDescriptor.js","names":["poseDescriptorForNode","descriptor","node","RECT_POSE_DESCRIPTOR","p","sx","src","dst","sy","b","dx","dy","a","t","like","n","pose","d","rotation","at","ROTATED_POSE_DESCRIPTOR","remapRotatedLeaf","theta","cos","sin","ux","uy","vx","vy","kx","ky","width","height","cxNew","cyNew","next","ta","tb","tc","td","poseLinearOf","c","multiply","rotate","visualBoundsViaDescriptor","axisAlignedBounds","framedBounds","geometry","transform","translatePoseViaDescriptor"],"sources":["../../../src/core/geometry/poseDescriptor.ts"],"sourcesContent":["import type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { axisAlignedBounds } from 'core/geometry/unionBounds';\nimport { multiply, poseLinearOf, rotate } from '@weasel-js/geom';\nimport type { TargetAxes } from '@weasel-js/animator';\n\n/** `Bounds` with a required rotation angle (radians). Pivot is the AABB\n *  center of the unrotated `{x, y, width, height}`. */\nexport interface RotatedPose extends Bounds {\n  rotation: number;\n}\n\n/**\n * Bridges arbitrary `TPose` shapes into the kit's bounds-driven math: bounds\n * are read via `getBounds`, and `remapBounds` projects a result back into\n * TPose.\n *\n * `remapBounds(pose, src, dst)` subsumes both \"set my own AABB to dst\"\n * (single-leaf resize) and \"scale me as a leaf inside parent's src→dst rect\"\n * (group resize) — they're the same affine map.\n */\nexport interface PoseDescriptor<TPose, TNode = unknown> {\n  getBounds(pose: TPose): Bounds;\n  remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;\n  /** A pose occupying `bounds`, of the same kind as `template`. Unlike\n   *  `remapBounds`, the result carries none of the template's shape. */\n  fromBounds(bounds: Bounds, template: TPose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** How a pose of `like`'s kind maps to the flat numbers an animation moves, and which of them\n   *  are angles. `from` keeps the fields of `like` that are not axes. Null for a pose this\n   *  descriptor cannot map; absent, a pose animates by its flat numeric fields. */\n  axes?(like: TPose): TargetAxes<TPose> | null;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation; the rotation affordance\n   *  hides when it is `false`. When omitted, the kit assumes `true`, so a\n   *  descriptor whose poses cannot rotate (e.g. polygon Paths) should\n   *  return `false`. */\n  supportsRotation?(pose: TPose): boolean;\n  /** Write a rotation (radians) into the pose, bounds unchanged. Absent means\n   *  the pose cannot carry one, and the rotate action leaves it alone. */\n  withRotation?(pose: TPose, rotation: number): TPose;\n  /**\n   * A descriptor specialized to one node. Every other method here sees only\n   * the pose, so shapes sharing a pose type are indistinguishable to them.\n   * Implement this to read `node.data` once and hand back a descriptor that\n   * knows which shape it is describing. Callers reach it through\n   * {@link poseDescriptorForNode}; sites with only an id keep using the\n   * unspecialized descriptor.\n   */\n  forNode?(node: TNode): PoseDescriptor<TPose, TNode>;\n}\n\n/** The descriptor `node` should be read through: its own specialization when\n *  it declares one, and otherwise the descriptor unchanged. */\nexport function poseDescriptorForNode<TPose, TNode>(\n  descriptor: PoseDescriptor<TPose, TNode>,\n  node: TNode,\n): PoseDescriptor<TPose, TNode> {\n  return descriptor.forNode?.(node) ?? descriptor;\n}\n\n/** Identity geometry for `TPose extends Bounds`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n  axes: (like) => {\n    const flat = [like.x, like.y, like.width, like.height];\n    if (!flat.every((n) => typeof n === 'number')) return null;\n    return {\n      count: 5,\n      names: ['x', 'y', 'width', 'height', 'rotation'],\n      angles: [4],\n      to: (p) => [p.x, p.y, p.width, p.height, p.rotation ?? 0],\n      from: (a) => {\n        const pose = { ...like, x: a[0]!, y: a[1]!, width: a[2]!, height: a[3]! };\n        if (like.rotation !== undefined || a[4] !== 0) pose.rotation = a[4]!;\n        return pose;\n      },\n      add: (p, d) => {\n        const pose = { ...p, x: p.x + d[0]!, y: p.y + d[1]!, width: p.width + d[2]!, height: p.height + d[3]! };\n        const rotation = (p.rotation ?? 0) + d[4]!;\n        if (p.rotation !== undefined || rotation !== 0) pose.rotation = rotation;\n        return pose;\n      },\n      write: (p, out, at) => {\n        out[at] = p.x;\n        out[at + 1] = p.y;\n        out[at + 2] = p.width;\n        out[at + 3] = p.height;\n        out[at + 4] = p.rotation ?? 0;\n      },\n    };\n  },\n  // `withRotation` writes into `Bounds`' optional `rotation`, so this reads\n  // the same channel, or a pose reports itself unrotated while painting rotated.\n  getRotation: (p) => p.rotation ?? 0,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,\n *  with a required `rotation`. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseDescriptor<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseDescriptor<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseDescriptor<RotatedPose>['translate'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseDescriptor<RotatedPose>['lerp'],\n  axes: RECT_POSE_DESCRIPTOR.axes as PoseDescriptor<RotatedPose>['axes'],\n  fromBounds: (b) => ({ x: b.x, y: b.y, width: b.width, height: b.height, rotation: 0 }),\n  getRotation: (p) => p.rotation,\n  withRotation: (p, rotation) => ({ ...p, rotation }),\n};\n\n/**\n * Remap a leaf drawn in a frame of its own, turned or skewed, inside a group\n * resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are expressed in the leaf's own frame. In a group\n * resize they are world-frame: at 90° a horizontal stretch should grow the\n * leaf's `height`, and the naive map grows its `width`.\n *\n * What this computes is the group affine applied to the leaf's frame. The\n * center moves exactly; each box axis takes the length of its own image under\n * the turn; the rotation follows the image of the box's x-axis; and the\n * parallelogram a non-uniform scale makes of a turned box, which those cannot\n * hold, is written to the leaf's `transform`.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: Bounds,\n  dst: Bounds,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n  const kx = Math.hypot(ux, uy);\n  const ky = Math.hypot(vx, vy);\n\n  const width = pose.width * kx;\n  const height = pose.height * ky;\n  const rotation = Math.atan2(uy, ux);\n\n  // The center is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  const next: RotatedPose = { ...pose, x: cxNew - width / 2, y: cyNew - height / 2, width, height, rotation };\n  // A collapsed axis leaves no frame to solve for; the leaf keeps the transform it had.\n  if (kx === 0 || ky === 0) return next as TPose;\n  const [ta, tb, tc, td] = poseLinearOf(pose) ?? [1, 0, 0, 1];\n  // The linear part the leaf must draw with, less what the new box and rotation already hold.\n  const [a, b, c, d] = multiply(\n    multiply(rotate(-rotation), [ux, uy, vx, vy, 0, 0]),\n    [ta / kx, tb / kx, tc / ky, td / ky, 0, 0],\n  );\n  if (Math.abs(a - 1) < 1e-12 && Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12 && Math.abs(d - 1) < 1e-12) {\n    delete next.transform;\n  } else {\n    next.transform = [a, b, c, d];\n  }\n  return next as TPose;\n}\n\n/** The pose's visual bounds: its box expanded to cover the box as drawn\n *  under its rotation and `transform`, so a turned or skewed shape reports\n *  the extent of its ink. */\nexport function visualBoundsViaDescriptor<TPose>(\n  pose: TPose,\n  geometry: PoseDescriptor<TPose>,\n): Bounds {\n  return axisAlignedBounds(framedBounds(pose, geometry));\n}\n\n/** The pose's box with the rotation and `transform` it is drawn in: what\n *  `poseFrameOf` reads, for a pose only its descriptor can read. */\nexport function framedBounds<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds {\n  const b = geometry.getBounds(pose);\n  const rotation = geometry.getRotation?.(pose) ?? b.rotation ?? 0;\n  const transform = poseLinearOf(pose) ?? poseLinearOf(b);\n  if (!rotation && !transform) return b;\n  return { ...b, ...(rotation ? { rotation } : {}), ...(transform ? { transform } : {}) };\n}\n\n/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted\n *  copy of the pose's own bounds when the descriptor has none. */\nexport function translatePoseViaDescriptor<TPose>(\n  pose: TPose,\n  dx: number,\n  dy: number,\n  geometry: PoseDescriptor<TPose>,\n): TPose {\n  if (geometry.translate) return geometry.translate(pose, dx, dy);\n  const src = geometry.getBounds(pose);\n  const dst = { x: src.x + dx, y: src.y + dy, width: src.width, height: src.height };\n  return geometry.remapBounds(pose, src, dst);\n}\n"],"mappings":"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"}

package/dist/core/geometry/regionHit.js

@@ -88,10 +88,10 @@ function m(e, t, r, s, c, l = () => !0) {
 		s.x + s.width,
 		s.y + s.height
 	]), p = d(r);
-	if (t === "enclosed") return f ? a(e.verts, p ? r : c()) : !1;
+	if (t === "enclosed") return p && !f ? !1 : a(e.verts, p ? r : c());
 	if (e.isRect && f) return !0;
 	let m = p ? r : c();
-	return l() ? m.kind === "rect" && e.isRect ? !0 : o(e.verts, m) : o(e.verts, m, { filled: !1 });
+	return l() ? m.kind === "rect" && e.isRect ? m.x < u.x + u.width && m.x + m.width > u.x && m.y < u.y + u.height && m.y + m.height > u.y : o(e.verts, m) : o(e.verts, m, { filled: !1 });
 }
 //#endregion
 export { d as isSilhouettePose, u as polygonRegion, p as poseOutline, c as rectRegion, f as regionBoundsOf, l as regionOf, m as regionTakes };

package/dist/core/geometry/regionHit.js.map

@@ -1 +1 @@
-{"version":3,"file":"regionHit.js","names":["rectRegion","w","h","r","regionOf","x","y","verts","flat","minX","minY","maxX","maxY","i","coords","bounds","polygonRegion","polygon","p","isSilhouettePose","pose","regionBoundsOf","nodeMemo","node","g","visualBoundsViaDescriptor","poseOutline","poseFrameOf","pathThroughPoseFrame","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","drawn","filled","polygonIntersectsPath"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision the\n * scene's area walk (`canvas/deps/hitTestArea`) makes.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { pathThroughPoseFrame, poseFrameOf } from '@weasel-js/geom';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './poseDescriptor';\n\n/** A closed selection area: a marquee rect or a lasso polygon. */\nexport interface SelectRegion {\n  /** The area's vertices; the closing edge back to the first is implicit. */\n  readonly verts: readonly Vec2[];\n  /** `verts` interleaved as `[x0, y0, x1, y1, …]`. */\n  readonly coords: readonly number[];\n  readonly bounds: Bounds;\n  /** True when the area is its own bounding rect, so a node inside `bounds`\n   *  is inside the area without further work. Never true for a lasso: a node\n   *  inside the hull's box can still miss the hull. */\n  readonly isRect: boolean;\n}\n\n/** A marquee's region. */\nexport function rectRegion(r: Bounds): SelectRegion {\n  const { x, y, width: w, height: h } = r;\n  return regionOf([x, y, x + w, y, x + w, y + h, x, y + h], { x, y, width: w, height: h }, true)!;\n}\n\n/** A region from interleaved coords. `bounds` is derived when omitted; `null`\n *  when there are no coords to bound. */\nexport function regionOf(\n  coords: ArrayLike<number>,\n  bounds?: Bounds,\n  isRect = false,\n): SelectRegion | null {\n  const verts: Vec2[] = [];\n  const flat: number[] = [];\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    verts.push({ x, y });\n    flat.push(x, y);\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  if (verts.length === 0) return null;\n  return {\n    verts,\n    coords: flat,\n    bounds: bounds ?? { x: minX, y: minY, width: maxX - minX, height: maxY - minY },\n    isRect,\n  };\n}\n\n/** A lasso's region, or `null` for fewer than three vertices. */\nexport function polygonRegion(polygon: ReadonlyArray<Vec2>): SelectRegion | null {\n  if (polygon.length < 3) return null;\n  const coords: number[] = [];\n  for (const p of polygon) coords.push(p.x, p.y);\n  return regionOf(coords);\n}\n\n/** A pose that is its own drawn outline. */\nexport function isSilhouettePose(pose: unknown): pose is PolygonPath {\n  return pose !== null && typeof pose === 'object' && (pose as Path).kind === 'polygon';\n}\n\n/**\n * The box a region fast-rejects a node against: a silhouette pose's own bounds,\n * else the pose's visual bounds — which for a rotated pose is the box of its\n * rotated ink, reaching past the pose box. `g` is the node's descriptor.\n */\nexport function regionBoundsOf(node: object, pose: unknown, g: PoseDescriptor<unknown>): Bounds {\n  // Memo is silhouettes-only: a rect pose's bounds are the pose itself, and\n  // memoizing it costs more than it saves. The result may be shared; never mutate it.\n  return isSilhouettePose(pose)\n    ? nodeMemo(node, 'aabb', pose, () => g.getBounds(pose))\n    : visualBoundsViaDescriptor(pose, g);\n}\n\n/** The outline of a node nothing paints: its pose rect through the pose's\n *  frame, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  if (poseFrameOf(pose)) {\n    const p = pose as Bounds;\n    return pathThroughPoseFrame({ kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height }, pose);\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere: its interior too,\n *   unless `filled` says nothing paints it.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n  filled: () => boolean = () => true,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A node sticking out of the region's box cannot be inside the region.\n    if (!inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  const drawn = silhouette ? pose : outline();\n  if (!filled()) return polygonIntersectsPath(region.verts, drawn, { filled: false });\n  // An axis-aligned rect overlapping a marquee's box already meets it.\n  if (drawn.kind === 'rect' && region.isRect) return true;\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":"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"}
+{"version":3,"file":"regionHit.js","names":["rectRegion","w","h","r","regionOf","x","y","verts","flat","minX","minY","maxX","maxY","i","coords","bounds","polygonRegion","polygon","p","isSilhouettePose","pose","regionBoundsOf","nodeMemo","node","g","visualBoundsViaDescriptor","poseOutline","poseFrameOf","pathThroughPoseFrame","b","regionTakes","ab","region","mode","pointInPolygon","inBox","boxContainsBox","silhouette","polygonContainsPath","outline","drawn","filled","polygonIntersectsPath"],"sources":["../../../src/core/geometry/regionHit.ts"],"sourcesContent":["/**\n * Whether a marquee or a lasso takes one node: the per-node decision the\n * scene's area walk (`canvas/deps/hitTestArea`) makes.\n *\n * What a node draws is not knowable here — the painters sit above `core/` — so\n * the caller hands in the node's outline as a thunk, asked for only when the\n * bounds cannot decide. A pose that is itself a polygon path is its own\n * outline and never asks.\n */\nimport {\n  boxContainsBox,\n  pointInPolygon,\n  polygonContainsPath,\n  polygonIntersectsPath,\n  type Path,\n  type PolygonPath,\n} from '@weasel-js/geom';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { Vec2 } from './vec2';\nimport { pathThroughPoseFrame, poseFrameOf } from '@weasel-js/geom';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './poseDescriptor';\n\n/** A closed selection area: a marquee rect or a lasso polygon. */\nexport interface SelectRegion {\n  /** The area's vertices; the closing edge back to the first is implicit. */\n  readonly verts: readonly Vec2[];\n  /** `verts` interleaved as `[x0, y0, x1, y1, …]`. */\n  readonly coords: readonly number[];\n  readonly bounds: Bounds;\n  /** True when the area is its own bounding rect, so a node inside `bounds`\n   *  is inside the area without further work. Never true for a lasso: a node\n   *  inside the hull's box can still miss the hull. */\n  readonly isRect: boolean;\n}\n\n/** A marquee's region. */\nexport function rectRegion(r: Bounds): SelectRegion {\n  const { x, y, width: w, height: h } = r;\n  return regionOf([x, y, x + w, y, x + w, y + h, x, y + h], { x, y, width: w, height: h }, true)!;\n}\n\n/** A region from interleaved coords. `bounds` is derived when omitted; `null`\n *  when there are no coords to bound. */\nexport function regionOf(\n  coords: ArrayLike<number>,\n  bounds?: Bounds,\n  isRect = false,\n): SelectRegion | null {\n  const verts: Vec2[] = [];\n  const flat: number[] = [];\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i + 1 < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    verts.push({ x, y });\n    flat.push(x, y);\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  }\n  if (verts.length === 0) return null;\n  return {\n    verts,\n    coords: flat,\n    bounds: bounds ?? { x: minX, y: minY, width: maxX - minX, height: maxY - minY },\n    isRect,\n  };\n}\n\n/** A lasso's region, or `null` for fewer than three vertices. */\nexport function polygonRegion(polygon: ReadonlyArray<Vec2>): SelectRegion | null {\n  if (polygon.length < 3) return null;\n  const coords: number[] = [];\n  for (const p of polygon) coords.push(p.x, p.y);\n  return regionOf(coords);\n}\n\n/** A pose that is its own drawn outline. */\nexport function isSilhouettePose(pose: unknown): pose is PolygonPath {\n  return pose !== null && typeof pose === 'object' && (pose as Path).kind === 'polygon';\n}\n\n/**\n * The box a region fast-rejects a node against: a silhouette pose's own bounds,\n * else the pose's visual bounds — which for a rotated pose is the box of its\n * rotated ink, reaching past the pose box. `g` is the node's descriptor.\n */\nexport function regionBoundsOf(node: object, pose: unknown, g: PoseDescriptor<unknown>): Bounds {\n  // Memo is silhouettes-only: a rect pose's bounds are the pose itself, and\n  // memoizing it costs more than it saves. The result may be shared; never mutate it.\n  return isSilhouettePose(pose)\n    ? nodeMemo(node, 'aabb', pose, () => g.getBounds(pose))\n    : visualBoundsViaDescriptor(pose, g);\n}\n\n/** The outline of a node nothing paints: its pose rect through the pose's\n *  frame, else its visual bounds `b`. */\nexport function poseOutline(pose: unknown, b: Bounds): Path {\n  if (poseFrameOf(pose)) {\n    const p = pose as Bounds;\n    return pathThroughPoseFrame({ kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height }, pose);\n  }\n  return { kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height };\n}\n\n/**\n * Whether `region` takes a node under `mode`, given its pose, its bounds `b`\n * from {@link regionBoundsOf}, and its drawn outline on demand.\n *\n * - `intersect` — the outline meets the region anywhere: its interior too,\n *   unless `filled` says nothing paints it.\n * - `enclosed` — the whole outline lies inside it.\n * - `centers` — the center of `b` lies inside it.\n *\n * `b` only rejects: it encloses the outline and may reach past it, so a node\n * is taken by the outline alone. A node without finite bounds is never taken.\n */\nexport function regionTakes(\n  region: SelectRegion,\n  mode: LassoHitMode,\n  pose: unknown,\n  b: Bounds,\n  outline: () => Path,\n  filled: () => boolean = () => true,\n): boolean {\n  if (\n    !Number.isFinite(b.x) || !Number.isFinite(b.y) ||\n    !Number.isFinite(b.width) || !Number.isFinite(b.height)\n  ) {\n    return false;\n  }\n  const ab = region.bounds;\n  if (\n    b.x >= ab.x + ab.width || b.x + b.width <= ab.x ||\n    b.y >= ab.y + ab.height || b.y + b.height <= ab.y\n  ) {\n    return false;\n  }\n  if (mode === 'centers') {\n    return pointInPolygon(region.coords, b.x + b.width / 2, b.y + b.height / 2);\n  }\n  const inBox = boxContainsBox(\n    [ab.x, ab.y, ab.x + ab.width, ab.y + ab.height],\n    [b.x, b.y, b.x + b.width, b.y + b.height],\n  );\n  const silhouette = isSilhouettePose(pose);\n  if (mode === 'enclosed') {\n    // A silhouette pose's bounds are its outline's: sticking out of the\n    // region's box, it cannot be inside the region.\n    if (silhouette && !inBox) return false;\n    return polygonContainsPath(region.verts, silhouette ? pose : outline());\n  }\n  // Swallowed whole by a marquee: no outline can change the answer.\n  if (region.isRect && inBox) return true;\n  const drawn = silhouette ? pose : outline();\n  if (!filled()) return polygonIntersectsPath(region.verts, drawn, { filled: false });\n  // Two axis-aligned rects meet exactly when their boxes overlap.\n  if (drawn.kind === 'rect' && region.isRect) {\n    return (\n      drawn.x < ab.x + ab.width && drawn.x + drawn.width > ab.x &&\n      drawn.y < ab.y + ab.height && drawn.y + drawn.height > ab.y\n    );\n  }\n  return polygonIntersectsPath(region.verts, drawn);\n}\n"],"mappings":"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"}

package/dist/core/geometry/targetFrame.js.map

@@ -1 +1 @@
-{"version":3,"file":"targetFrame.js","names":["IDENTITY","IDENTITY_TARGET","targetTransformOf","toWorld","poseFrameOf","bounds","invert","angleOf","xf","isRigid","a","b","c","d","localToWorld","lx","ly","x","y","applyToPoint","worldToLocal","wx","wy","worldDeltaToLocal","dx","dy","m","normalToWorld","n","k","pxExtentIn","ux","scale","uy","vx","vy","det","px","targetCorners"],"sources":["../../../src/core/geometry/targetFrame.ts"],"sourcesContent":["/**\n * The frame selection chrome reads a target in: `poseFrameOf` over the\n * target's bounds, with the helpers the outline, the handles, their hit\n * regions, and the resize and rotate actions all place themselves by.\n */\nimport { applyToPoint, invert, poseFrameOf, type Mat3, type Scale2 } from '@weasel-js/geom';\n\n/** Local↔world maps for a chrome target. Local is the target's unrotated box\n *  frame; world is where the node is drawn. */\nexport interface TargetTransform {\n  /** No rotation and no `transform`: local is world. */\n  identity: boolean;\n  /** Target box frame → world. */\n  toWorld: Mat3;\n  /** World → target box frame. `null` when the target's `transform` is\n   *  singular: it draws nothing, and no world point maps back. */\n  toLocal: Mat3 | null;\n}\n\nconst IDENTITY: Mat3 = [1, 0, 0, 1, 0, 0];\n\nexport const IDENTITY_TARGET: TargetTransform = { identity: true, toWorld: IDENTITY, toLocal: IDENTITY };\n\n/** The frame `bounds` is drawn in: its `rotation`, its `transform`, or both. */\nexport function targetTransformOf(bounds: unknown): TargetTransform {\n  const toWorld = poseFrameOf(bounds);\n  if (!toWorld) return IDENTITY_TARGET;\n  return { identity: false, toWorld, toLocal: invert(toWorld) };\n}\n\n/** How far the target's x axis is turned from world's, radians. */\nexport function angleOf(xf: TargetTransform): number {\n  return xf.identity ? 0 : Math.atan2(xf.toWorld[1], xf.toWorld[0]);\n}\n\n/** Whether the frame only turns the target: no skew, no stretch, no flip. */\nexport function isRigid(xf: TargetTransform): boolean {\n  if (xf.identity) return true;\n  const [a, b, c, d] = xf.toWorld;\n  return Math.abs(a - d) < 1e-9 && Math.abs(b + c) < 1e-9 && Math.abs(a * a + b * b - 1) < 1e-9;\n}\n\n/** local point → world point. */\nexport function localToWorld(xf: TargetTransform, lx: number, ly: number): { x: number; y: number } {\n  if (xf.identity) return { x: lx, y: ly };\n  const [x, y] = applyToPoint(xf.toWorld, lx, ly);\n  return { x, y };\n}\n\n/** world point → local point; `null` where nothing maps back. */\nexport function worldToLocal(xf: TargetTransform, wx: number, wy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: wx, y: wy };\n  if (!xf.toLocal) return null;\n  const [x, y] = applyToPoint(xf.toLocal, wx, wy);\n  return { x, y };\n}\n\n/** A world delta in the target's own axes; `null` where nothing maps back. */\nexport function worldDeltaToLocal(xf: TargetTransform, dx: number, dy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: dx, y: dy };\n  const m = xf.toLocal;\n  return m && { x: m[0] * dx + m[2] * dy, y: m[1] * dx + m[3] * dy };\n}\n\n/** A local edge's outward normal as a world direction, unnormalized. A normal\n *  goes through the inverse transpose, so it stays square to a skewed edge. */\nexport function normalToWorld(xf: TargetTransform, n: { x: number; y: number }): { x: number; y: number } {\n  if (xf.identity) return n;\n  const [a, b, c, d] = xf.toWorld;\n  const k = Math.sign(a * d - b * c) || 1;\n  return { x: (d * n.x - b * n.y) * k, y: (a * n.y - c * n.x) * k };\n}\n\n/** `pxExtent` along the target's own axes: how far along each an edge across\n *  it must move to move `px` on screen. */\nexport function pxExtentIn(px: number, scale: Scale2, xf: TargetTransform): { x: number; y: number } {\n  const [a, b, c, d] = xf.toWorld;\n  const ux = a * scale.x, uy = b * scale.y;\n  const vx = c * scale.x, vy = d * scale.y;\n  const det = Math.abs(ux * vy - uy * vx);\n  if (det === 0) return { x: 0, y: 0 };\n  return { x: (px * Math.hypot(vx, vy)) / det, y: (px * Math.hypot(ux, uy)) / det };\n}\n\n/** The target's box corners in world, TL/TR/BR/BL. */\nexport function targetCorners(\n  b: { x: number; y: number; width: number; height: number },\n  xf: TargetTransform,\n): { x: number; y: number }[] {\n  return [\n    localToWorld(xf, b.x, b.y),\n    localToWorld(xf, b.x + b.width, b.y),\n    localToWorld(xf, b.x + b.width, b.y + b.height),\n    localToWorld(xf, b.x, b.y + b.height),\n  ];\n}\n"],"mappings":"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"}
+{"version":3,"file":"targetFrame.js","names":["IDENTITY","IDENTITY_TARGET","targetTransformOf","toWorld","poseFrameOf","bounds","invert","angleOf","xf","isRigid","a","b","c","d","localToWorld","lx","ly","x","y","applyToPoint","worldToLocal","wx","wy","worldDeltaToLocal","dx","dy","m","normalToWorld","n","k","pxExtentIn","ux","scale","uy","vx","vy","det","px","targetCorners"],"sources":["../../../src/core/geometry/targetFrame.ts"],"sourcesContent":["/**\n * The frame selection chrome reads a target in: `poseFrameOf` over the\n * target's bounds, with the helpers the outline, the handles, their hit\n * regions, and the resize and rotate actions all place themselves by.\n */\nimport { applyToPoint, invert, poseFrameOf, type Affine, type Scale2 } from '@weasel-js/geom';\n\n/** Local↔world maps for a chrome target. Local is the target's unrotated box\n *  frame; world is where the node is drawn. */\nexport interface TargetTransform {\n  /** No rotation and no `transform`: local is world. */\n  identity: boolean;\n  /** Target box frame → world. */\n  toWorld: Affine;\n  /** World → target box frame. `null` when the target's `transform` is\n   *  singular: it draws nothing, and no world point maps back. */\n  toLocal: Affine | null;\n}\n\nconst IDENTITY: Affine = [1, 0, 0, 1, 0, 0];\n\nexport const IDENTITY_TARGET: TargetTransform = { identity: true, toWorld: IDENTITY, toLocal: IDENTITY };\n\n/** The frame `bounds` is drawn in: its `rotation`, its `transform`, or both. */\nexport function targetTransformOf(bounds: unknown): TargetTransform {\n  const toWorld = poseFrameOf(bounds);\n  if (!toWorld) return IDENTITY_TARGET;\n  return { identity: false, toWorld, toLocal: invert(toWorld) };\n}\n\n/** How far the target's x axis is turned from world's, radians. */\nexport function angleOf(xf: TargetTransform): number {\n  return xf.identity ? 0 : Math.atan2(xf.toWorld[1], xf.toWorld[0]);\n}\n\n/** Whether the frame only turns the target: no skew, no stretch, no flip. */\nexport function isRigid(xf: TargetTransform): boolean {\n  if (xf.identity) return true;\n  const [a, b, c, d] = xf.toWorld;\n  return Math.abs(a - d) < 1e-9 && Math.abs(b + c) < 1e-9 && Math.abs(a * a + b * b - 1) < 1e-9;\n}\n\n/** local point → world point. */\nexport function localToWorld(xf: TargetTransform, lx: number, ly: number): { x: number; y: number } {\n  if (xf.identity) return { x: lx, y: ly };\n  const [x, y] = applyToPoint(xf.toWorld, lx, ly);\n  return { x, y };\n}\n\n/** world point → local point; `null` where nothing maps back. */\nexport function worldToLocal(xf: TargetTransform, wx: number, wy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: wx, y: wy };\n  if (!xf.toLocal) return null;\n  const [x, y] = applyToPoint(xf.toLocal, wx, wy);\n  return { x, y };\n}\n\n/** A world delta in the target's own axes; `null` where nothing maps back. */\nexport function worldDeltaToLocal(xf: TargetTransform, dx: number, dy: number): { x: number; y: number } | null {\n  if (xf.identity) return { x: dx, y: dy };\n  const m = xf.toLocal;\n  return m && { x: m[0] * dx + m[2] * dy, y: m[1] * dx + m[3] * dy };\n}\n\n/** A local edge's outward normal as a world direction, unnormalized. A normal\n *  goes through the inverse transpose, so it stays square to a skewed edge. */\nexport function normalToWorld(xf: TargetTransform, n: { x: number; y: number }): { x: number; y: number } {\n  if (xf.identity) return n;\n  const [a, b, c, d] = xf.toWorld;\n  const k = Math.sign(a * d - b * c) || 1;\n  return { x: (d * n.x - b * n.y) * k, y: (a * n.y - c * n.x) * k };\n}\n\n/** `pxExtent` along the target's own axes: how far along each an edge across\n *  it must move to move `px` on screen. */\nexport function pxExtentIn(px: number, scale: Scale2, xf: TargetTransform): { x: number; y: number } {\n  const [a, b, c, d] = xf.toWorld;\n  const ux = a * scale.x, uy = b * scale.y;\n  const vx = c * scale.x, vy = d * scale.y;\n  const det = Math.abs(ux * vy - uy * vx);\n  if (det === 0) return { x: 0, y: 0 };\n  return { x: (px * Math.hypot(vx, vy)) / det, y: (px * Math.hypot(ux, uy)) / det };\n}\n\n/** The target's box corners in world, TL/TR/BR/BL. */\nexport function targetCorners(\n  b: { x: number; y: number; width: number; height: number },\n  xf: TargetTransform,\n): { x: number; y: number }[] {\n  return [\n    localToWorld(xf, b.x, b.y),\n    localToWorld(xf, b.x + b.width, b.y),\n    localToWorld(xf, b.x + b.width, b.y + b.height),\n    localToWorld(xf, b.x, b.y + b.height),\n  ];\n}\n"],"mappings":"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"}

package/dist/core/layers/children.js

@@ -6,9 +6,7 @@ function e(e) {
 		defaultVisible: e.defaultVisible,
 		alwaysOn: e.alwaysOn,
 		draw: (t, n) => {
-			let r = e.adapter.getChildren;
-			if (!r) return [];
-			let i = r(typeof e.parentId == "function" ? e.parentId() : e.parentId ?? null), a = [];
+			let r = typeof e.parentId == "function" ? e.parentId() : e.parentId ?? null, i = e.adapter.getChildren(r), a = [];
 			for (let r of i) {
 				let i = e.drawChild(r, t, n);
 				for (let e of i) a.push(e);

package/dist/core/layers/children.js.map

@@ -1 +1 @@
-{"version":3,"file":"children.js","names":["createChildrenLayer","opts","getChildren","ids","out","id","sub","data","view","cmd"],"sources":["../../../src/core/layers/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer: a `RenderLayer` factory over an `OrderedAdapter`.\n * Children are drawn in z-order (index 0 = bottom). If the adapter doesn't\n * implement `getChildren`, the layer is a silent no-op.\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const getChildren = opts.adapter.getChildren;\n      if (!getChildren) return [];\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AAgCA,SAAgBA,EACd,GACoB;CACpB,OAAO;EACL,IAAIC,EAAK,MAAM;EACf,OAAOA,EAAK,SAAS;EACrB,gBAAgBA,EAAK;EACrB,UAAUA,EAAK;EACf,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAcD,EAAK,QAAQ;GACjC,IAAI,CAACC,GAAa,OAAO,CAAC;GAK1B,IAAMC,IAAMD,EAHV,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,IACO,GACxBG,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAMF,GAAK;IACpB,IAAMG,IAAML,EAAK,UAAUI,GAAIE,GAAMC,CAAI;IACzC,KAAK,IAAMC,KAAOH,GAAK,EAAI,KAAKG,CAAG;GACrC;GACA,OAAOL;EACT;CACF;AACF"}
+{"version":3,"file":"children.js","names":["createChildrenLayer","opts","parent","ids","out","id","sub","data","view","cmd"],"sources":["../../../src/core/layers/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer: a `RenderLayer` factory over an `OrderedAdapter`.\n * Children are drawn in z-order (index 0 = bottom).\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = opts.adapter.getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AA+BA,SAAgBA,EACd,GACoB;CACpB,OAAO;EACL,IAAIC,EAAK,MAAM;EACf,OAAOA,EAAK,SAAS;EACrB,gBAAgBA,EAAK;EACrB,UAAUA,EAAK;EACf,OAAO,GAAM,MAAS;GACpB,IAAMC,IACJ,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,MACjBE,IAAMF,EAAK,QAAQ,YAAYC,CAAM,GACrCE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAMF,GAAK;IACpB,IAAMG,IAAML,EAAK,UAAUI,GAAIE,GAAMC,CAAI;IACzC,KAAK,IAAMC,KAAOH,GAAK,EAAI,KAAKG,CAAG;GACrC;GACA,OAAOL;EACT;CACF;AACF"}

package/dist/core/ops/create.js

@@ -15,10 +15,10 @@ function a(e) {
 		label: o,
 		apply(e) {
 			let r = e, i = () => {
-				r.insertNode(a, n(r.getChildren?.(t(a)), c));
+				r.insertNode(a, n(r.getChildren(t(a)), c));
 			};
 			if (!s || s.length === 0) return i();
-			for (let e of s) r.getNode?.(e.node.id) || (e.node.id === a.id ? i() : r.insertNode(e.node, e.index));
+			for (let e of s) r.getNode(e.node.id) || (e.node.id === a.id ? i() : r.insertNode(e.node, e.index));
 		},
 		invert() {
 			return i({

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

@@ -1 +1 @@
-{"version":3,"file":"create.js","names":["createInsertOp","args","slot","slotFromIndex","cascaded","a","adapter","insertRoot","node","resolveSlot","parentOf","entry","createDeleteOp","registerOpFactory"],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp, type PlacedNode } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  getNode?(id: string): TNode | undefined;\n  /** When `index` is supplied, insert at that position; adapters that ignore\n   *  the second arg (or don't expose it) fall back to their default\n   *  placement (typically append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n  /** Every node to insert, `node` itself included, each at its ordinal among\n   *  its own parent's children and ordered so a parent precedes its children.\n   *  What a delete's `cascaded` captures, and how its inverse brings the whole\n   *  set back; `node` still goes in at `slot`. One already present is skipped. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete\n *  of `node`. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label, cascaded } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot, ...(cascaded ? { cascaded } : {}) },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const insertRoot = (): void => {\n        a.insertNode(node, resolveSlot(a.getChildren?.(parentOf(node)), slot));\n      };\n      if (!cascaded || cascaded.length === 0) return insertRoot();\n      for (const entry of cascaded) {\n        // A flat adapter's removeNode doesn't cascade, so its children\n        // were never gone — re-inserting them would duplicate them.\n        if (a.getNode?.(entry.node.id)) continue;\n        if (entry.node.id === node.id) insertRoot();\n        else a.insertNode(entry.node, entry.index);\n      }\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot, ...(cascaded ? { cascaded } : {}) });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;AAoCA,SAAgBA,EAA6C,GAAmC;CAC9F,IAAM,EAAE,SAAM,UAAO,gBAAaC,GAC5BC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;GAAM,GAAIG,IAAW,EAAE,YAAS,IAAI,CAAC;EAAG;EAC7D;EACA,MAAM,GAAS;GACb,IAAMC,IAAIC,GACJC,UAAyB;IAC7B,EAAE,WAAWC,GAAMC,EAAYJ,EAAE,cAAcK,EAASF,CAAI,CAAC,GAAGN,CAAI,CAAC;GACvE;GACA,IAAI,CAACE,KAAYA,EAAS,WAAW,GAAG,OAAOG,EAAW;GAC1D,KAAK,IAAMI,KAASP,GAGlB,AAAIC,EAAE,UAAUM,EAAM,KAAK,EAAE,MACzBA,EAAM,KAAK,OAAOH,EAAK,KAAID,EAAW,IACrCF,EAAE,WAAWM,EAAM,MAAMA,EAAM,KAAK;EAE7C;EACA,SAAS;GACP,OAAOC,EAAe;IAAE;IAAM;IAAO;IAAM,GAAIR,IAAW,EAAE,YAAS,IAAI,CAAC;GAAG,CAAC;EAChF;CACF;AACF;AAEAS,EAA8C,WAAW,MAASb,EAAeC,CAAI,CAAC"}
+{"version":3,"file":"create.js","names":["createInsertOp","args","slot","slotFromIndex","cascaded","a","adapter","insertRoot","node","resolveSlot","parentOf","entry","createDeleteOp","registerOpFactory"],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp, type PlacedNode } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  getNode(id: string): TNode | undefined;\n  /** When `index` is supplied, insert at that position; an adapter that\n   *  ignores the second arg falls back to its default placement (typically\n   *  append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n  /** Every node to insert, `node` itself included, each at its ordinal among\n   *  its own parent's children and ordered so a parent precedes its children.\n   *  What a delete's `cascaded` captures, and how its inverse brings the whole\n   *  set back; `node` still goes in at `slot`. One already present is skipped. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** Op: insert `node`, and the rest of `cascaded` with it; inverts to a delete\n *  of `node`. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label, cascaded } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot, ...(cascaded ? { cascaded } : {}) },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const insertRoot = (): void => {\n        a.insertNode(node, resolveSlot(a.getChildren(parentOf(node)), slot));\n      };\n      if (!cascaded || cascaded.length === 0) return insertRoot();\n      for (const entry of cascaded) {\n        // An adapter whose removeNode doesn't cascade never lost the\n        // children — re-inserting them would duplicate them.\n        if (a.getNode(entry.node.id)) continue;\n        if (entry.node.id === node.id) insertRoot();\n        else a.insertNode(entry.node, entry.index);\n      }\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot, ...(cascaded ? { cascaded } : {}) });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;AAoCA,SAAgBA,EAA6C,GAAmC;CAC9F,IAAM,EAAE,SAAM,UAAO,gBAAaC,GAC5BC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;GAAM,GAAIG,IAAW,EAAE,YAAS,IAAI,CAAC;EAAG;EAC7D;EACA,MAAM,GAAS;GACb,IAAMC,IAAIC,GACJC,UAAyB;IAC7B,EAAE,WAAWC,GAAMC,EAAYJ,EAAE,YAAYK,EAASF,CAAI,CAAC,GAAGN,CAAI,CAAC;GACrE;GACA,IAAI,CAACE,KAAYA,EAAS,WAAW,GAAG,OAAOG,EAAW;GAC1D,KAAK,IAAMI,KAASP,GAGlB,AAAIC,EAAE,QAAQM,EAAM,KAAK,EAAE,MACvBA,EAAM,KAAK,OAAOH,EAAK,KAAID,EAAW,IACrCF,EAAE,WAAWM,EAAM,MAAMA,EAAM,KAAK;EAE7C;EACA,SAAS;GACP,OAAOC,EAAe;IAAE;IAAM;IAAO;IAAM,GAAIR,IAAW,EAAE,YAAS,IAAI,CAAC;GAAG,CAAC;EAChF;CACF;AACF;AAEAS,EAA8C,WAAW,MAASb,EAAeC,CAAI,CAAC"}

package/dist/core/ops/delete.js

@@ -3,45 +3,43 @@ import { captureSlot as t, parentOf as n, slotFromIndex as r } from "./slot.js";
 import { createInsertOp as i } from "./create.js";
 //#region src/core/ops/delete.ts
 function a(e, t, n) {
-	return e.getChildren?.(t)?.indexOf(n) ?? -1;
+	return e.getChildren(t).indexOf(n);
 }
 function o(e, t) {
-	let { getChildren: r, getNode: i } = e;
-	if (!r || !i) return null;
-	let o = e.getRemovalClosure?.([t]), s = /* @__PURE__ */ new Map();
-	if (o) for (let t of o) {
-		let n = i.call(e, t);
-		n && s.set(t, n);
+	let r = e.getRemovalClosure?.([t]), i = /* @__PURE__ */ new Map();
+	if (r) for (let t of r) {
+		let n = e.getNode(t);
+		n && i.set(t, n);
 	}
 	else {
 		let n = (t) => {
-			let a = i.call(e, t);
-			if (a) {
-				s.set(t, a);
-				for (let i of r.call(e, t)) n(i);
+			let r = e.getNode(t);
+			if (r) {
+				i.set(t, r);
+				for (let r of e.getChildren(t)) n(r);
 			}
 		};
 		n(t);
 	}
-	let c = [...s.values()].filter((e) => {
+	let o = [...i.values()].filter((e) => {
 		let t = n(e);
-		return t === null || !s.has(t);
+		return t === null || !i.has(t);
 	}).map((t) => ({
 		node: t,
 		index: a(e, n(t), t.id)
-	})).sort((e, t) => e.index - t.index), l = [], u = (t) => {
-		l.push(t);
-		let n = r.call(e, t.node.id);
+	})).sort((e, t) => e.index - t.index), s = [], c = (t) => {
+		s.push(t);
+		let n = e.getChildren(t.node.id);
 		for (let e = 0; e < n.length; e++) {
-			let t = s.get(n[e]);
-			t && u({
+			let t = i.get(n[e]);
+			t && c({
 				node: t,
 				index: e
 			});
 		}
 	};
-	for (let e of c) u(e);
-	return l;
+	for (let e of o) c(e);
+	return s;
 }
 function s(e) {
 	let { node: a, label: s } = e, c = e.slot ?? r(e.index), l = {
@@ -56,9 +54,7 @@ function s(e) {
 		label: s,
 		apply(e) {
 			let r = e, i = t(r, n(a), a.id);
-			i && (c = i, l.slot = i);
-			let s = o(r, a.id);
-			s && (u = s, l.cascaded = s), r.removeNode(a.id);
+			i && (c = i, l.slot = i), u = o(r, a.id), l.cascaded = u, r.removeNode(a.id);
 		},
 		invert() {
 			return i({

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

@@ -1 +1 @@
-{"version":3,"file":"delete.js","names":["indexIn","a","parentId","id","captureCascade","getChildren","getNode","closure","rootId","taken","node","walk","kid","detachRoots","p","parentOf","n","l","r","out","emitSubtree","entry","kids","i","child","createDeleteOp","args","slot","slotFromIndex","argsForSerial","captured","adapter","observed","captureSlot","snapshot","createInsertOp","registerOpFactory"],"sources":["../../../src/core/ops/delete.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** Subtree reads, used to snapshot the cascade before it runs. Optional\n   *  — a flat adapter has neither, and a delete there is a single node. */\n  getNode?(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. A store whose removal\n   *  cascades past the subtree — the kit's scene takes a deleted node's\n   *  dependents too — must answer here, or those nodes are absent from the\n   *  snapshot and undo does not bring them back. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\n/** A captured node plus its slot in its own parent's child list. */\nexport interface PlacedNode<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** Arguments to {@link createDeleteOp}: the node to remove, plus what undo needs to put it back. */\nexport interface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter, where it can, and that supersedes this. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: SiblingSlot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. Ordered so a node's parent precedes\n   *  it, which is the order they have to be re-inserted in. Captured on apply;\n   *  mirrored into the serialized args so a rebuilt op can invert without\n   *  having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when unobservable. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren?.(parentId)?.indexOf(id) ?? -1;\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * Returns `null` when the adapter can't enumerate, which leaves any previously\n * captured snapshot in place rather than clobbering it with an empty one.\n *\n * A cascade unlinks several disjoint subtrees, so the captured set is walked\n * as a forest: a node whose parent is not also going is a detach root, and\n * each one is emitted — ascending sibling index first, so every slot still\n * means what it meant — followed by its captured descendants preorder. The\n * closure's own order will not do: it can reach a dependent before the parent\n * it sits under, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): PlacedNode<TNode>[] | null {\n  const { getChildren, getNode } = a;\n  if (!getChildren || !getNode) return null;\n\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = getNode.call(a, id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = getNode.call(a, id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of getChildren.call(a, id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: PlacedNode<TNode>[] = [];\n  const emitSubtree = (entry: PlacedNode<TNode>): void => {\n    out.push(entry);\n    const kids = getChildren.call(a, entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: PlacedNode<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      const snapshot = captureCascade(a, node.id);\n      if (snapshot) {\n        captured = snapshot;\n        argsForSerial.cascaded = snapshot;\n      }\n      a.removeNode(node.id);\n    },\n    invert() {\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      return createInsertOp<TNode>({\n        node, label, slot,\n        ...(captured.length > 0 ? { cascaded: captured } : {}),\n      });\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":";;;;AA0CA,SAASA,EAAQ,GAAkB,GAAyB,GAAoB;CAC9E,OAAOC,EAAE,cAAcC,CAAQ,CAAC,EAAE,QAAQC,CAAE,KAAK;AACnD;AAgBA,SAASC,EACP,GACA,GAC4B;CAC5B,IAAM,EAAE,gBAAa,eAAYH;CACjC,IAAI,CAACI,KAAe,CAACC,GAAS,OAAO;CAErC,IAAMC,IAAUN,EAAE,oBAAoB,CAACO,CAAM,CAAC,GACxCC,oBAAQ,IAAI,IAAmB;CACrC,IAAIF,GACF,KAAK,IAAMJ,KAAMI,GAAS;EACxB,IAAMG,IAAOJ,EAAQ,KAAKL,GAAGE,CAAE;EAC/B,AAAIO,KAAMD,EAAM,IAAIN,GAAIO,CAAI;CAC9B;MACK;EAEL,IAAMC,KAAQ,MAAqB;GACjC,IAAMD,IAAOJ,EAAQ,KAAKL,GAAGE,CAAE;GAC/B,IAAKO,GACL;MAAM,IAAIP,GAAIO,CAAI;IAClB,KAAK,IAAME,KAAOP,EAAY,KAAKJ,GAAGE,CAAE,GAAG,EAAKS,CAAG;GADjC;EAEpB;EACA,EAAKJ,CAAM;CACb;CAEA,IAAMK,IAAc,CAAC,GAAGJ,EAAM,OAAO,CAAC,CAAC,CACpC,QAAQ,MAAM;EAAE,IAAMK,IAAIC,EAASC,CAAC;EAAG,OAAOF,MAAM,QAAQ,CAACL,EAAM,IAAIK,CAAC;CAAG,CAAC,CAAC,CAC7E,KAAK,OAAO;EAAE,MAAME;EAAG,OAAOhB,EAAQC,GAAGc,EAASC,CAAC,GAAGA,EAAE,EAAE;CAAE,EAAE,CAAC,CAC/D,MAAM,GAAG,MAAMC,EAAE,QAAQC,EAAE,KAAK,GAE7BC,IAA2B,CAAC,GAC5BC,KAAe,MAAmC;EACtD,EAAI,KAAKC,CAAK;EACd,IAAMC,IAAOjB,EAAY,KAAKJ,GAAGoB,EAAM,KAAK,EAAE;EAC9C,KAAK,IAAIE,IAAI,GAAGA,IAAID,EAAK,QAAQ,KAAK;GACpC,IAAME,IAAQf,EAAM,IAAIa,EAAKC,EAAG;GAChC,AAAIC,KAAOJ,EAAY;IAAE,MAAMI;IAAO,OAAOD;GAAE,CAAC;EAClD;CACF;CACA,KAAK,IAAMF,KAASR,GAAa,EAAYQ,CAAK;CAClD,OAAOF;AACT;AAIA,SAAgBM,EAA6C,GAA6B;CACxF,IAAM,EAAE,SAAM,aAAUC,GACpBC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK,GACvDG,IAAmC;EAAE;EAAM;EAAO;EAAM,UAAUH,EAAK;CAAS,GAClFI,IAAgCJ,EAAK,YAAY,CAAC;CACtD,OAAO;EACL,MAAM;EACN,MAAMG;EACN;EACA,MAAM,GAAS;GACb,IAAM5B,IAAI8B,GACJC,IAAWC,EAAYhC,GAAGc,EAASL,CAAI,GAAGA,EAAK,EAAE;GACvD,AAAIsB,MACF,IAAOA,GACP,EAAc,OAAOA;GAEvB,IAAME,IAAW9B,EAAeH,GAAGS,EAAK,EAAE;GAK1C,AAJIwB,MACF,IAAWA,GACX,EAAc,WAAWA,IAE3BjC,EAAE,WAAWS,EAAK,EAAE;EACtB;EACA,SAAS;GAGP,OAAOyB,EAAsB;IAC3B;IAAM;IAAO;IACb,GAAIL,EAAS,SAAS,IAAI,EAAE,UAAUA,EAAS,IAAI,CAAC;GACtD,CAAC;EACH;CACF;AACF;AAEAM,EAA8C,WAAW,MAASX,EAAeC,CAAI,CAAC"}
+{"version":3,"file":"delete.js","names":["indexIn","a","parentId","id","captureCascade","closure","rootId","taken","node","walk","kid","detachRoots","p","parentOf","n","l","r","out","emitSubtree","entry","kids","i","child","createDeleteOp","args","slot","slotFromIndex","argsForSerial","captured","adapter","observed","captureSlot","createInsertOp","registerOpFactory"],"sources":["../../../src/core/ops/delete.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** With `getChildren`, the subtree reads that snapshot the cascade before\n   *  it runs. */\n  getNode(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. A store whose removal\n   *  cascades past the subtree — the kit's scene takes a deleted node's\n   *  dependents too — must answer here, or those nodes are absent from the\n   *  snapshot and undo does not bring them back. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\n/** A captured node plus its slot in its own parent's child list. */\nexport interface PlacedNode<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** Arguments to {@link createDeleteOp}: the node to remove, plus what undo needs to put it back. */\nexport interface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter, and that supersedes this. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: SiblingSlot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. Ordered so a node's parent precedes\n   *  it, which is the order they have to be re-inserted in. Captured on apply;\n   *  mirrored into the serialized args so a rebuilt op can invert without\n   *  having run. */\n  cascaded?: PlacedNode<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when it is not one. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren(parentId).indexOf(id);\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * A cascade unlinks several disjoint subtrees, so the captured set is walked\n * as a forest: a node whose parent is not also going is a detach root, and\n * each one is emitted — ascending sibling index first, so every slot still\n * means what it meant — followed by its captured descendants preorder. The\n * closure's own order will not do: it can reach a dependent before the parent\n * it sits under, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): PlacedNode<TNode>[] {\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = a.getNode(id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = a.getNode(id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of a.getChildren(id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: PlacedNode<TNode>[] = [];\n  const emitSubtree = (entry: PlacedNode<TNode>): void => {\n    out.push(entry);\n    const kids = a.getChildren(entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: PlacedNode<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      captured = captureCascade(a, node.id);\n      argsForSerial.cascaded = captured;\n      a.removeNode(node.id);\n    },\n    invert() {\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      return createInsertOp<TNode>({\n        node, label, slot,\n        ...(captured.length > 0 ? { cascaded: captured } : {}),\n      });\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"],"mappings":";;;;AA0CA,SAASA,EAAQ,GAAkB,GAAyB,GAAoB;CAC9E,OAAOC,EAAE,YAAYC,CAAQ,CAAC,CAAC,QAAQC,CAAE;AAC3C;AAaA,SAASC,EACP,GACA,GACqB;CACrB,IAAMC,IAAUJ,EAAE,oBAAoB,CAACK,CAAM,CAAC,GACxCC,oBAAQ,IAAI,IAAmB;CACrC,IAAIF,GACF,KAAK,IAAMF,KAAME,GAAS;EACxB,IAAMG,IAAOP,EAAE,QAAQE,CAAE;EACzB,AAAIK,KAAMD,EAAM,IAAIJ,GAAIK,CAAI;CAC9B;MACK;EAEL,IAAMC,KAAQ,MAAqB;GACjC,IAAMD,IAAOP,EAAE,QAAQE,CAAE;GACzB,IAAKK,GACL;MAAM,IAAIL,GAAIK,CAAI;IAClB,KAAK,IAAME,KAAOT,EAAE,YAAYE,CAAE,GAAG,EAAKO,CAAG;GAD3B;EAEpB;EACA,EAAKJ,CAAM;CACb;CAEA,IAAMK,IAAc,CAAC,GAAGJ,EAAM,OAAO,CAAC,CAAC,CACpC,QAAQ,MAAM;EAAE,IAAMK,IAAIC,EAASC,CAAC;EAAG,OAAOF,MAAM,QAAQ,CAACL,EAAM,IAAIK,CAAC;CAAG,CAAC,CAAC,CAC7E,KAAK,OAAO;EAAE,MAAME;EAAG,OAAOd,EAAQC,GAAGY,EAASC,CAAC,GAAGA,EAAE,EAAE;CAAE,EAAE,CAAC,CAC/D,MAAM,GAAG,MAAMC,EAAE,QAAQC,EAAE,KAAK,GAE7BC,IAA2B,CAAC,GAC5BC,KAAe,MAAmC;EACtD,EAAI,KAAKC,CAAK;EACd,IAAMC,IAAOnB,EAAE,YAAYkB,EAAM,KAAK,EAAE;EACxC,KAAK,IAAIE,IAAI,GAAGA,IAAID,EAAK,QAAQ,KAAK;GACpC,IAAME,IAAQf,EAAM,IAAIa,EAAKC,EAAG;GAChC,AAAIC,KAAOJ,EAAY;IAAE,MAAMI;IAAO,OAAOD;GAAE,CAAC;EAClD;CACF;CACA,KAAK,IAAMF,KAASR,GAAa,EAAYQ,CAAK;CAClD,OAAOF;AACT;AAIA,SAAgBM,EAA6C,GAA6B;CACxF,IAAM,EAAE,SAAM,aAAUC,GACpBC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK,GACvDG,IAAmC;EAAE;EAAM;EAAO;EAAM,UAAUH,EAAK;CAAS,GAClFI,IAAgCJ,EAAK,YAAY,CAAC;CACtD,OAAO;EACL,MAAM;EACN,MAAMG;EACN;EACA,MAAM,GAAS;GACb,IAAM1B,IAAI4B,GACJC,IAAWC,EAAY9B,GAAGY,EAASL,CAAI,GAAGA,EAAK,EAAE;GAOvD,AANIsB,MACF,IAAOA,GACP,EAAc,OAAOA,IAEvB,IAAW1B,EAAeH,GAAGO,EAAK,EAAE,GACpC,EAAc,WAAWoB,GACzB3B,EAAE,WAAWO,EAAK,EAAE;EACtB;EACA,SAAS;GAGP,OAAOwB,EAAsB;IAC3B;IAAM;IAAO;IACb,GAAIJ,EAAS,SAAS,IAAI,EAAE,UAAUA,EAAS,IAAI,CAAC;GACtD,CAAC;EACH;CACF;AACF;AAEAK,EAA8C,WAAW,MAASV,EAAeC,CAAI,CAAC"}

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

@@ -25,11 +25,9 @@ function u(e) {
 		args: o,
 		label: i,
 		apply(e) {
-			let n = e;
-			if (!n.getChildren || !n.setChildOrder) return !1;
-			let i = /* @__PURE__ */ new Map();
+			let n = e, i = /* @__PURE__ */ new Map();
 			for (let e of t) {
-				let t = n.getParent ? n.getParent(e) : null, r = i.get(t) ?? [];
+				let t = n.getParent(e), r = i.get(t) ?? [];
 				r.push(e), i.set(t, r);
 			}
 			let a = [], c = !1;
@@ -108,9 +106,7 @@ function p(e) {
 		args: o,
 		label: i ?? "Move to index",
 		apply(e) {
-			let i = e;
-			if (!i.getChildren || !i.setChildOrder) return;
-			let c = t.filter((e) => (i.getParent ? i.getParent(e) : null) === n), l = i.getChildren(n);
+			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);