@weasel-js/core 1.10.0 → 1.11.0

package/dist/interactions/actions/resize/capture.js

@@ -1,85 +1,128 @@
-import { unionAABB as e, unionBounds as t } from "../../../core/geometry/unionBounds.js";
-import { visualBoundsViaDescriptor as n } from "../../../core/geometry/poseDescriptor.js";
-import { localToWorld as r } from "../../../core/geometry/targetFrame.js";
-import { fixedCornerOf as i } from "./cornerHandles.js";
-import { carryPose as a, invertPlane as o, planeOf as s } from "../planeInput.js";
-import { shapeSources as c } from "../selectionSubtree.js";
-import { pointerStateOf as l } from "../pointerState.js";
-import { sceneGestureFrames as u } from "../gestureFrames.js";
-import { boxFrame as d } from "./boxFrame.js";
-import { boundsForRules as f } from "./ruleBounds.js";
-import { DEFAULT_RESIZE_BEHAVIORS as p } from "./behaviors/index.js";
-import { poseLinearOf as m } from "@weasel-js/geom";
+import { unionAABB, unionBounds } from "../../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor } from "../../../core/geometry/poseDescriptor.js";
+import { localToWorld } from "../../../core/geometry/targetFrame.js";
+import { NO_INK_EXTENTS, inkExtentsBetween, isNoInkExtents, outsetBox } from "../../../core/geometry/inkExtents.js";
+import { fixedCornerOf } from "./cornerHandles.js";
+import { carryPose, invertPlane, planeOf } from "../planeInput.js";
+import { shapeSources } from "../selectionSubtree.js";
+import { pointerStateOf } from "../pointerState.js";
+import { sceneGestureFrames } from "../gestureFrames.js";
+import { boundsForRules } from "./ruleBounds.js";
+import { boxFrame } from "./boxFrame.js";
+import { poseLinearOf } from "@weasel-js/geom";
+
 //#region src/interactions/actions/resize/capture.ts
-var h = (e) => e, g = [];
-function _(e) {
-	return e ? {
-		constraints: e.constraints,
-		pointSnap: e.pointSnap,
-		expandIds: e.expandIds
-	} : {
-		constraints: p,
-		pointSnap: g,
-		expandIds: h
+var IDENTITY_EXPAND = (ids) => ids;
+/** The `resizePolicy` dep's rules, or the defaults when it is unsourced. */
+function resolvePolicy(dep) {
+	if (!dep) return {
+		constraints: [],
+		expandIds: IDENTITY_EXPAND
+	};
+	return {
+		constraints: dep.constraints,
+		expandIds: dep.expandIds
 	};
 }
-function v(e, t, n) {
-	let r = c(e, n(t));
-	if (r.length === 0) return null;
-	let i = t.length === 1 && (r.length !== 1 || r[0] !== t[0]);
+/** The ids the gesture writes, and whether one selected id stands for them.
+*  A lone id the policy expands into a different set is the group path:
+*  every leaf is written, against the union of their bounds. Otherwise the
+*  selected ids are written directly. A group whose pose derives from its
+*  children is resized by resizing them, whatever the policy expanded to.
+*  Null when there is nothing to write. */
+function captureTargets(scene, ids, expandIds) {
+	const expanded = shapeSources(scene, expandIds(ids));
+	if (expanded.length === 0) return null;
+	const isGroupPath = ids.length === 1 && (expanded.length !== 1 || expanded[0] !== ids[0]);
 	return {
-		writeIds: i || t.length > 1 ? r : t,
-		isGroupPath: i
+		writeIds: isGroupPath || ids.length > 1 ? expanded : ids,
+		isGroupPath
 	};
 }
-function y(e, t, r, i, c) {
-	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = [], f = [];
-	for (let p of t) {
-		let t = e.get(p);
-		if (!t) continue;
-		l.set(p, t.pose);
-		let m = r(p), h = a(m, i.world(p), o(s(c, t.layer)));
-		u.set(p, h), d.push(m.getBounds(h)), f.push(n(h, m));
+function captureStarts(scene, writeIds, geometryOf, poseFrame, view, boxes) {
+	const startPoses = /* @__PURE__ */ new Map();
+	const startWorlds = /* @__PURE__ */ new Map();
+	const leafBounds = [];
+	const drawnBounds = [];
+	const leafExtents = [];
+	const inkedBounds = [];
+	for (const id of writeIds) {
+		const node = scene.get(id);
+		if (!node) continue;
+		startPoses.set(id, node.pose);
+		const g = geometryOf(id);
+		const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(view, node.layer)));
+		startWorlds.set(id, world);
+		leafBounds.push(g.getBounds(world));
+		drawnBounds.push(visualBoundsViaDescriptor(world, g));
+		leafExtents.push(boxes.extents(id, world));
+		inkedBounds.push(boxes.aabb(id, world));
 	}
 	return {
-		startPoses: l,
-		startWorlds: u,
-		leafBounds: d,
-		drawnBounds: f
+		startPoses,
+		startWorlds,
+		leafBounds,
+		drawnBounds,
+		leafExtents,
+		inkedBounds
 	};
 }
-function b(n, a, o, s, c, l) {
-	let { leafBounds: u, drawnBounds: p } = n, h = u.length === 1 ? u[0] : o ? t(u) : e(p), g = !o && a.length === 1, _ = g ? n.startWorlds.get(a[0]) : h, v = g ? l(a[0]) : c, y = o ? 0 : v.getRotation?.(_) ?? 0, b = g && m(_) || void 0, x = i(h, s);
+/** How far the ink of everything in a box reaches past it: a lone target's
+*  own extents, or the union of the members as drawn past their union. */
+function boxExtents(starts, bounds, isGroupPath) {
+	const { leafBounds, leafExtents } = starts;
+	if (leafBounds.length === 1) return leafExtents[0];
+	if (leafExtents.every(isNoInkExtents)) return NO_INK_EXTENTS;
+	const inked = isGroupPath ? unionBounds(leafBounds.map((b, i) => outsetBox(b, leafExtents[i]))) : unionAABB(starts.inkedBounds);
+	return inked ? inkExtentsBetween(bounds, inked) : NO_INK_EXTENTS;
+}
+/** The box the drag resizes, and that box as the constraints read it.
+*  `starts` must hold at least one pose. */
+function captureBox(starts, writeIds, isGroupPath, anchor, geometry, geometryOf) {
+	const { leafBounds, drawnBounds } = starts;
+	const bounds = leafBounds.length === 1 ? leafBounds[0] : isGroupPath ? unionBounds(leafBounds) : unionAABB(drawnBounds);
+	const lone = !isGroupPath && writeIds.length === 1;
+	const originPose = lone ? starts.startWorlds.get(writeIds[0]) : bounds;
+	const originGeometry = lone ? geometryOf(writeIds[0]) : geometry;
+	const rotation = !isGroupPath ? originGeometry.getRotation?.(originPose) ?? 0 : 0;
+	const transform = lone && poseLinearOf(originPose) || void 0;
+	const fixedLocal = fixedCornerOf(bounds, anchor);
+	const fixedWorld = localToWorld(boxFrame({
+		rotation,
+		transform
+	}, bounds), fixedLocal.x, fixedLocal.y);
+	const extents = boxExtents(starts, bounds, isGroupPath);
 	return {
 		box: {
-			bounds: h,
-			anchor: s,
-			rotation: y,
-			transform: b,
-			fixedWorld: r(d({
-				rotation: y,
-				transform: b
-			}, h), x.x, x.y)
+			bounds,
+			anchor,
+			rotation,
+			transform,
+			fixedWorld,
+			extents
 		},
-		ruleOrigin: f(v, _)
+		ruleOrigin: outsetBox(boundsForRules(originGeometry, originPose), extents)
 	};
 }
-function x(e, t, n, r, i) {
+/** The context the constraints read. `draggedIds` is the selection, not the
+*  ids written, and the one pose it tracks is keyed by the first selected id. */
+function buildGestureContext(ctx, ids, ruleOrigin, startWorld, readers) {
 	return {
-		draggedIds: t,
-		origin: /* @__PURE__ */ new Map([[t[0], n]]),
-		current: /* @__PURE__ */ new Map([[t[0], n]]),
+		draggedIds: ids,
+		origin: /* @__PURE__ */ new Map([[ids[0], ruleOrigin]]),
+		current: /* @__PURE__ */ new Map([[ids[0], ruleOrigin]]),
 		snap: null,
-		modifiers: { ...e.modifiers },
-		pointer: l(r, e),
-		view: i.view(),
-		plane: i.plane(),
-		...e.deps.scene ? { frames: u(e.deps.scene, e.deps.view) } : {},
+		modifiers: { ...ctx.modifiers },
+		pointer: pointerStateOf(startWorld, ctx),
+		view: readers.view(),
+		plane: readers.plane(),
+		kitSettings: readers.kitSettings,
+		...ctx.deps.scene ? { frames: sceneGestureFrames(ctx.deps.scene, ctx.deps) } : {},
 		adapter: void 0,
 		scratch: {}
 	};
 }
-//#endregion
-export { x as buildGestureContext, b as captureBox, y as captureStarts, v as captureTargets, _ as resolvePolicy };
 
+//#endregion
+export { buildGestureContext, captureBox, captureStarts, captureTargets, resolvePolicy };
 //# sourceMappingURL=capture.js.map

package/dist/interactions/actions/resize/capture.js.map

@@ -1 +1 @@
-{"version":3,"file":"capture.js","names":["IDENTITY_EXPAND","ids","EMPTY_POINT_SNAP","resolvePolicy","dep","DEFAULT_RESIZE_BEHAVIORS","captureTargets","expanded","shapeSources","scene","expandIds","isGroupPath","captureStarts","startPoses","startWorlds","leafBounds","drawnBounds","id","writeIds","node","g","geometryOf","world","carryPose","poseFrame","invertPlane","planeOf","view","visualBoundsViaDescriptor","captureBox","starts","bounds","unionBounds","unionAABB","lone","originPose","originGeometry","geometry","rotation","transform","poseLinearOf","fixedLocal","fixedCornerOf","anchor","localToWorld","boxFrame","boundsForRules","buildGestureContext","ruleOrigin","ctx","pointerStateOf","startWorld","readers","sceneGestureFrames"],"sources":["../../../../src/interactions/actions/resize/capture.ts"],"sourcesContent":["import { poseLinearOf } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\nimport { localToWorld } from 'core/geometry/targetFrame';\nimport { pointerStateOf } from '../pointerState';\nimport { sceneGestureFrames } from '../gestureFrames';\nimport { unionAABB, unionBounds } from 'core/geometry/unionBounds';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, PointSnapBehavior, ResizeAnchor } from '../../gestures/types';\nimport type { ResizePolicy } from '../depSchema';\nimport { carryPose, invertPlane, planeOf } from '../planeInput';\nimport type { PoseFrame } from '../poseFrame';\nimport { shapeSources } from '../selectionSubtree';\nimport { DEFAULT_RESIZE_BEHAVIORS } from './behaviors';\nimport { fixedCornerOf } from './cornerHandles';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './geometry';\nimport { boundsForRules } from './ruleBounds';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox } from './session';\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY_POINT_SNAP: PointSnapBehavior<Bounds>[] = [];\n\n/** The `resizePolicy` dep's rules, or the defaults when it is unsourced. */\nexport function resolvePolicy(dep: ResizePolicy<unknown> | undefined): {\n  constraints: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n  expandIds: (ids: string[]) => string[];\n} {\n  if (!dep) {\n    return {\n      // Standard kit behaviors (shift = aspect lock) apply even with no\n      // policy wired; consumers opt out via an explicit `constraints: []`.\n      constraints: DEFAULT_RESIZE_BEHAVIORS as BoundsConstraint<Bounds>[],\n      pointSnap: EMPTY_POINT_SNAP,\n      expandIds: IDENTITY_EXPAND,\n    };\n  }\n  return {\n    constraints: dep.constraints as unknown as BoundsConstraint<Bounds>[],\n    pointSnap: dep.pointSnap as unknown as PointSnapBehavior<Bounds>[],\n    expandIds: dep.expandIds,\n  };\n}\n\n/** The ids the gesture writes, and whether one selected id stands for them.\n *  A lone id the policy expands into a different set is the group path:\n *  every leaf is written, against the union of their bounds. Otherwise the\n *  selected ids are written directly. A group whose pose derives from its\n *  children is resized by resizing them, whatever the policy expanded to.\n *  Null when there is nothing to write. */\nexport function captureTargets(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  expandIds: (ids: string[]) => string[],\n): { writeIds: NodeId[]; isGroupPath: boolean } | null {\n  const expanded = shapeSources(scene, expandIds(ids as unknown as string[]));\n  if (expanded.length === 0) return null;\n  const isGroupPath =\n    ids.length === 1 && (expanded.length !== 1 || expanded[0] !== (ids[0] as string));\n  const writeIds = (isGroupPath || ids.length > 1 ? expanded : (ids as unknown as string[])) as NodeId[];\n  return { writeIds, isGroupPath };\n}\n\nexport interface ResizeStarts {\n  /** As stored. */\n  startPoses: Map<NodeId, unknown>;\n  /** In world, carried into the plane the edit is measured in. */\n  startWorlds: Map<NodeId, unknown>;\n  leafBounds: Bounds[];\n  drawnBounds: Bounds[];\n}\n\nexport function captureStarts(\n  scene: Scene<unknown, string, unknown>,\n  writeIds: readonly NodeId[],\n  geometryOf: (id: NodeId) => PoseDescriptor<unknown>,\n  poseFrame: PoseFrame<unknown>,\n  view: unknown,\n): ResizeStarts {\n  const startPoses = new Map<NodeId, unknown>();\n  const startWorlds = new Map<NodeId, unknown>();\n  const leafBounds: Bounds[] = [];\n  const drawnBounds: Bounds[] = [];\n  for (const id of writeIds) {\n    const node = scene.get(id);\n    if (!node) continue;\n    startPoses.set(id, node.pose);\n    const g = geometryOf(id);\n    const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(view, node.layer)));\n    startWorlds.set(id, world);\n    leafBounds.push(g.getBounds(world));\n    drawnBounds.push(visualBoundsViaDescriptor(world, g));\n  }\n  return { startPoses, startWorlds, leafBounds, drawnBounds };\n}\n\n/** The box the drag resizes, and that box as the constraints read it.\n *  `starts` must hold at least one pose. */\nexport function captureBox(\n  starts: Pick<ResizeStarts, 'startWorlds' | 'leafBounds' | 'drawnBounds'>,\n  writeIds: readonly NodeId[],\n  isGroupPath: boolean,\n  anchor: ResizeAnchor,\n  geometry: PoseDescriptor<unknown>,\n  geometryOf: (id: NodeId) => PoseDescriptor<unknown>,\n): { box: ResizeBox; ruleOrigin: Bounds } {\n  const { leafBounds, drawnBounds } = starts;\n  // A multi-selection's handles sit on the union of what is drawn, so that\n  // is the box its drag resizes.\n  const bounds = leafBounds.length === 1\n    ? leafBounds[0]\n    : isGroupPath ? unionBounds(leafBounds)! : unionAABB(drawnBounds)!;\n\n  // Rotation captured only for the single-write-id path; group-resize\n  // takes the AABB-frame (unrotated) path even if leaves have rotation.\n  const lone = !isGroupPath && writeIds.length === 1;\n  const originPose = lone ? starts.startWorlds.get(writeIds[0]) : (bounds as unknown);\n  // A lone target is read as its own shape; a shared box is a plain rect.\n  const originGeometry = lone ? geometryOf(writeIds[0]) : geometry;\n  const rotation = !isGroupPath ? (originGeometry.getRotation?.(originPose) ?? 0) : 0;\n  const transform = (lone && poseLinearOf(originPose)) || undefined;\n\n  const fixedLocal = fixedCornerOf(bounds, anchor);\n  const fixedWorld = localToWorld(boxFrame({ rotation, transform }, bounds), fixedLocal.x, fixedLocal.y);\n  return {\n    box: { bounds, anchor, rotation, transform, fixedWorld },\n    ruleOrigin: boundsForRules(originGeometry, originPose),\n  };\n}\n\n/** The context the constraints read. `draggedIds` is the selection, not the\n *  ids written, and the one pose it tracks is keyed by the first selected id. */\nexport function buildGestureContext(\n  ctx: InvocationCtx,\n  ids: readonly NodeId[],\n  ruleOrigin: Bounds,\n  startWorld: { x: number; y: number },\n  readers: GestureReaders,\n): GestureContext<Bounds> {\n  return {\n    draggedIds: ids as unknown as string[],\n    origin: new Map<string, Bounds>([[ids[0] as string, ruleOrigin]]),\n    current: new Map<string, Bounds>([[ids[0] as string, ruleOrigin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(startWorld, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    ...(ctx.deps.scene\n      ? { frames: sceneGestureFrames(ctx.deps.scene, ctx.deps.view) as GestureContext<Bounds>['frames'] }\n      : {}),\n    // `adapter` is unused by the kit's behaviors; cast to satisfy the type.\n    adapter: undefined as unknown as GestureContext<Bounds>['adapter'],\n    scratch: {},\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,IAAMA,KAAmB,MAAkBC,GACrCC,IAAgD,CAAC;AAGvD,SAAgBC,EAAc,GAI5B;CAUA,OATKC,IASE;EACL,aAAaA,EAAI;EACjB,WAAWA,EAAI;EACf,WAAWA,EAAI;CACjB,IAZS;EAGL,aAAaC;EACb,WAAWH;EACX,WAAWF;CACb;AAOJ;AAQA,SAAgBM,EACd,GACA,GACA,GACqD;CACrD,IAAMC,IAAWC,EAAaC,GAAOC,EAAUT,CAA0B,CAAC;CAC1E,IAAIM,EAAS,WAAW,GAAG,OAAO;CAClC,IAAMI,IACJV,EAAI,WAAW,MAAMM,EAAS,WAAW,KAAKA,EAAS,OAAQN,EAAI;CAErE,OAAO;EAAE,UADSU,KAAeV,EAAI,SAAS,IAAIM,IAAYN;EAC3C;CAAY;AACjC;AAWA,SAAgBW,EACd,GACA,GACA,GACA,GACA,GACc;CACd,IAAMC,oBAAa,IAAI,IAAqB,GACtCC,oBAAc,IAAI,IAAqB,GACvCC,IAAuB,CAAC,GACxBC,IAAwB,CAAC;CAC/B,KAAK,IAAMC,KAAMC,GAAU;EACzB,IAAMC,IAAOV,EAAM,IAAIQ,CAAE;EACzB,IAAI,CAACE,GAAM;EACX,EAAW,IAAIF,GAAIE,EAAK,IAAI;EAC5B,IAAMC,IAAIC,EAAWJ,CAAE,GACjBK,IAAQC,EAAUH,GAAGI,EAAU,MAAMP,CAAE,GAAGQ,EAAYC,EAAQC,GAAMR,EAAK,KAAK,CAAC,CAAC;EAGtF,AAFAL,EAAY,IAAIG,GAAIK,CAAK,GACzBP,EAAW,KAAKK,EAAE,UAAUE,CAAK,CAAC,GAClCN,EAAY,KAAKY,EAA0BN,GAAOF,CAAC,CAAC;CACtD;CACA,OAAO;EAAE;EAAY;EAAa;EAAY;CAAY;AAC5D;AAIA,SAAgBS,EACd,GACA,GACA,GACA,GACA,GACA,GACwC;CACxC,IAAM,EAAE,eAAY,mBAAgBC,GAG9BC,IAAShB,EAAW,WAAW,IACjCA,EAAW,KACXJ,IAAcqB,EAAYjB,CAAU,IAAKkB,EAAUjB,CAAW,GAI5DkB,IAAO,CAACvB,KAAeO,EAAS,WAAW,GAC3CiB,IAAaD,IAAOJ,EAAO,YAAY,IAAIZ,EAAS,EAAE,IAAKa,GAE3DK,IAAiBF,IAAOb,EAAWH,EAAS,EAAE,IAAImB,GAClDC,IAAY3B,IAAgE,IAAjDyB,EAAe,cAAcD,CAAU,KAAK,GACvEI,IAAaL,KAAQM,EAAaL,CAAU,KAAM,KAAA,GAElDM,IAAaC,EAAcX,GAAQY,CAAM;CAE/C,OAAO;EACL,KAAK;GAAE;GAAQ;GAAQ;GAAU;GAAW,YAF3BC,EAAaC,EAAS;IAAE;IAAU;GAAU,GAAGd,CAAM,GAAGU,EAAW,GAAGA,EAAW,CAEtD;EAAW;EACvD,YAAYK,EAAeV,GAAgBD,CAAU;CACvD;AACF;AAIA,SAAgBY,EACd,GACA,GACA,GACA,GACA,GACwB;CACxB,OAAO;EACL,YAAY9C;EACZ,wBAAQ,IAAI,IAAoB,CAAC,CAACA,EAAI,IAAc+C,CAAU,CAAC,CAAC;EAChE,yBAAS,IAAI,IAAoB,CAAC,CAAC/C,EAAI,IAAc+C,CAAU,CAAC,CAAC;EACjE,MAAM;EACN,WAAW,EAAE,GAAGC,EAAI,UAAU;EAC9B,SAASC,EAAeC,GAAYF,CAAG;EACvC,MAAMG,EAAQ,KAAK;EACnB,OAAOA,EAAQ,MAAM;EACrB,GAAIH,EAAI,KAAK,QACT,EAAE,QAAQI,EAAmBJ,EAAI,KAAK,OAAOA,EAAI,KAAK,IAAI,EAAsC,IAChG,CAAC;EAEL,SAAS,KAAA;EACT,SAAS,CAAC;CACZ;AACF"}
+{"version":3,"file":"capture.js","names":[],"sources":["../../../../src/interactions/actions/resize/capture.ts"],"sourcesContent":["import { poseLinearOf } from '@weasel-js/geom';\nimport type { InvocationCtx } from '@weasel-js/routing';\nimport { localToWorld } from 'core/geometry/targetFrame';\nimport { pointerStateOf } from '../pointerState';\nimport { sceneGestureFrames } from '../gestureFrames';\nimport { unionAABB, unionBounds } from 'core/geometry/unionBounds';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { BoundsConstraint, GestureContext, ResizeAnchor } from '../../gestures/types';\nimport type { ResizePolicy } from '../depSchema';\nimport { carryPose, invertPlane, planeOf } from '../planeInput';\nimport type { PoseFrame } from '../poseFrame';\nimport { shapeSources } from '../selectionSubtree';\nimport { fixedCornerOf } from './cornerHandles';\nimport { visualBoundsViaDescriptor, type PoseDescriptor } from './geometry';\nimport { boundsForRules } from './ruleBounds';\nimport { boxFrame } from './boxFrame';\nimport type { ResizeBox } from './session';\nimport type { DrawnBoxes } from '../drawnBoxes';\nimport {\n  inkExtentsBetween,\n  isNoInkExtents,\n  NO_INK_EXTENTS,\n  outsetBox,\n  type InkExtents,\n} from 'core/geometry/inkExtents';\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\n\n/** The `resizePolicy` dep's rules, or the defaults when it is unsourced. */\nexport function resolvePolicy(dep: ResizePolicy<unknown> | undefined): {\n  constraints: BoundsConstraint<Bounds>[];\n  expandIds: (ids: string[]) => string[];\n} {\n  if (!dep) {\n    return {\n      constraints: [],\n      expandIds: IDENTITY_EXPAND,\n    };\n  }\n  return {\n    constraints: dep.constraints as unknown as BoundsConstraint<Bounds>[],\n    expandIds: dep.expandIds,\n  };\n}\n\n/** The ids the gesture writes, and whether one selected id stands for them.\n *  A lone id the policy expands into a different set is the group path:\n *  every leaf is written, against the union of their bounds. Otherwise the\n *  selected ids are written directly. A group whose pose derives from its\n *  children is resized by resizing them, whatever the policy expanded to.\n *  Null when there is nothing to write. */\nexport function captureTargets(\n  scene: Scene<unknown, string, unknown>,\n  ids: readonly NodeId[],\n  expandIds: (ids: string[]) => string[],\n): { writeIds: NodeId[]; isGroupPath: boolean } | null {\n  const expanded = shapeSources(scene, expandIds(ids as unknown as string[]));\n  if (expanded.length === 0) return null;\n  const isGroupPath =\n    ids.length === 1 && (expanded.length !== 1 || expanded[0] !== (ids[0] as string));\n  const writeIds = (isGroupPath || ids.length > 1 ? expanded : (ids as unknown as string[])) as NodeId[];\n  return { writeIds, isGroupPath };\n}\n\nexport interface ResizeStarts {\n  /** As stored. */\n  startPoses: Map<NodeId, unknown>;\n  /** In world, carried into the plane the edit is measured in. */\n  startWorlds: Map<NodeId, unknown>;\n  /** Each write id's pose box, unturned. */\n  leafBounds: Bounds[];\n  /** Each write id's pose box as it covers the world, turned. */\n  drawnBounds: Bounds[];\n  /** How far each write id's ink reaches past its pose box. */\n  leafExtents: InkExtents[];\n  /** `drawnBounds` with the ink. */\n  inkedBounds: Bounds[];\n}\n\nexport function captureStarts(\n  scene: Scene<unknown, string, unknown>,\n  writeIds: readonly NodeId[],\n  geometryOf: (id: NodeId) => PoseDescriptor<unknown>,\n  poseFrame: PoseFrame<unknown>,\n  view: unknown,\n  boxes: DrawnBoxes,\n): ResizeStarts {\n  const startPoses = new Map<NodeId, unknown>();\n  const startWorlds = new Map<NodeId, unknown>();\n  const leafBounds: Bounds[] = [];\n  const drawnBounds: Bounds[] = [];\n  const leafExtents: InkExtents[] = [];\n  const inkedBounds: Bounds[] = [];\n  for (const id of writeIds) {\n    const node = scene.get(id);\n    if (!node) continue;\n    startPoses.set(id, node.pose);\n    const g = geometryOf(id);\n    const world = carryPose(g, poseFrame.world(id), invertPlane(planeOf(view, node.layer)));\n    startWorlds.set(id, world);\n    leafBounds.push(g.getBounds(world));\n    drawnBounds.push(visualBoundsViaDescriptor(world, g));\n    leafExtents.push(boxes.extents(id, world));\n    inkedBounds.push(boxes.aabb(id, world));\n  }\n  return { startPoses, startWorlds, leafBounds, drawnBounds, leafExtents, inkedBounds };\n}\n\n/** How far the ink of everything in a box reaches past it: a lone target's\n *  own extents, or the union of the members as drawn past their union. */\nfunction boxExtents(\n  starts: Pick<ResizeStarts, 'leafBounds' | 'leafExtents' | 'inkedBounds'>,\n  bounds: Bounds,\n  isGroupPath: boolean,\n): InkExtents {\n  const { leafBounds, leafExtents } = starts;\n  if (leafBounds.length === 1) return leafExtents[0]!;\n  if (leafExtents.every(isNoInkExtents)) return NO_INK_EXTENTS;\n  const inked = isGroupPath\n    ? unionBounds(leafBounds.map((b, i) => outsetBox(b, leafExtents[i]!)))\n    : unionAABB(starts.inkedBounds);\n  return inked ? inkExtentsBetween(bounds, inked) : NO_INK_EXTENTS;\n}\n\n/** The box the drag resizes, and that box as the constraints read it.\n *  `starts` must hold at least one pose. */\nexport function captureBox(\n  starts: Pick<ResizeStarts, 'startWorlds' | 'leafBounds' | 'drawnBounds' | 'leafExtents' | 'inkedBounds'>,\n  writeIds: readonly NodeId[],\n  isGroupPath: boolean,\n  anchor: ResizeAnchor,\n  geometry: PoseDescriptor<unknown>,\n  geometryOf: (id: NodeId) => PoseDescriptor<unknown>,\n): { box: ResizeBox; ruleOrigin: Bounds } {\n  const { leafBounds, drawnBounds } = starts;\n  // A multi-selection's handles sit on the union of what is drawn, so that\n  // is the box its drag resizes.\n  const bounds = leafBounds.length === 1\n    ? leafBounds[0]\n    : isGroupPath ? unionBounds(leafBounds)! : unionAABB(drawnBounds)!;\n\n  // Rotation captured only for the single-write-id path; group-resize\n  // takes the AABB-frame (unrotated) path even if leaves have rotation.\n  const lone = !isGroupPath && writeIds.length === 1;\n  const originPose = lone ? starts.startWorlds.get(writeIds[0]) : (bounds as unknown);\n  // A lone target is read as its own shape; a shared box is a plain rect.\n  const originGeometry = lone ? geometryOf(writeIds[0]) : geometry;\n  const rotation = !isGroupPath ? (originGeometry.getRotation?.(originPose) ?? 0) : 0;\n  const transform = (lone && poseLinearOf(originPose)) || undefined;\n\n  const fixedLocal = fixedCornerOf(bounds, anchor);\n  const fixedWorld = localToWorld(boxFrame({ rotation, transform }, bounds), fixedLocal.x, fixedLocal.y);\n  const extents = boxExtents(starts, bounds, isGroupPath);\n  return {\n    box: { bounds, anchor, rotation, transform, fixedWorld, extents },\n    ruleOrigin: outsetBox(boundsForRules(originGeometry, originPose), extents),\n  };\n}\n\n/** The context the constraints read. `draggedIds` is the selection, not the\n *  ids written, and the one pose it tracks is keyed by the first selected id. */\nexport function buildGestureContext(\n  ctx: InvocationCtx,\n  ids: readonly NodeId[],\n  ruleOrigin: Bounds,\n  startWorld: { x: number; y: number },\n  readers: GestureReaders,\n): GestureContext<Bounds> {\n  return {\n    draggedIds: ids as unknown as string[],\n    origin: new Map<string, Bounds>([[ids[0] as string, ruleOrigin]]),\n    current: new Map<string, Bounds>([[ids[0] as string, ruleOrigin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(startWorld, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    kitSettings: readers.kitSettings,\n    ...(ctx.deps.scene\n      ? { frames: sceneGestureFrames(ctx.deps.scene, ctx.deps) as GestureContext<Bounds>['frames'] }\n      : {}),\n    // `adapter` is unused by the kit's behaviors; cast to satisfy the type.\n    adapter: undefined as unknown as GestureContext<Bounds>['adapter'],\n    scratch: {},\n  };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/resize/commit.js

@@ -1,69 +1,88 @@
-import { commitGestureOps as e, reduceBehaviorEnd as t } from "../gestureLifecycle.js";
-import { createTransformOp as n } from "../../../core/ops/transform.js";
-import { geometryDataOp as r } from "../geometryProjection.js";
-import { defaultCommitAdapter as i } from "../defaultCommitAdapter.js";
-import { boxToBox as a } from "@weasel-js/geom";
+import { commitGestureOps, reduceBehaviorEnd } from "../gestureLifecycle.js";
+import { createTransformOp } from "../../../core/ops/transform.js";
+import { geometryDataOp } from "../geometryProjection.js";
+import { defaultCommitAdapter } from "../defaultCommitAdapter.js";
+import { boxToBox } from "@weasel-js/geom";
+
 //#region src/interactions/actions/resize/commit.ts
-function o(e, t, n, i, o, s) {
-	let c = t.getBounds(i), l = t.getBounds(o), u = a(c.x, c.y, c.width, c.height, l.x, l.y, l.width, l.height), d = r(e, {
-		id: n.id,
-		data: n.data,
-		pose: i
-	}, u, s);
-	if (!d) return null;
-	if (!(l.width < 0 || l.height < 0)) return {
-		dataOp: d,
-		pose: o
+/** The op mapping a leaf's data-held geometry by the box→box affine its pose
+*  underwent, and the pose to commit beside it. Null when the projection
+*  leaves this node's data alone. */
+function projectedGeometry(projection, g, node, from, next, label) {
+	const sb = g.getBounds(from);
+	const db = g.getBounds(next);
+	const m = boxToBox(sb.x, sb.y, sb.width, sb.height, db.x, db.y, db.width, db.height);
+	const dataOp = geometryDataOp(projection, {
+		id: node.id,
+		data: node.data,
+		pose: from
+	}, m, label);
+	if (!dataOp) return null;
+	if (!(db.width < 0 || db.height < 0)) return {
+		dataOp,
+		pose: next
 	};
-	let f = {
-		...l,
-		x: l.width < 0 ? l.x + l.width : l.x,
-		y: l.height < 0 ? l.y + l.height : l.y,
-		width: Math.abs(l.width),
-		height: Math.abs(l.height)
+	const nb = {
+		...db,
+		x: db.width < 0 ? db.x + db.width : db.x,
+		y: db.height < 0 ? db.y + db.height : db.y,
+		width: Math.abs(db.width),
+		height: Math.abs(db.height)
 	};
 	return {
-		dataOp: d,
-		pose: t.remapBounds(o, l, f)
+		dataOp,
+		pose: g.remapBounds(next, db, nb)
 	};
 }
-function s(e, t, r) {
-	let i = [];
-	for (let a of e.writeIds) {
-		let s = t.get(a);
-		if (s === void 0) continue;
-		let c = e.startPoses.get(a);
-		if (c === void 0) continue;
-		let l = s, u = e.geometryProjection ? e.scene.get(a) : void 0;
-		if (e.geometryProjection && u) {
-			let t = o(e.geometryProjection, e.geometryOf(a), {
-				id: a,
-				data: u.data
-			}, c, s, r);
-			t && (i.push(t.dataOp), l = t.pose);
+/** One transform op per write id, `from` the pose stored at press and `to`
+*  its preview, each preceded by its data op when the geometry projection
+*  answers for the node. */
+function resizeOps(leaves, previews, label) {
+	const ops = [];
+	for (const id of leaves.writeIds) {
+		const next = previews.get(id);
+		if (next === void 0) continue;
+		const from = leaves.startPoses.get(id);
+		if (from === void 0) continue;
+		let to = next;
+		const node = leaves.geometryProjection ? leaves.scene.get(id) : void 0;
+		if (leaves.geometryProjection && node) {
+			const projected = projectedGeometry(leaves.geometryProjection, leaves.geometryOf(id), {
+				id,
+				data: node.data
+			}, from, next, label);
+			if (projected) {
+				ops.push(projected.dataOp);
+				to = projected.pose;
+			}
 		}
-		i.push(n({
-			id: a,
-			from: c,
-			to: l,
-			label: r
+		ops.push(createTransformOp({
+			id,
+			from,
+			to,
+			label
 		}));
 	}
-	return i;
+	return ops;
 }
-function c(n, r) {
-	let { lifecycle: a } = n, o = {
-		scene: n.scene,
-		applyOps: n.applyOps,
-		adapter: i(n.scene, n.selectionMethods)
-	}, c = t(n.constraints, n.gestureCtx);
-	if (c === null) return !1;
-	if (c !== void 0) return e(o, a, c);
-	if (r.previews.size === 0) return !1;
-	let l = s(n, r.previews, a.label);
-	return l.length !== 0 && e(o, a, l);
+/** Commit the drag as one batch, so one undo entry. Returns whether anything
+*  reached the document. */
+function commitResize(session, frame) {
+	const { lifecycle } = session;
+	const target = {
+		scene: session.scene,
+		applyOps: session.applyOps,
+		adapter: defaultCommitAdapter(session.scene, session.selectionMethods)
+	};
+	const r = reduceBehaviorEnd(session.constraints, session.gestureCtx);
+	if (r === null) return false;
+	if (r !== void 0) return commitGestureOps(target, lifecycle, r);
+	if (frame.previews.size === 0) return false;
+	const ops = resizeOps(session, frame.previews, lifecycle.label);
+	if (ops.length === 0) return false;
+	return commitGestureOps(target, lifecycle, ops);
 }
-//#endregion
-export { c as commitResize, s as resizeOps };
 
+//#endregion
+export { commitResize, resizeOps };
 //# sourceMappingURL=commit.js.map

package/dist/interactions/actions/resize/commit.js.map

@@ -1 +1 @@
-{"version":3,"file":"commit.js","names":["projectedGeometry","sb","g","from","db","next","m","boxToBox","dataOp","geometryDataOp","projection","node","label","nb","resizeOps","ops","id","leaves","previews","to","projected","createTransformOp","commitResize","session","target","defaultCommitAdapter","r","reduceBehaviorEnd","commitGestureOps","lifecycle","frame"],"sources":["../../../../src/interactions/actions/resize/commit.ts"],"sourcesContent":["import { boxToBox, type Mat3 } from '@weasel-js/geom';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { NodeId } from 'core/scene/types';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\nimport { commitGestureOps, reduceBehaviorEnd } from '../gestureLifecycle';\nimport type { PoseDescriptor } from './geometry';\nimport type { ResizeFrame, ResizeSession } from './session';\n\n/** The op mapping a leaf's data-held geometry by the box→box affine its pose\n *  underwent, and the pose to commit beside it. Null when the projection\n *  leaves this node's data alone. */\nfunction projectedGeometry(\n  projection: GeometryProjection,\n  g: PoseDescriptor<unknown>,\n  node: { id: string; data: unknown },\n  from: unknown,\n  next: unknown,\n  label: string,\n): { dataOp: Op; pose: unknown } | null {\n  const sb = g.getBounds(from);\n  const db = g.getBounds(next);\n  const m: Mat3 = boxToBox(\n    sb.x, sb.y, sb.width, sb.height,\n    db.x, db.y, db.width, db.height,\n  );\n  const dataOp = geometryDataOp(projection, { id: node.id, data: node.data, pose: from }, m, label);\n  if (!dataOp) return null;\n  // The data absorbed the affine — including any mirror from a\n  // drag past the opposite edge — so the pose must commit as a\n  // normalized AABB. Leaving signed extents on the pose makes\n  // the node unhittable (hit-testing assumes normalized boxes).\n  // Without the seam the signed pose is kept: a bare-AABB pose\n  // is the only carrier of the flip there.\n  if (!(db.width < 0 || db.height < 0)) return { dataOp, pose: next };\n  const nb = {\n    ...db,\n    x: db.width < 0 ? db.x + db.width : db.x,\n    y: db.height < 0 ? db.y + db.height : db.y,\n    width: Math.abs(db.width),\n    height: Math.abs(db.height),\n  };\n  return { dataOp, pose: g.remapBounds(next, db, nb) };\n}\n\n/** One transform op per write id, `from` the pose stored at press and `to`\n *  its preview, each preceded by its data op when the geometry projection\n *  answers for the node. */\nexport function resizeOps(\n  leaves: Pick<ResizeSession, 'scene' | 'writeIds' | 'startPoses' | 'geometryOf' | 'geometryProjection'>,\n  previews: ReadonlyMap<NodeId, unknown>,\n  label: string,\n): Op[] {\n  const ops: Op[] = [];\n  for (const id of leaves.writeIds) {\n    const next = previews.get(id);\n    if (next === undefined) continue;\n    const from = leaves.startPoses.get(id);\n    if (from === undefined) continue;\n    let to: unknown = next;\n    const node = leaves.geometryProjection ? leaves.scene.get(id) : undefined;\n    if (leaves.geometryProjection && node) {\n      const projected = projectedGeometry(\n        leaves.geometryProjection, leaves.geometryOf(id), { id: id as string, data: node.data }, from, next, label,\n      );\n      if (projected) {\n        ops.push(projected.dataOp);\n        to = projected.pose;\n      }\n    }\n    ops.push(createTransformOp<unknown>({ id: id as string, from, to, label }));\n  }\n  return ops;\n}\n\n/** Commit the drag as one batch, so one undo entry. Returns whether anything\n *  reached the document. */\nexport function commitResize(session: ResizeSession, frame: ResizeFrame): boolean {\n  const { lifecycle } = session;\n  const target = {\n    scene: session.scene,\n    applyOps: session.applyOps,\n    adapter: defaultCommitAdapter(session.scene, session.selectionMethods),\n  };\n  const r = reduceBehaviorEnd(session.constraints, session.gestureCtx);\n  if (r === null) return false;\n  if (r !== undefined) return commitGestureOps(target, lifecycle, r);\n\n  if (frame.previews.size === 0) return false;\n  const ops = resizeOps(session, frame.previews, lifecycle.label);\n  if (ops.length === 0) return false;\n  return commitGestureOps(target, lifecycle, ops);\n}\n"],"mappings":";;;;;;AAaA,SAASA,EACP,GACA,GACA,GACA,GACA,GACA,GACsC;CACtC,IAAMC,IAAKC,EAAE,UAAUC,CAAI,GACrBC,IAAKF,EAAE,UAAUG,CAAI,GACrBC,IAAUC,EACdN,EAAG,GAAGA,EAAG,GAAGA,EAAG,OAAOA,EAAG,QACzBG,EAAG,GAAGA,EAAG,GAAGA,EAAG,OAAOA,EAAG,MAC3B,GACMI,IAASC,EAAeC,GAAY;EAAE,IAAIC,EAAK;EAAI,MAAMA,EAAK;EAAM,MAAMR;CAAK,GAAGG,GAAGM,CAAK;CAChG,IAAI,CAACJ,GAAQ,OAAO;CAOpB,IAAI,EAAEJ,EAAG,QAAQ,KAAKA,EAAG,SAAS,IAAI,OAAO;EAAE;EAAQ,MAAMC;CAAK;CAClE,IAAMQ,IAAK;EACT,GAAGT;EACH,GAAGA,EAAG,QAAQ,IAAIA,EAAG,IAAIA,EAAG,QAAQA,EAAG;EACvC,GAAGA,EAAG,SAAS,IAAIA,EAAG,IAAIA,EAAG,SAASA,EAAG;EACzC,OAAO,KAAK,IAAIA,EAAG,KAAK;EACxB,QAAQ,KAAK,IAAIA,EAAG,MAAM;CAC5B;CACA,OAAO;EAAE;EAAQ,MAAMF,EAAE,YAAYG,GAAMD,GAAIS,CAAE;CAAE;AACrD;AAKA,SAAgBC,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAMC,EAAO,UAAU;EAChC,IAAMZ,IAAOa,EAAS,IAAIF,CAAE;EAC5B,IAAIX,MAAS,KAAA,GAAW;EACxB,IAAMF,IAAOc,EAAO,WAAW,IAAID,CAAE;EACrC,IAAIb,MAAS,KAAA,GAAW;EACxB,IAAIgB,IAAcd,GACZM,IAAOM,EAAO,qBAAqBA,EAAO,MAAM,IAAID,CAAE,IAAI,KAAA;EAChE,IAAIC,EAAO,sBAAsBN,GAAM;GACrC,IAAMS,IAAYpB,EAChBiB,EAAO,oBAAoBA,EAAO,WAAWD,CAAE,GAAG;IAAM;IAAc,MAAML,EAAK;GAAK,GAAGR,GAAME,GAAMO,CACvG;GACA,AAAIQ,MACFL,EAAI,KAAKK,EAAU,MAAM,GACzB,IAAKA,EAAU;EAEnB;EACA,EAAI,KAAKC,EAA2B;GAAM;GAAc;GAAM;GAAI;EAAM,CAAC,CAAC;CAC5E;CACA,OAAON;AACT;AAIA,SAAgBO,EAAa,GAAwB,GAA6B;CAChF,IAAM,EAAE,iBAAcC,GAChBC,IAAS;EACb,OAAOD,EAAQ;EACf,UAAUA,EAAQ;EAClB,SAASE,EAAqBF,EAAQ,OAAOA,EAAQ,gBAAgB;CACvE,GACMG,IAAIC,EAAkBJ,EAAQ,aAAaA,EAAQ,UAAU;CACnE,IAAIG,MAAM,MAAM,OAAO;CACvB,IAAIA,MAAM,KAAA,GAAW,OAAOE,EAAiBJ,GAAQK,GAAWH,CAAC;CAEjE,IAAII,EAAM,SAAS,SAAS,GAAG,OAAO;CACtC,IAAMf,IAAMD,EAAUS,GAASO,EAAM,UAAUD,EAAU,KAAK;CAE9D,OADId,EAAI,WAAW,KACZa,EAAiBJ,GAAQK,GAAWd,CAAG;AAChD"}
+{"version":3,"file":"commit.js","names":[],"sources":["../../../../src/interactions/actions/resize/commit.ts"],"sourcesContent":["import { boxToBox, type Affine } from '@weasel-js/geom';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { NodeId } from 'core/scene/types';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\nimport { commitGestureOps, reduceBehaviorEnd } from '../gestureLifecycle';\nimport type { PoseDescriptor } from './geometry';\nimport type { ResizeFrame, ResizeSession } from './session';\n\n/** The op mapping a leaf's data-held geometry by the box→box affine its pose\n *  underwent, and the pose to commit beside it. Null when the projection\n *  leaves this node's data alone. */\nfunction projectedGeometry(\n  projection: GeometryProjection,\n  g: PoseDescriptor<unknown>,\n  node: { id: string; data: unknown },\n  from: unknown,\n  next: unknown,\n  label: string,\n): { dataOp: Op; pose: unknown } | null {\n  const sb = g.getBounds(from);\n  const db = g.getBounds(next);\n  const m: Affine = boxToBox(\n    sb.x, sb.y, sb.width, sb.height,\n    db.x, db.y, db.width, db.height,\n  );\n  const dataOp = geometryDataOp(projection, { id: node.id, data: node.data, pose: from }, m, label);\n  if (!dataOp) return null;\n  // The data absorbed the affine — including any mirror from a\n  // drag past the opposite edge — so the pose must commit as a\n  // normalized AABB. Leaving signed extents on the pose makes\n  // the node unhittable (hit-testing assumes normalized boxes).\n  // Without the seam the signed pose is kept: a bare-AABB pose\n  // is the only carrier of the flip there.\n  if (!(db.width < 0 || db.height < 0)) return { dataOp, pose: next };\n  const nb = {\n    ...db,\n    x: db.width < 0 ? db.x + db.width : db.x,\n    y: db.height < 0 ? db.y + db.height : db.y,\n    width: Math.abs(db.width),\n    height: Math.abs(db.height),\n  };\n  return { dataOp, pose: g.remapBounds(next, db, nb) };\n}\n\n/** One transform op per write id, `from` the pose stored at press and `to`\n *  its preview, each preceded by its data op when the geometry projection\n *  answers for the node. */\nexport function resizeOps(\n  leaves: Pick<ResizeSession, 'scene' | 'writeIds' | 'startPoses' | 'geometryOf' | 'geometryProjection'>,\n  previews: ReadonlyMap<NodeId, unknown>,\n  label: string,\n): Op[] {\n  const ops: Op[] = [];\n  for (const id of leaves.writeIds) {\n    const next = previews.get(id);\n    if (next === undefined) continue;\n    const from = leaves.startPoses.get(id);\n    if (from === undefined) continue;\n    let to: unknown = next;\n    const node = leaves.geometryProjection ? leaves.scene.get(id) : undefined;\n    if (leaves.geometryProjection && node) {\n      const projected = projectedGeometry(\n        leaves.geometryProjection, leaves.geometryOf(id), { id: id as string, data: node.data }, from, next, label,\n      );\n      if (projected) {\n        ops.push(projected.dataOp);\n        to = projected.pose;\n      }\n    }\n    ops.push(createTransformOp<unknown>({ id: id as string, from, to, label }));\n  }\n  return ops;\n}\n\n/** Commit the drag as one batch, so one undo entry. Returns whether anything\n *  reached the document. */\nexport function commitResize(session: ResizeSession, frame: ResizeFrame): boolean {\n  const { lifecycle } = session;\n  const target = {\n    scene: session.scene,\n    applyOps: session.applyOps,\n    adapter: defaultCommitAdapter(session.scene, session.selectionMethods),\n  };\n  const r = reduceBehaviorEnd(session.constraints, session.gestureCtx);\n  if (r === null) return false;\n  if (r !== undefined) return commitGestureOps(target, lifecycle, r);\n\n  if (frame.previews.size === 0) return false;\n  const ops = resizeOps(session, frame.previews, lifecycle.label);\n  if (ops.length === 0) return false;\n  return commitGestureOps(target, lifecycle, ops);\n}\n"],"mappings":";;;;;;;;;;AAaA,SAAS,kBACP,YACA,GACA,MACA,MACA,MACA,OACsC;CACtC,MAAM,KAAK,EAAE,UAAU,IAAI;CAC3B,MAAM,KAAK,EAAE,UAAU,IAAI;CAC3B,MAAM,IAAY,SAChB,GAAG,GAAG,GAAG,GAAG,GAAG,OAAO,GAAG,QACzB,GAAG,GAAG,GAAG,GAAG,GAAG,OAAO,GAAG,MAC3B;CACA,MAAM,SAAS,eAAe,YAAY;EAAE,IAAI,KAAK;EAAI,MAAM,KAAK;EAAM,MAAM;CAAK,GAAG,GAAG,KAAK;CAChG,IAAI,CAAC,QAAQ,OAAO;CAOpB,IAAI,EAAE,GAAG,QAAQ,KAAK,GAAG,SAAS,IAAI,OAAO;EAAE;EAAQ,MAAM;CAAK;CAClE,MAAM,KAAK;EACT,GAAG;EACH,GAAG,GAAG,QAAQ,IAAI,GAAG,IAAI,GAAG,QAAQ,GAAG;EACvC,GAAG,GAAG,SAAS,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG;EACzC,OAAO,KAAK,IAAI,GAAG,KAAK;EACxB,QAAQ,KAAK,IAAI,GAAG,MAAM;CAC5B;CACA,OAAO;EAAE;EAAQ,MAAM,EAAE,YAAY,MAAM,IAAI,EAAE;CAAE;AACrD;;;;AAKA,SAAgB,UACd,QACA,UACA,OACM;CACN,MAAM,MAAY,CAAC;CACnB,KAAK,MAAM,MAAM,OAAO,UAAU;EAChC,MAAM,OAAO,SAAS,IAAI,EAAE;EAC5B,IAAI,SAAS,QAAW;EACxB,MAAM,OAAO,OAAO,WAAW,IAAI,EAAE;EACrC,IAAI,SAAS,QAAW;EACxB,IAAI,KAAc;EAClB,MAAM,OAAO,OAAO,qBAAqB,OAAO,MAAM,IAAI,EAAE,IAAI;EAChE,IAAI,OAAO,sBAAsB,MAAM;GACrC,MAAM,YAAY,kBAChB,OAAO,oBAAoB,OAAO,WAAW,EAAE,GAAG;IAAM;IAAc,MAAM,KAAK;GAAK,GAAG,MAAM,MAAM,KACvG;GACA,IAAI,WAAW;IACb,IAAI,KAAK,UAAU,MAAM;IACzB,KAAK,UAAU;GACjB;EACF;EACA,IAAI,KAAK,kBAA2B;GAAM;GAAc;GAAM;GAAI;EAAM,CAAC,CAAC;CAC5E;CACA,OAAO;AACT;;;AAIA,SAAgB,aAAa,SAAwB,OAA6B;CAChF,MAAM,EAAE,cAAc;CACtB,MAAM,SAAS;EACb,OAAO,QAAQ;EACf,UAAU,QAAQ;EAClB,SAAS,qBAAqB,QAAQ,OAAO,QAAQ,gBAAgB;CACvE;CACA,MAAM,IAAI,kBAAkB,QAAQ,aAAa,QAAQ,UAAU;CACnE,IAAI,MAAM,MAAM,OAAO;CACvB,IAAI,MAAM,QAAW,OAAO,iBAAiB,QAAQ,WAAW,CAAC;CAEjE,IAAI,MAAM,SAAS,SAAS,GAAG,OAAO;CACtC,MAAM,MAAM,UAAU,SAAS,MAAM,UAAU,UAAU,KAAK;CAC9D,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,OAAO,iBAAiB,QAAQ,WAAW,GAAG;AAChD"}

package/dist/interactions/actions/resize/cornerHandles.js

@@ -1,5 +1,15 @@
+import { pxExtentIn } from "../../../core/geometry/targetFrame.js";
+
 //#region src/interactions/actions/resize/cornerHandles.ts
-var e = [
+/**
+* The single ordered resize-handle table: the four corners (TL, TR, BL, BR),
+* then the four edge midpoints (top, right, bottom, left). Order is
+* **load-bearing**: the resize-handle affordance, the selection overlay and
+* `cornerResizeHandles` all iterate it in this sequence, so the i-th handle
+* means the same thing to each. A corner pins the diagonally opposite corner;
+* an edge pins the opposite edge and leaves the other axis free.
+*/
+var RESIZE_HANDLE_ANCHORS = [
 	{
 		xEdge: "min",
 		yEdge: "min",
@@ -39,34 +49,161 @@ var e = [
 		},
 		kind: "handle:bottom-right",
 		tag: "max-max"
+	},
+	{
+		xEdge: "mid",
+		yEdge: "min",
+		anchor: {
+			x: "free",
+			y: "max"
+		},
+		kind: "handle:top",
+		tag: "mid-min"
+	},
+	{
+		xEdge: "max",
+		yEdge: "mid",
+		anchor: {
+			x: "min",
+			y: "free"
+		},
+		kind: "handle:right",
+		tag: "max-mid"
+	},
+	{
+		xEdge: "mid",
+		yEdge: "max",
+		anchor: {
+			x: "free",
+			y: "min"
+		},
+		kind: "handle:bottom",
+		tag: "mid-max"
+	},
+	{
+		xEdge: "min",
+		yEdge: "mid",
+		anchor: {
+			x: "max",
+			y: "free"
+		},
+		kind: "handle:left",
+		tag: "min-mid"
 	}
 ];
-function t(e, t) {
+/** True for a corner entry of {@link RESIZE_HANDLE_ANCHORS}. */
+function isCornerHandle(entry) {
+	return entry.xEdge !== "mid" && entry.yEdge !== "mid";
+}
+/** The corner entries of {@link RESIZE_HANDLE_ANCHORS}, in its order. */
+var CORNER_ANCHORS = RESIZE_HANDLE_ANCHORS.filter(isCornerHandle);
+/** An edge handle sits this many hit radii on screen from each corner of the
+*  side it is on, at least: under that, it would crowd the corners and leave
+*  the body too little room to be grabbed. At the default 8 px radius, a
+*  side must span 48 px. */
+var EDGE_HANDLE_MIN_RADII = 6;
+/** Whether a body this size, in its own frame `xf`, has room for edge
+*  handles on screen: each side spans {@link EDGE_HANDLE_MIN_RADII} times
+*  `radiusPx`. Both sides, because a short side puts the two handles across
+*  it over the middle of the body. */
+function edgeHandlesFit(body, xf, scale, radiusPx) {
+	const floor = pxExtentIn(EDGE_HANDLE_MIN_RADII * radiusPx, scale, xf);
+	return Math.abs(body.width) >= floor.x && Math.abs(body.height) >= floor.y;
+}
+/** The handles a body gets in `layout`: every corner, then the edge
+*  midpoints when the layout has them and {@link edgeHandlesFit} at its hit
+*  radius. The answer the selection overlay paints; the hit-test reaches the
+*  same one through the regions' `edgeOf`. */
+function resizeHandlesFor(layout, body, xf, scale) {
+	return layout.edges && edgeHandlesFit(body, xf, scale, layout.hitRadiusPx) ? RESIZE_HANDLE_ANCHORS : CORNER_ANCHORS;
+}
+/** Resolve a handle's position for the given bounds, in the bounds' frame:
+*  `'min'` → the origin edge, `'max'` → origin + extent, `'mid'` → between. */
+function handlePoint(bounds, entry) {
 	return {
-		x: t.xEdge === "max" ? e.x + e.width : e.x,
-		y: t.yEdge === "max" ? e.y + e.height : e.y
+		x: bounds.x + bounds.width * EDGE_FRACTION[entry.xEdge],
+		y: bounds.y + bounds.height * EDGE_FRACTION[entry.yEdge]
 	};
 }
-function n(n) {
-	return e.map((e) => {
-		let r = t(n, e);
+var EDGE_FRACTION = {
+	min: 0,
+	mid: .5,
+	max: 1
+};
+/** @deprecated Use {@link handlePoint}, which also places edge handles. */
+var cornerPoint = handlePoint;
+/** Standard 4-corner resize-handle layout: each corner pins the opposite
+*  corner via an anchor of `{x: 'min'|'max', y: 'min'|'max'}` so dragging it
+*  scales the box from the fixed opposite corner. Decodes {@link CORNER_ANCHORS}
+*  against `bounds`; edge handles are the affordance's, which knows the view. */
+function cornerResizeHandles(bounds) {
+	return CORNER_ANCHORS.map((c) => {
+		const p = handlePoint(bounds, c);
 		return {
-			cx: r.x,
-			cy: r.y,
-			anchor: e.anchor
+			cx: p.x,
+			cy: p.y,
+			anchor: c.anchor
 		};
 	});
 }
-function r(e, t, n, r) {
-	return Math.abs(t - e.cx) <= r && Math.abs(n - e.cy) <= r;
+/** Square hit-test for a handle: returns true if `(px, py)` is within
+*  `radius` of the handle center on both axes. */
+function hitCornerHandle(handle, px, py, radius) {
+	return Math.abs(px - handle.cx) <= radius && Math.abs(py - handle.cy) <= radius;
+}
+/** The corner that does NOT move under a resize gesture with the given
+*  anchor. Used by the rotated-resize math to pin a world-space invariant.
+*
+*  Convention: `anchor.x === 'min'` means the min-x (left) edge is the
+*  fixed anchor, so the fixed corner sits at `x = bounds.x` (min-x).
+*  `anchor.x === 'max'` means the max-x (right) edge is fixed, so the
+*  fixed corner sits at `x = bounds.x + bounds.width`. `'free'` on an
+*  axis (an edge handle's other axis) pins the bounds' center on it: a drag
+*  leaves that extent alone, and an aspect lock grows it about the center. */
+function fixedCornerOf(bounds, anchor) {
+	return handlePoint(bounds, {
+		xEdge: PINNED[anchor.x],
+		yEdge: PINNED[anchor.y]
+	});
+}
+var PINNED = {
+	min: "min",
+	max: "max",
+	free: "mid"
+};
+/** The corner or edge midpoint of `bounds` a resize pinning `anchor` moves. */
+function movingPoint(bounds, anchor) {
+	return handlePoint(bounds, {
+		xEdge: MOVING[anchor.x],
+		yEdge: MOVING[anchor.y]
+	});
 }
-function i(e, t) {
+var MOVING = {
+	min: "max",
+	max: "min",
+	free: "mid"
+};
+/** `bounds` with the edges `anchor` leaves free moved by `(dx, dy)`, in its own axes. */
+function movedEdges(bounds, anchor, dx, dy) {
+	let { x, y, width, height } = bounds;
+	if (anchor.x === "min") width += dx;
+	else if (anchor.x === "max") {
+		x += dx;
+		width -= dx;
+	}
+	if (anchor.y === "min") height += dy;
+	else if (anchor.y === "max") {
+		y += dy;
+		height -= dy;
+	}
 	return {
-		x: t.x === "max" ? e.x + e.width : e.x,
-		y: t.y === "max" ? e.y + e.height : e.y
+		x,
+		y,
+		width,
+		height
 	};
 }
-//#endregion
-export { e as CORNER_ANCHORS, t as cornerPoint, n as cornerResizeHandles, i as fixedCornerOf, r as hitCornerHandle };
 
+//#endregion
+export { CORNER_ANCHORS, EDGE_HANDLE_MIN_RADII, RESIZE_HANDLE_ANCHORS, cornerPoint, cornerResizeHandles, edgeHandlesFit, fixedCornerOf, handlePoint, hitCornerHandle, isCornerHandle, movedEdges, movingPoint, resizeHandlesFor };
 //# sourceMappingURL=cornerHandles.js.map