@weasel-js/core 1.10.1 → 1.11.1

package/dist/interactions/actions/gestureFrames.js

@@ -1,18 +1,27 @@
-import { planeOf as e } from "./planeInput.js";
-import { scenePoseFrame as t } from "./poseFrame.js";
+import { scenePoseFrame } from "./poseFrame.js";
+import { planeOf } from "./planeInput.js";
+import { drawnBoxes } from "./drawnBoxes.js";
+
 //#region src/interactions/actions/gestureFrames.ts
-function n(n, r, i = t(n)) {
+/** A scene-backed gesture's {@link GestureFrames}, read through the action's deps. */
+function sceneGestureFrames(scene, deps, frame = scenePoseFrame(scene)) {
+	const view = deps.view;
+	let boxes;
 	return {
-		world: (e) => i.world(e),
-		toWorld: (e, t) => {
-			let n = i.parentWorld(e);
-			return n === null ? t : i.pc.compose(n, t);
+		drawnBounds: (id, worldPose) => (boxes ??= drawnBoxes({
+			...deps,
+			scene
+		}, frame)).aabb(id, worldPose),
+		world: (id) => frame.world(id),
+		toWorld: (id, pose) => {
+			const parent = frame.parentWorld(id);
+			return parent === null ? pose : frame.pc.compose(parent, pose);
 		},
-		toLocal: (e, t) => i.local(e, t),
-		planeOf: (t) => e(r, t)
+		toLocal: (id, worldPose) => frame.local(id, worldPose),
+		planeOf: (layer) => planeOf(view, layer)
 	};
 }
-//#endregion
-export { n as sceneGestureFrames };
 
+//#endregion
+export { sceneGestureFrames };
 //# sourceMappingURL=gestureFrames.js.map

package/dist/interactions/actions/gestureFrames.js.map

@@ -1 +1 @@
-{"version":3,"file":"gestureFrames.js","names":["sceneGestureFrames","scenePoseFrame","scene","frame","id","parent","pose","worldPose","planeOf","view","layer"],"sources":["../../../src/interactions/actions/gestureFrames.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { GestureFrames } from '../gestures/types';\nimport { planeOf } from './planeInput';\nimport { scenePoseFrame, type PoseFrame } from './poseFrame';\n\n/** A scene-backed gesture's {@link GestureFrames}. `view` is the `view` dep. */\nexport function sceneGestureFrames(\n  scene: Scene<unknown, string, unknown>,\n  view: unknown,\n  frame: PoseFrame<unknown> = scenePoseFrame(scene),\n): GestureFrames<unknown> {\n  return {\n    world: (id) => frame.world(id as NodeId),\n    toWorld: (id, pose) => {\n      const parent = frame.parentWorld(id as NodeId);\n      return parent === null ? pose : frame.pc.compose(parent, pose);\n    },\n    toLocal: (id, worldPose) => frame.local(id as NodeId, worldPose),\n    planeOf: (layer) => planeOf(view, layer),\n  };\n}\n"],"mappings":";;;AAMA,SAAgBA,EACd,GACA,GACA,IAA4BC,EAAeC,CAAK,GACxB;CACxB,OAAO;EACL,QAAQ,MAAOC,EAAM,MAAMC,CAAY;EACvC,UAAU,GAAI,MAAS;GACrB,IAAMC,IAASF,EAAM,YAAYC,CAAY;GAC7C,OAAOC,MAAW,OAAOC,IAAOH,EAAM,GAAG,QAAQE,GAAQC,CAAI;EAC/D;EACA,UAAU,GAAI,MAAcH,EAAM,MAAMC,GAAcG,CAAS;EAC/D,UAAU,MAAUC,EAAQC,GAAMC,CAAK;CACzC;AACF"}
+{"version":3,"file":"gestureFrames.js","names":[],"sources":["../../../src/interactions/actions/gestureFrames.ts"],"sourcesContent":["import type { ActionDeps } from '@weasel-js/routing';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { drawnBoxes, type DrawnBoxes } from './drawnBoxes';\nimport type { GestureFrames } from '../gestures/types';\nimport { planeOf } from './planeInput';\nimport { scenePoseFrame, type PoseFrame } from './poseFrame';\n\n/** A scene-backed gesture's {@link GestureFrames}, read through the action's deps. */\nexport function sceneGestureFrames(\n  scene: Scene<unknown, string, unknown>,\n  deps: Pick<ActionDeps, 'view' | 'poseDescriptor' | 'boundsIncludeStroke'>,\n  frame: PoseFrame<unknown> = scenePoseFrame(scene),\n): GestureFrames<unknown> {\n  const view = deps.view;\n  let boxes: DrawnBoxes | undefined;\n  return {\n    drawnBounds: (id, worldPose) => (boxes ??= drawnBoxes({ ...deps, scene }, frame)).aabb(id, worldPose),\n    world: (id) => frame.world(id as NodeId),\n    toWorld: (id, pose) => {\n      const parent = frame.parentWorld(id as NodeId);\n      return parent === null ? pose : frame.pc.compose(parent, pose);\n    },\n    toLocal: (id, worldPose) => frame.local(id as NodeId, worldPose),\n    planeOf: (layer) => planeOf(view, layer),\n  };\n}\n"],"mappings":";;;;;;AAQA,SAAgB,mBACd,OACA,MACA,QAA4B,eAAe,KAAK,GACxB;CACxB,MAAM,OAAO,KAAK;CAClB,IAAI;CACJ,OAAO;EACL,cAAc,IAAI,eAAe,UAAU,WAAW;GAAE,GAAG;GAAM;EAAM,GAAG,KAAK,EAAA,CAAG,KAAK,IAAI,SAAS;EACpG,QAAQ,OAAO,MAAM,MAAM,EAAY;EACvC,UAAU,IAAI,SAAS;GACrB,MAAM,SAAS,MAAM,YAAY,EAAY;GAC7C,OAAO,WAAW,OAAO,OAAO,MAAM,GAAG,QAAQ,QAAQ,IAAI;EAC/D;EACA,UAAU,IAAI,cAAc,MAAM,MAAM,IAAc,SAAS;EAC/D,UAAU,UAAU,QAAQ,MAAM,KAAK;CACzC;AACF"}

package/dist/interactions/actions/gestureLifecycle.js

@@ -1,71 +1,119 @@
-import { SceneArrivalRefused as e } from "../../core/scene/arrivals.js";
+import { SceneArrivalRefused } from "../../core/scene/arrivals.js";
+
 //#region src/interactions/actions/gestureLifecycle.ts
-function t(e) {
-	let t = {};
-	return e.label !== void 0 && (t.label = e.label), e.transient !== void 0 && (t.transient = e.transient), e.onGestureStart && (t.onGestureStart = e.onGestureStart), e.onGestureEnd && (t.onGestureEnd = e.onGestureEnd), t;
+/** The params entries for {@link GestureLifecycleOptions}, with the unset
+*  keys left out. */
+function gestureLifecycleParams(o) {
+	const out = {};
+	if (o.label !== void 0) out.label = o.label;
+	if (o.transient !== void 0) out.transient = o.transient;
+	if (o.onGestureStart) out.onGestureStart = o.onGestureStart;
+	if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;
+	return out;
 }
-function n(e, t, n = []) {
-	let r = e ?? {}, i = !1, a = !1;
+function readGestureLifecycle(source, defaultLabel, behaviors = []) {
+	const o = source ?? {};
+	let started = false;
+	let ended = false;
 	return {
-		label: r.label ?? t,
-		labelFor: (e) => r.label ?? e[0]?.label ?? t,
-		transient: r.transient ?? n.some((e) => e.defaultTransient === !0),
-		start(e) {
-			i || (i = !0, r.onGestureStart?.([...e]));
+		label: o.label ?? defaultLabel,
+		labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,
+		transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),
+		start(ids) {
+			if (started) return;
+			started = true;
+			o.onGestureStart?.([...ids]);
 		},
-		end(e) {
-			i && !a && (a = !0, r.onGestureEnd?.(e));
+		end(committed) {
+			if (!started || ended) return;
+			ended = true;
+			o.onGestureEnd?.(committed);
 		}
 	};
 }
-function r(t, n, r) {
-	if (n.transient) {
+/** Commit a gesture's ops, finished by `target.finish` when it has one:
+*  untracked when transient, else through the
+*  consumer `applyOps` hook when one is wired, else into the scene's history.
+*  Returns whether the commit landed: false when a container refused what
+*  the ops brought it, which the scene reverts. A consumer's `applyOps` may
+*  keep the document elsewhere, so it is taken at its word. */
+function commitGestureOps(target, lifecycle, given) {
+	const ops = target.finish ? target.finish(given, lifecycle.labelFor(given)) : given;
+	if (!ops) return false;
+	if (lifecycle.transient) {
 		try {
-			t.scene.untracked(() => {
-				for (let e of r) e.apply(t.adapter);
+			target.scene.untracked(() => {
+				for (const op of ops) op.apply(target.adapter);
 			});
-		} catch (t) {
-			if (!(t instanceof e)) throw t;
-			return !1;
+		} catch (err) {
+			if (!(err instanceof SceneArrivalRefused)) throw err;
+			return false;
 		}
-		return !0;
+		return true;
 	}
-	let i = n.labelFor(r);
-	return t.applyOps ? (t.applyOps(r, i), !0) : t.scene.applyBatch(r, i, t.adapter);
+	const label = lifecycle.labelFor(ops);
+	if (!target.applyOps) return target.scene.applyBatch(ops, label, target.adapter);
+	target.applyOps(ops, label);
+	return true;
 }
-function i(e, t, ...[n]) {
-	let r, i = !1;
-	return a(e, (e) => {
+/** Runs every behavior's `onEnd` in order; the first that answers decides the
+*  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an
+*  empty array included), and `undefined` means every behavior deferred to the
+*  action's own commit. An action whose behaviors take more than a plain
+*  `BehaviorEnd` passes the rest as `own`; each `onEnd` gets it beside
+*  `answered`. One that throws does not stop the rest, which are told the
+*  commit is decided; its error is rethrown after, so nothing commits. */
+function reduceBehaviorEnd(behaviors, ctx, ...[own]) {
+	let answer;
+	let threw = false;
+	runEvery(behaviors, (b) => {
 		try {
-			let a = e.onEnd?.(t, {
-				...n,
-				answered: i || r !== void 0
+			const r = b.onEnd?.(ctx, {
+				...own,
+				answered: threw || answer !== void 0
 			});
-			r === void 0 && a !== void 0 && (r = a);
-		} catch (e) {
-			throw i = !0, e;
+			if (answer === void 0 && r !== void 0) answer = r;
+		} catch (err) {
+			threw = true;
+			throw err;
 		}
-	}), r;
+	});
+	return answer;
 }
-function a(e, t) {
-	let n = [];
-	for (let r of e) try {
-		t(r);
-	} catch (e) {
-		n.push(e);
+/** Runs `step` for every item, a throwing one included, then rethrows the
+*  first error. For steps that each release something of their own. */
+function runEvery(items, step) {
+	const errors = [];
+	for (const item of items) try {
+		step(item);
+	} catch (err) {
+		errors.push(err);
 	}
-	if (n.length > 0) throw n[0];
+	if (errors.length > 0) throw errors[0];
 }
-function o(e, t) {
-	a(e, (e) => e.onCancel?.(t));
+/** Runs every behavior's `onCancel`, for a gesture closing without a commit.
+*  One that throws does not stop the rest; its error is rethrown after. */
+function runBehaviorCancel(behaviors, ctx) {
+	runEvery(behaviors, (b) => b.onCancel?.(ctx));
 }
-function s(e, t, n) {
-	a(e, (e) => e.onSettled?.(t, n));
+/** Runs every behavior's `onSettled`, once the gesture's commit has landed or
+*  its cancel has run. One that throws does not stop the rest; its error is
+*  rethrown after. */
+function runBehaviorSettled(behaviors, ctx, committed) {
+	runEvery(behaviors, (b) => b.onSettled?.(ctx, committed));
 }
-function c(e, t) {
-	e.hold.drop(), e.previews.clear(), a([() => s(e.behaviors, e.ctx, t), () => e.lifecycle.end(t)], (e) => e());
+/**
+* The close a transform action runs from its `finally`, commit or cancel:
+* drop the preview overrides, tell the behaviors, then fire `onGestureEnd`,
+* which fires even when a behavior's `onSettled` throws; the first error is
+* rethrown.
+*/
+function closeGesture(gesture, committed) {
+	gesture.hold.drop();
+	gesture.previews.clear();
+	runEvery([() => runBehaviorSettled(gesture.behaviors, gesture.ctx, committed), () => gesture.lifecycle.end(committed)], (step) => step());
 }
-//#endregion
-export { c as closeGesture, r as commitGestureOps, t as gestureLifecycleParams, n as readGestureLifecycle, i as reduceBehaviorEnd, o as runBehaviorCancel, s as runBehaviorSettled };
 
+//#endregion
+export { closeGesture, commitGestureOps, gestureLifecycleParams, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel, runBehaviorSettled };
 //# sourceMappingURL=gestureLifecycle.js.map

package/dist/interactions/actions/gestureLifecycle.js.map

@@ -1 +1 @@
-{"version":3,"file":"gestureLifecycle.js","names":["gestureLifecycleParams","out","o","readGestureLifecycle","source","started","ended","defaultLabel","ops","behaviors","b","ids","committed","commitGestureOps","lifecycle","op","target","err","SceneArrivalRefused","label","reduceBehaviorEnd","own","answer","threw","runEvery","r","ctx","errors","item","items","runBehaviorCancel","runBehaviorSettled","closeGesture","gesture","step"],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport { SceneArrivalRefused } from 'core/scene/arrivals';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\nimport type { NodeId, PoseHold } from 'core/scene/types';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops: untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history.\n *  Returns whether the commit landed: false when a container refused what\n *  the ops brought it, which the scene reverts. A consumer's `applyOps` may\n *  keep the document elsewhere, so it is taken at its word. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n  },\n  lifecycle: GestureLifecycle,\n  ops: Op[],\n): boolean {\n  if (lifecycle.transient) {\n    try {\n      target.scene.untracked(() => {\n        for (const op of ops) op.apply(target.adapter);\n      });\n    } catch (err) {\n      // `untracked` lets a refused arrival out; `applyBatch` swallows it.\n      if (!(err instanceof SceneArrivalRefused)) throw err;\n      return false;\n    }\n    return true;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (!target.applyOps) return target.scene.applyBatch(ops, label, target.adapter);\n  target.applyOps(ops, label);\n  return true;\n}\n\n/** The trailing argument of {@link reduceBehaviorEnd}: what `TEnd` adds to\n *  `BehaviorEnd`, required exactly when it adds something. */\ntype OwnEndFields<TEnd extends BehaviorEnd> = keyof Omit<TEnd, keyof BehaviorEnd> extends never\n  ? [own?: Omit<TEnd, keyof BehaviorEnd>]\n  : [own: Omit<TEnd, keyof BehaviorEnd>];\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. An action whose behaviors take more than a plain\n *  `BehaviorEnd` passes the rest as `own`; each `onEnd` gets it beside\n *  `answered`. One that throws does not stop the rest, which are told the\n *  commit is decided; its error is rethrown after, so nothing commits. */\nexport function reduceBehaviorEnd<TCtx, TEnd extends BehaviorEnd = BehaviorEnd>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: TEnd): Op[] | null | void }[],\n  ctx: TCtx,\n  ...[own]: OwnEndFields<TEnd>\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  let threw = false;\n  runEvery(behaviors, (b) => {\n    try {\n      const r = b.onEnd?.(ctx, { ...own, answered: threw || answer !== undefined } as TEnd);\n      if (answer === undefined && r !== undefined) answer = r;\n    } catch (err) {\n      threw = true;\n      throw err;\n    }\n  });\n  return answer;\n}\n\n/** Runs `step` for every item, a throwing one included, then rethrows the\n *  first error. For steps that each release something of their own. */\nfunction runEvery<T>(items: readonly T[], step: (item: T) => void): void {\n  const errors: unknown[] = [];\n  for (const item of items) {\n    try {\n      step(item);\n    } catch (err) {\n      errors.push(err);\n    }\n  }\n  if (errors.length > 0) throw errors[0];\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit.\n *  One that throws does not stop the rest; its error is rethrown after. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  runEvery(behaviors, (b) => b.onCancel?.(ctx));\n}\n\n/** Runs every behavior's `onSettled`, once the gesture's commit has landed or\n *  its cancel has run. One that throws does not stop the rest; its error is\n *  rethrown after. */\nexport function runBehaviorSettled<TCtx>(\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[],\n  ctx: TCtx,\n  committed: boolean,\n): void {\n  runEvery(behaviors, (b) => b.onSettled?.(ctx, committed));\n}\n\n/** What {@link closeGesture} closes. */\nexport interface ClosingGesture<TCtx> {\n  hold: PoseHold<unknown>;\n  /** The action's own buffer of this frame's poses, emptied at the close. */\n  previews: Map<NodeId, unknown>;\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[];\n  ctx: TCtx;\n  lifecycle: GestureLifecycle;\n}\n\n/**\n * The close a transform action runs from its `finally`, commit or cancel:\n * drop the preview overrides, tell the behaviors, then fire `onGestureEnd`,\n * which fires even when a behavior's `onSettled` throws; the first error is\n * rethrown.\n */\nexport function closeGesture<TCtx>(gesture: ClosingGesture<TCtx>, committed: boolean): void {\n  gesture.hold.drop();\n  gesture.previews.clear();\n  runEvery([\n    () => runBehaviorSettled(gesture.behaviors, gesture.ctx, committed),\n    () => gesture.lifecycle.end(committed),\n  ], (step) => step());\n}\n"],"mappings":";;AAkCA,SAAgBA,EAAuB,GAAqD;CAC1F,IAAMC,IAA+B,CAAC;CAKtC,OAJIC,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACrCA,EAAE,cAAc,KAAA,MAAW,EAAI,YAAYA,EAAE,YAC7CA,EAAE,mBAAgB,EAAI,iBAAiBA,EAAE,iBACzCA,EAAE,iBAAc,EAAI,eAAeA,EAAE,eAClCD;AACT;AAcA,SAAgBE,EACd,GACA,GACA,IAAuD,CAAC,GACtC;CAClB,IAAMD,IAAKE,KAAU,CAAC,GAClBC,IAAU,IACVC,IAAQ;CACZ,OAAO;EACL,OAAOJ,EAAE,SAASK;EAClB,WAAW,MAAQL,EAAE,SAASM,EAAI,EAAE,EAAE,SAASD;EAC/C,WAAWL,EAAE,aAAaO,EAAU,MAAM,MAAMC,EAAE,qBAAqB,EAAI;EAC3E,MAAM,GAAK;GACT,AAAIL,MACJ,IAAU,IACVH,EAAE,iBAAiB,CAAC,GAAGS,CAAG,CAAC;EAC7B;EACA,IAAI,GAAW;GACb,AAAKN,KAAW,OAChB,IAAQ,IACRH,EAAE,eAAeU,CAAS;EAC5B;CACF;AACF;AAOA,SAAgBC,EACd,GAKA,GACA,GACS;CACT,IAAIC,EAAU,WAAW;EACvB,IAAI;GACF,EAAO,MAAM,gBAAgB;IAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;GAC/C,CAAC;EACH,SAASC,GAAK;GAEZ,IAAI,EAAEA,aAAeC,IAAsB,MAAMD;GACjD,OAAO;EACT;EACA,OAAO;CACT;CACA,IAAME,IAAQL,EAAU,SAASN,CAAG;CAGpC,OAFKQ,EAAO,YACZA,EAAO,SAASR,GAAKW,CAAK,GACnB,MAFsBH,EAAO,MAAM,WAAWR,GAAKW,GAAOH,EAAO,OAAO;AAGjF;AAeA,SAAgBI,EACd,GACA,GACA,GAAG,CAACC,IACqB;CACzB,IAAIC,GACAC,IAAQ;CAUZ,OATAC,EAASf,IAAY,MAAM;EACzB,IAAI;GACF,IAAMgB,IAAIf,EAAE,QAAQgB,GAAK;IAAE,GAAGL;IAAK,UAAUE,KAASD,MAAW,KAAA;GAAU,CAAS;GACpF,AAAIA,MAAW,KAAA,KAAaG,MAAM,KAAA,MAAW,IAASA;EACxD,SAASR,GAAK;GAEZ,MADA,IAAQ,IACFA;EACR;CACF,CAAC,GACMK;AACT;AAIA,SAASE,EAAY,GAAqB,GAA+B;CACvE,IAAMG,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAQC,GACjB,IAAI;EACF,EAAKD,CAAI;CACX,SAASX,GAAK;EACZ,EAAO,KAAKA,CAAG;CACjB;CAEF,IAAIU,EAAO,SAAS,GAAG,MAAMA,EAAO;AACtC;AAIA,SAAgBG,EACd,GACA,GACM;CACN,EAASrB,IAAY,MAAMC,EAAE,WAAWgB,CAAG,CAAC;AAC9C;AAKA,SAAgBK,EACd,GACA,GACA,GACM;CACN,EAAStB,IAAY,MAAMC,EAAE,YAAYgB,GAAKd,CAAS,CAAC;AAC1D;AAkBA,SAAgBoB,EAAmB,GAA+B,GAA0B;CAG1F,AAFAC,EAAQ,KAAK,KAAK,GAClBA,EAAQ,SAAS,MAAM,GACvBT,EAAS,OACDO,EAAmBE,EAAQ,WAAWA,EAAQ,KAAKrB,CAAS,SAC5DqB,EAAQ,UAAU,IAAIrB,CAAS,CACvC,IAAI,MAASsB,EAAK,CAAC;AACrB"}
+{"version":3,"file":"gestureLifecycle.js","names":[],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport { SceneArrivalRefused } from 'core/scene/arrivals';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\nimport type { NodeId, PoseHold } from 'core/scene/types';\nimport type { TransformFinisher } from './transformFinish';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops, finished by `target.finish` when it has one:\n *  untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history.\n *  Returns whether the commit landed: false when a container refused what\n *  the ops brought it, which the scene reverts. A consumer's `applyOps` may\n *  keep the document elsewhere, so it is taken at its word. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n    finish?: TransformFinisher;\n  },\n  lifecycle: GestureLifecycle,\n  given: Op[],\n): boolean {\n  const ops = target.finish ? target.finish(given, lifecycle.labelFor(given)) : given;\n  if (!ops) return false;\n  if (lifecycle.transient) {\n    try {\n      target.scene.untracked(() => {\n        for (const op of ops) op.apply(target.adapter);\n      });\n    } catch (err) {\n      // `untracked` lets a refused arrival out; `applyBatch` swallows it.\n      if (!(err instanceof SceneArrivalRefused)) throw err;\n      return false;\n    }\n    return true;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (!target.applyOps) return target.scene.applyBatch(ops, label, target.adapter);\n  target.applyOps(ops, label);\n  return true;\n}\n\n/** The trailing argument of {@link reduceBehaviorEnd}: what `TEnd` adds to\n *  `BehaviorEnd`, required exactly when it adds something. */\ntype OwnEndFields<TEnd extends BehaviorEnd> = keyof Omit<TEnd, keyof BehaviorEnd> extends never\n  ? [own?: Omit<TEnd, keyof BehaviorEnd>]\n  : [own: Omit<TEnd, keyof BehaviorEnd>];\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. An action whose behaviors take more than a plain\n *  `BehaviorEnd` passes the rest as `own`; each `onEnd` gets it beside\n *  `answered`. One that throws does not stop the rest, which are told the\n *  commit is decided; its error is rethrown after, so nothing commits. */\nexport function reduceBehaviorEnd<TCtx, TEnd extends BehaviorEnd = BehaviorEnd>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: TEnd): Op[] | null | void }[],\n  ctx: TCtx,\n  ...[own]: OwnEndFields<TEnd>\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  let threw = false;\n  runEvery(behaviors, (b) => {\n    try {\n      const r = b.onEnd?.(ctx, { ...own, answered: threw || answer !== undefined } as TEnd);\n      if (answer === undefined && r !== undefined) answer = r;\n    } catch (err) {\n      threw = true;\n      throw err;\n    }\n  });\n  return answer;\n}\n\n/** Runs `step` for every item, a throwing one included, then rethrows the\n *  first error. For steps that each release something of their own. */\nfunction runEvery<T>(items: readonly T[], step: (item: T) => void): void {\n  const errors: unknown[] = [];\n  for (const item of items) {\n    try {\n      step(item);\n    } catch (err) {\n      errors.push(err);\n    }\n  }\n  if (errors.length > 0) throw errors[0];\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit.\n *  One that throws does not stop the rest; its error is rethrown after. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  runEvery(behaviors, (b) => b.onCancel?.(ctx));\n}\n\n/** Runs every behavior's `onSettled`, once the gesture's commit has landed or\n *  its cancel has run. One that throws does not stop the rest; its error is\n *  rethrown after. */\nexport function runBehaviorSettled<TCtx>(\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[],\n  ctx: TCtx,\n  committed: boolean,\n): void {\n  runEvery(behaviors, (b) => b.onSettled?.(ctx, committed));\n}\n\n/** What {@link closeGesture} closes. */\nexport interface ClosingGesture<TCtx> {\n  hold: PoseHold<unknown>;\n  /** The action's own buffer of this frame's poses, emptied at the close. */\n  previews: Map<NodeId, unknown>;\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[];\n  ctx: TCtx;\n  lifecycle: GestureLifecycle;\n}\n\n/**\n * The close a transform action runs from its `finally`, commit or cancel:\n * drop the preview overrides, tell the behaviors, then fire `onGestureEnd`,\n * which fires even when a behavior's `onSettled` throws; the first error is\n * rethrown.\n */\nexport function closeGesture<TCtx>(gesture: ClosingGesture<TCtx>, committed: boolean): void {\n  gesture.hold.drop();\n  gesture.previews.clear();\n  runEvery([\n    () => runBehaviorSettled(gesture.behaviors, gesture.ctx, committed),\n    () => gesture.lifecycle.end(committed),\n  ], (step) => step());\n}\n"],"mappings":";;;;;AAmCA,SAAgB,uBAAuB,GAAqD;CAC1F,MAAM,MAA+B,CAAC;CACtC,IAAI,EAAE,UAAU,QAAW,IAAI,QAAQ,EAAE;CACzC,IAAI,EAAE,cAAc,QAAW,IAAI,YAAY,EAAE;CACjD,IAAI,EAAE,gBAAgB,IAAI,iBAAiB,EAAE;CAC7C,IAAI,EAAE,cAAc,IAAI,eAAe,EAAE;CACzC,OAAO;AACT;AAcA,SAAgB,qBACd,QACA,cACA,YAAuD,CAAC,GACtC;CAClB,MAAM,IAAK,UAAU,CAAC;CACtB,IAAI,UAAU;CACd,IAAI,QAAQ;CACZ,OAAO;EACL,OAAO,EAAE,SAAS;EAClB,WAAW,QAAQ,EAAE,SAAS,IAAI,EAAE,EAAE,SAAS;EAC/C,WAAW,EAAE,aAAa,UAAU,MAAM,MAAM,EAAE,qBAAqB,IAAI;EAC3E,MAAM,KAAK;GACT,IAAI,SAAS;GACb,UAAU;GACV,EAAE,iBAAiB,CAAC,GAAG,GAAG,CAAC;EAC7B;EACA,IAAI,WAAW;GACb,IAAI,CAAC,WAAW,OAAO;GACvB,QAAQ;GACR,EAAE,eAAe,SAAS;EAC5B;CACF;AACF;;;;;;;AAQA,SAAgB,iBACd,QAMA,WACA,OACS;CACT,MAAM,MAAM,OAAO,SAAS,OAAO,OAAO,OAAO,UAAU,SAAS,KAAK,CAAC,IAAI;CAC9E,IAAI,CAAC,KAAK,OAAO;CACjB,IAAI,UAAU,WAAW;EACvB,IAAI;GACF,OAAO,MAAM,gBAAgB;IAC3B,KAAK,MAAM,MAAM,KAAK,GAAG,MAAM,OAAO,OAAO;GAC/C,CAAC;EACH,SAAS,KAAK;GAEZ,IAAI,EAAE,eAAe,sBAAsB,MAAM;GACjD,OAAO;EACT;EACA,OAAO;CACT;CACA,MAAM,QAAQ,UAAU,SAAS,GAAG;CACpC,IAAI,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,WAAW,KAAK,OAAO,OAAO,OAAO;CAC/E,OAAO,SAAS,KAAK,KAAK;CAC1B,OAAO;AACT;;;;;;;;AAeA,SAAgB,kBACd,WACA,KACA,GAAG,CAAC,MACqB;CACzB,IAAI;CACJ,IAAI,QAAQ;CACZ,SAAS,YAAY,MAAM;EACzB,IAAI;GACF,MAAM,IAAI,EAAE,QAAQ,KAAK;IAAE,GAAG;IAAK,UAAU,SAAS,WAAW;GAAU,CAAS;GACpF,IAAI,WAAW,UAAa,MAAM,QAAW,SAAS;EACxD,SAAS,KAAK;GACZ,QAAQ;GACR,MAAM;EACR;CACF,CAAC;CACD,OAAO;AACT;;;AAIA,SAAS,SAAY,OAAqB,MAA+B;CACvE,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,QAAQ,OACjB,IAAI;EACF,KAAK,IAAI;CACX,SAAS,KAAK;EACZ,OAAO,KAAK,GAAG;CACjB;CAEF,IAAI,OAAO,SAAS,GAAG,MAAM,OAAO;AACtC;;;AAIA,SAAgB,kBACd,WACA,KACM;CACN,SAAS,YAAY,MAAM,EAAE,WAAW,GAAG,CAAC;AAC9C;;;;AAKA,SAAgB,mBACd,WACA,KACA,WACM;CACN,SAAS,YAAY,MAAM,EAAE,YAAY,KAAK,SAAS,CAAC;AAC1D;;;;;;;AAkBA,SAAgB,aAAmB,SAA+B,WAA0B;CAC1F,QAAQ,KAAK,KAAK;CAClB,QAAQ,SAAS,MAAM;CACvB,SAAS,OACD,mBAAmB,QAAQ,WAAW,QAAQ,KAAK,SAAS,SAC5D,QAAQ,UAAU,IAAI,SAAS,CACvC,IAAI,SAAS,KAAK,CAAC;AACrB"}

package/dist/interactions/actions/hitSelection.js

@@ -1,8 +1,10 @@
 //#region src/interactions/actions/hitSelection.ts
-function e(e, t, n) {
-	return [...new Set(n ? [...e, ...t] : t)];
+/** The selection a hit list leaves behind: the hits alone, or, when the
+*  gesture extends the selection, the current ids with the new hits after them. */
+function selectionFromHits(current, hits, extend) {
+	return [...new Set(extend ? [...current, ...hits] : hits)];
 }
-//#endregion
-export { e as selectionFromHits };
 
+//#endregion
+export { selectionFromHits };
 //# sourceMappingURL=hitSelection.js.map

package/dist/interactions/actions/hitSelection.js.map

@@ -1 +1 @@
-{"version":3,"file":"hitSelection.js","names":["selectionFromHits","extend","current","hits"],"sources":["../../../src/interactions/actions/hitSelection.ts"],"sourcesContent":["/** The selection a hit list leaves behind: the hits alone, or, when the\n *  gesture extends the selection, the current ids with the new hits after them. */\nexport function selectionFromHits<T extends string>(\n  current: readonly T[],\n  hits: readonly T[],\n  extend: boolean,\n): T[] {\n  return [...new Set(extend ? [...current, ...hits] : hits)];\n}\n"],"mappings":";AAEA,SAAgBA,EACd,GACA,GACA,GACK;CACL,OAAO,CAAC,GAAG,IAAI,IAAIC,IAAS,CAAC,GAAGC,GAAS,GAAGC,CAAI,IAAIA,CAAI,CAAC;AAC3D"}
+{"version":3,"file":"hitSelection.js","names":[],"sources":["../../../src/interactions/actions/hitSelection.ts"],"sourcesContent":["/** The selection a hit list leaves behind: the hits alone, or, when the\n *  gesture extends the selection, the current ids with the new hits after them. */\nexport function selectionFromHits<T extends string>(\n  current: readonly T[],\n  hits: readonly T[],\n  extend: boolean,\n): T[] {\n  return [...new Set(extend ? [...current, ...hits] : hits)];\n}\n"],"mappings":";;;AAEA,SAAgB,kBACd,SACA,MACA,QACK;CACL,OAAO,CAAC,GAAG,IAAI,IAAI,SAAS,CAAC,GAAG,SAAS,GAAG,IAAI,IAAI,IAAI,CAAC;AAC3D"}

package/dist/interactions/actions/insert/action.js

@@ -1,19 +1,37 @@
-import { scenePaintedPoseOf as e } from "../../../canvas/derivedPath.js";
-import { runBehaviorSettled as t } from "../gestureLifecycle.js";
-import { inPlane as n, insertLayer as r } from "../planeInput.js";
-import { shapeKindInfo as i } from "../../../core/shapeKinds.js";
-import { copiesWithin as a } from "../../../canvas/copiesAbove.js";
-import { insertKind as o, insertShape as s } from "./shape.js";
-import { cancelInsert as c, commitInsert as l } from "./commit.js";
-import { beginInsert as u } from "./session.js";
-import { carryStart as d, nextFrame as f } from "./frame.js";
-import { resolveParams as p } from "@weasel-js/routing";
+import { scenePaintedPoseOf } from "../../../canvas/derivedPath.js";
+import { runBehaviorSettled } from "../gestureLifecycle.js";
+import { inPlane, insertLayer } from "../planeInput.js";
+import { SNAP_ROLES } from "../../../features/snap/roles.js";
+import { shapeKindInfo } from "../../../core/shapeKinds.js";
+import { copiesWithin } from "../../../canvas/copiesAbove.js";
+import { insertKind, insertShape } from "./shape.js";
+import { cancelInsert, commitInsert } from "./commit.js";
+import { beginInsert } from "./session.js";
+import { carryStart, nextFrame } from "./frame.js";
+import { resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/insert/action.ts
-var m = n({
+/**
+* Drag-to-insert. The node `kind` is read from `opts.params.kind`.
+*
+* The drag's start and current point snap through the `snap` dep's `point`
+* sessions (never freehand pencil samples). While `snap.constrain` (Shift) is
+* held, a line's end stays on the 15° line through the snapped start nearest
+* the pointer, and lands where that line meets a target. Behaviors from the
+* binding's `opts.behaviors` (`InsertBehavior[]`) run over the two points
+* after that; on release the first answer wins (`null` aborts, `Op[]` commits
+* in place of the insert).
+*
+* The new node has no scene id until commit, so the live preview is the
+* `overlay()` surface with `kind: 'insertPreview'`. A consumer-defined kind
+* the kit cannot draw skips the preview and still commits on release.
+*/
+var insertAction = inPlane({
 	id: "insert",
 	label: "Insert",
 	group: "insert",
 	eligible: { capability: "creates-shapes" },
+	modifierRoles: SNAP_ROLES,
 	requires: [
 		"insert",
 		"insertLive",
@@ -23,57 +41,67 @@ var m = n({
 		"textEdit",
 		"scene",
 		"applyOps",
-		"view"
+		"view",
+		"kitSettings"
 	],
 	invoker: {
 		timing: "ongoing",
-		start(n, r) {
-			let m = u(n, r);
-			if (!m) return {};
-			let { session: h, readers: g } = m, _ = m.frame, v = {
-				open: !0,
+		start(ctx, opts) {
+			const begun = beginInsert(ctx, opts);
+			if (!begun) return {};
+			const { session, readers } = begun;
+			let frame = begun.frame;
+			const gesture = {
+				open: true,
 				userRotation: 0,
-				repositioning: !1
-			}, y = n.deps.insertLive;
-			y && (y.gesture = v);
-			let b = n.deps.scene, x = n.deps.insertInto?.get() ?? null, S = b ? a(b, x, e(b)) : [];
+				repositioning: false
+			};
+			const live = ctx.deps.insertLive;
+			if (live) live.gesture = gesture;
+			const scene = ctx.deps.scene;
+			const copies = scene ? copiesWithin(scene, session.parent, scenePaintedPoseOf(scene)) : [];
 			return {
 				kind: "insert",
-				onMove(e) {
-					v.repositioning && d(h, _.pointer, e.world), _ = f(h, g, _, e);
+				onMove(moveCtx) {
+					if (gesture.repositioning) carryStart(session, frame.pointer, moveCtx.world, moveCtx);
+					frame = nextFrame(session, readers, frame, moveCtx);
 				},
 				overlay() {
-					if (!v.open) return null;
-					let e = p(h.opts?.params);
-					if (!i(o(e))?.insertPreview) return null;
-					let { bounds: t, extras: n, start: r } = s(e, _, _.points, v.userRotation);
+					if (!gesture.open) return null;
+					const resolved = resolveParams(session.opts?.params);
+					if (!shapeKindInfo(insertKind(resolved))?.insertPreview) return null;
+					const { bounds, extras, start } = insertShape(resolved, frame, frame.points, gesture.userRotation);
 					return {
 						kind: "insertPreview",
-						shape: n.kind,
-						bounds: t,
-						extras: n,
+						shape: extras.kind,
+						bounds,
+						extras,
 						anchorPoint: {
-							x: r.x,
-							y: r.y
+							x: start.x,
+							y: start.y
 						},
-						...S.length > 0 ? { copies: S } : {}
+						...copies.length > 0 ? { copies } : {}
 					};
 				},
-				onEnd(e, n) {
-					v.open = !1, y?.gesture === v && (y.gesture = null);
-					let r = !1;
+				onEnd(endCtx, reason) {
+					gesture.open = false;
+					if (live?.gesture === gesture) live.gesture = null;
+					let committed = false;
 					try {
-						n === "cancel" ? c(h) : r = l(h, _, e.drag?.points ?? _.points, v.userRotation);
+						if (reason === "cancel") cancelInsert(session);
+						else committed = commitInsert(session, frame, endCtx.drag?.points ?? frame.points, gesture.userRotation);
 					} finally {
-						t(h.behaviors, h.gestureCtx, r);
+						session.snap.close();
+						runBehaviorSettled(session.behaviors, session.gestureCtx, committed);
 					}
 				}
 			};
 		}
 	},
-	enabled: () => !0
-}, r);
-//#endregion
-export { m as insertAction };
+	/** Insert needs no selection; anything but `true` blocks dispatcher-routed inserts. */
+	enabled: () => true
+}, insertLayer);
 
+//#endregion
+export { insertAction };
 //# sourceMappingURL=action.js.map

package/dist/interactions/actions/insert/action.js.map

@@ -1 +1 @@
-{"version":3,"file":"action.js","names":["insertAction","inPlane","begun","beginInsert","ctx","opts","frame","gesture","live","scene","into","copies","copiesWithin","scenePaintedPoseOf","carryStart","session","moveCtx","nextFrame","readers","resolved","resolveParams","shapeKindInfo","insertKind","insertShape","extras","start","committed","reason","cancelInsert","commitInsert","endCtx","insertLayer"],"sources":["../../../../src/interactions/actions/insert/action.ts"],"sourcesContent":["import type { Action, NodeId } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts, OngoingOverlay } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { shapeKindInfo } from 'core/shapeKinds';\nimport type { KitInsertShape } from 'core/shapeKinds';\nimport { runBehaviorSettled } from '../gestureLifecycle';\nimport { inPlane, insertLayer } from '../planeInput';\nimport { copiesWithin } from 'canvas/copiesAbove';\nimport { scenePaintedPoseOf } from 'canvas/derivedPath';\nimport { cancelInsert, commitInsert } from './commit';\nimport { carryStart, nextFrame } from './frame';\nimport type { InsertLiveGesture } from './live';\nimport { beginInsert } from './session';\nimport { insertKind, insertShape } from './shape';\n\n/**\n * @experimental\n * Drag-to-insert. The node `kind` is read from `opts.params.kind`.\n *\n * Grid snapping comes from the optional `snap` dep, applied to the drag's\n * start and current point (never to freehand pencil samples). Behaviors from\n * the binding's `opts.behaviors` (`InsertBehavior[]`) run over the two points\n * after that; on release the first answer wins (`null` aborts, `Op[]` commits\n * in place of the insert).\n *\n * The new node has no scene id until commit, so the live preview is the\n * `overlay()` surface with `kind: 'insertPreview'`. A consumer-defined kind\n * the kit cannot draw skips the preview and still commits on release.\n */\nexport const insertAction: Action & { requires: string[] } = inPlane({\n  id: 'insert',\n  label: 'Insert',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  requires: ['insert', 'insertLive', 'insertInto', 'selection', 'snap', 'textEdit', 'scene', 'applyOps', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const begun = beginInsert(ctx, opts);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      let frame = begun.frame;\n      const gesture: InsertLiveGesture = { open: true, userRotation: 0, repositioning: false };\n      const live = ctx.deps.insertLive;\n      if (live) live.gesture = gesture;\n      // Where the shape will land decides the copies it will be drawn in.\n      const scene = ctx.deps.scene;\n      const into = (ctx.deps.insertInto?.get() ?? null) as NodeId | null;\n      const copies = scene ? copiesWithin(scene, into, scenePaintedPoseOf(scene)) : [];\n\n      return {\n        kind: 'insert',\n        onMove(moveCtx: InvocationCtx): void {\n          if (gesture.repositioning) carryStart(session, frame.pointer, moveCtx.world);\n          frame = nextFrame(session, readers, frame, moveCtx);\n        },\n        overlay(): OngoingOverlay | null {\n          if (!gesture.open) return null;\n          // Resolve params on every overlay() so thunked params (polygon\n          // sides ticking via ArrowUp mid-drag) reflect in the live preview.\n          const resolved = resolveParams(session.opts?.params);\n          if (!shapeKindInfo(insertKind(resolved))?.insertPreview) return null;\n          const { bounds, extras, start } = insertShape(resolved, frame, frame.points, gesture.userRotation);\n          return {\n            kind: 'insertPreview',\n            shape: extras.kind as KitInsertShape,\n            bounds,\n            extras,\n            // Anchor dot at the click point: radial shapes have no vertex\n            // there, and in center mode it marks the growth axis.\n            anchorPoint: { x: start.x, y: start.y },\n            ...(copies.length > 0 ? { copies } : {}),\n          };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          gesture.open = false;\n          if (live?.gesture === gesture) live.gesture = null;\n          let committed = false;\n          try {\n            if (reason === 'cancel') cancelInsert(session);\n            else committed = commitInsert(session, frame, endCtx.drag?.points ?? frame.points, gesture.userRotation);\n          } finally {\n            runBehaviorSettled(session.behaviors, session.gestureCtx, committed);\n          }\n        },\n      };\n    },\n  },\n  /** Insert needs no selection; anything but `true` blocks dispatcher-routed inserts. */\n  enabled: () => true as const,\n}, insertLayer);\n"],"mappings":";;;;;;;;;;;AA6BA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,UAAU;EAAC;EAAU;EAAc;EAAc;EAAa;EAAQ;EAAY;EAAS;EAAY;CAAM;CAC7G,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAQC,EAAYC,GAAKC,CAAI;GACnC,IAAI,CAACH,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACzBI,IAAQJ,EAAM,OACZK,IAA6B;IAAE,MAAM;IAAM,cAAc;IAAG,eAAe;GAAM,GACjFC,IAAOJ,EAAI,KAAK;GACtB,AAAII,MAAM,EAAK,UAAUD;GAEzB,IAAME,IAAQL,EAAI,KAAK,OACjBM,IAAQN,EAAI,KAAK,YAAY,IAAI,KAAK,MACtCO,IAASF,IAAQG,EAAaH,GAAOC,GAAMG,EAAmBJ,CAAK,CAAC,IAAI,CAAC;GAE/E,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KAEnC,AADIF,EAAQ,iBAAeO,EAAWC,GAAST,EAAM,SAASU,EAAQ,KAAK,GAC3E,IAAQC,EAAUF,GAASG,GAASZ,GAAOU,CAAO;IACpD;IACA,UAAiC;KAC/B,IAAI,CAACT,EAAQ,MAAM,OAAO;KAG1B,IAAMY,IAAWC,EAAcL,EAAQ,MAAM,MAAM;KACnD,IAAI,CAACM,EAAcC,EAAWH,CAAQ,CAAC,CAAC,EAAE,eAAe,OAAO;KAChE,IAAM,EAAE,WAAQ,WAAQ,aAAUI,EAAYJ,GAAUb,GAAOA,EAAM,QAAQC,EAAQ,YAAY;KACjG,OAAO;MACL,MAAM;MACN,OAAOiB,EAAO;MACd;MACA;MAGA,aAAa;OAAE,GAAGC,EAAM;OAAG,GAAGA,EAAM;MAAE;MACtC,GAAId,EAAO,SAAS,IAAI,EAAE,UAAO,IAAI,CAAC;KACxC;IACF;IACA,MAAM,GAAuB,GAAmC;KAE9D,AADA,EAAQ,OAAO,IACXH,GAAM,YAAYD,MAAS,EAAK,UAAU;KAC9C,IAAImB,IAAY;KAChB,IAAI;MACF,AAAIC,MAAW,WAAUC,EAAab,CAAO,IACxC,IAAYc,EAAad,GAAST,GAAOwB,EAAO,MAAM,UAAUxB,EAAM,QAAQC,EAAQ,YAAY;KACzG,UAAU;MACR,EAAmBQ,EAAQ,WAAWA,EAAQ,YAAYW,CAAS;KACrE;IACF;GACF;EACF;CACF;CAEA,eAAe;AACjB,GAAGK,CAAW"}
+{"version":3,"file":"action.js","names":[],"sources":["../../../../src/interactions/actions/insert/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts, OngoingOverlay } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { shapeKindInfo } from 'core/shapeKinds';\nimport type { KitInsertShape } from 'core/shapeKinds';\nimport { SNAP_ROLES } from 'features/snap/roles';\nimport { runBehaviorSettled } from '../gestureLifecycle';\nimport { inPlane, insertLayer } from '../planeInput';\nimport { copiesWithin } from 'canvas/copiesAbove';\nimport { scenePaintedPoseOf } from 'canvas/derivedPath';\nimport { cancelInsert, commitInsert } from './commit';\nimport { carryStart, nextFrame } from './frame';\nimport type { InsertLiveGesture } from './live';\nimport { beginInsert } from './session';\nimport { insertKind, insertShape } from './shape';\n\n/**\n * Drag-to-insert. The node `kind` is read from `opts.params.kind`.\n *\n * The drag's start and current point snap through the `snap` dep's `point`\n * sessions (never freehand pencil samples). While `snap.constrain` (Shift) is\n * held, a line's end stays on the 15° line through the snapped start nearest\n * the pointer, and lands where that line meets a target. Behaviors from the\n * binding's `opts.behaviors` (`InsertBehavior[]`) run over the two points\n * after that; on release the first answer wins (`null` aborts, `Op[]` commits\n * in place of the insert).\n *\n * The new node has no scene id until commit, so the live preview is the\n * `overlay()` surface with `kind: 'insertPreview'`. A consumer-defined kind\n * the kit cannot draw skips the preview and still commits on release.\n */\nexport const insertAction: Action & { requires: string[] } = inPlane({\n  id: 'insert',\n  label: 'Insert',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  modifierRoles: SNAP_ROLES,\n  requires: ['insert', 'insertLive', 'insertInto', 'selection', 'snap', 'textEdit', 'scene', 'applyOps', 'view', 'kitSettings'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const begun = beginInsert(ctx, opts);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      let frame = begun.frame;\n      const gesture: InsertLiveGesture = { open: true, userRotation: 0, repositioning: false };\n      const live = ctx.deps.insertLive;\n      if (live) live.gesture = gesture;\n      // Where the shape will land decides the copies it will be drawn in.\n      const scene = ctx.deps.scene;\n      const copies = scene ? copiesWithin(scene, session.parent, scenePaintedPoseOf(scene)) : [];\n\n      return {\n        kind: 'insert',\n        onMove(moveCtx: InvocationCtx): void {\n          if (gesture.repositioning) carryStart(session, frame.pointer, moveCtx.world, moveCtx);\n          frame = nextFrame(session, readers, frame, moveCtx);\n        },\n        overlay(): OngoingOverlay | null {\n          if (!gesture.open) return null;\n          // Resolve params on every overlay() so thunked params (polygon\n          // sides ticking via ArrowUp mid-drag) reflect in the live preview.\n          const resolved = resolveParams(session.opts?.params);\n          if (!shapeKindInfo(insertKind(resolved))?.insertPreview) return null;\n          const { bounds, extras, start } = insertShape(resolved, frame, frame.points, gesture.userRotation);\n          return {\n            kind: 'insertPreview',\n            shape: extras.kind as KitInsertShape,\n            bounds,\n            extras,\n            // Anchor dot at the click point: radial shapes have no vertex\n            // there, and in center mode it marks the growth axis.\n            anchorPoint: { x: start.x, y: start.y },\n            ...(copies.length > 0 ? { copies } : {}),\n          };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          gesture.open = false;\n          if (live?.gesture === gesture) live.gesture = null;\n          let committed = false;\n          try {\n            if (reason === 'cancel') cancelInsert(session);\n            else committed = commitInsert(session, frame, endCtx.drag?.points ?? frame.points, gesture.userRotation);\n          } finally {\n            session.snap.close();\n            runBehaviorSettled(session.behaviors, session.gestureCtx, committed);\n          }\n        },\n      };\n    },\n  },\n  /** Insert needs no selection; anything but `true` blocks dispatcher-routed inserts. */\n  enabled: () => true as const,\n}, insertLayer);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,eAAgD,QAAQ;CACnE,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,eAAe;CACf,UAAU;EAAC;EAAU;EAAc;EAAc;EAAa;EAAQ;EAAY;EAAS;EAAY;EAAQ;CAAa;CAC5H,SAAS;EACP,QAAQ;EACR,MAAM,KAAoB,MAAmC;GAC3D,MAAM,QAAQ,YAAY,KAAK,IAAI;GACnC,IAAI,CAAC,OAAO,OAAO,CAAC;GACpB,MAAM,EAAE,SAAS,YAAY;GAC7B,IAAI,QAAQ,MAAM;GAClB,MAAM,UAA6B;IAAE,MAAM;IAAM,cAAc;IAAG,eAAe;GAAM;GACvF,MAAM,OAAO,IAAI,KAAK;GACtB,IAAI,MAAM,KAAK,UAAU;GAEzB,MAAM,QAAQ,IAAI,KAAK;GACvB,MAAM,SAAS,QAAQ,aAAa,OAAO,QAAQ,QAAQ,mBAAmB,KAAK,CAAC,IAAI,CAAC;GAEzF,OAAO;IACL,MAAM;IACN,OAAO,SAA8B;KACnC,IAAI,QAAQ,eAAe,WAAW,SAAS,MAAM,SAAS,QAAQ,OAAO,OAAO;KACpF,QAAQ,UAAU,SAAS,SAAS,OAAO,OAAO;IACpD;IACA,UAAiC;KAC/B,IAAI,CAAC,QAAQ,MAAM,OAAO;KAG1B,MAAM,WAAW,cAAc,QAAQ,MAAM,MAAM;KACnD,IAAI,CAAC,cAAc,WAAW,QAAQ,CAAC,CAAC,EAAE,eAAe,OAAO;KAChE,MAAM,EAAE,QAAQ,QAAQ,UAAU,YAAY,UAAU,OAAO,MAAM,QAAQ,QAAQ,YAAY;KACjG,OAAO;MACL,MAAM;MACN,OAAO,OAAO;MACd;MACA;MAGA,aAAa;OAAE,GAAG,MAAM;OAAG,GAAG,MAAM;MAAE;MACtC,GAAI,OAAO,SAAS,IAAI,EAAE,OAAO,IAAI,CAAC;KACxC;IACF;IACA,MAAM,QAAuB,QAAmC;KAC9D,QAAQ,OAAO;KACf,IAAI,MAAM,YAAY,SAAS,KAAK,UAAU;KAC9C,IAAI,YAAY;KAChB,IAAI;MACF,IAAI,WAAW,UAAU,aAAa,OAAO;WACxC,YAAY,aAAa,SAAS,OAAO,OAAO,MAAM,UAAU,MAAM,QAAQ,QAAQ,YAAY;KACzG,UAAU;MACR,QAAQ,KAAK,MAAM;MACnB,mBAAmB,QAAQ,WAAW,QAAQ,YAAY,SAAS;KACrE;IACF;GACF;EACF;CACF;;CAEA,eAAe;AACjB,GAAG,WAAW"}

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

@@ -1,28 +1,50 @@
-import { commitGestureOps as e, readGestureLifecycle as t, reduceBehaviorEnd as n, runBehaviorCancel as r } from "../gestureLifecycle.js";
-import { defaultCommitAdapter as i } from "../defaultCommitAdapter.js";
-import { insertShape as a, isCommittableExtent as o } from "./shape.js";
-import { resolveParams as s } from "@weasel-js/routing";
+import { defaultCommitAdapter } from "../defaultCommitAdapter.js";
+import { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel } from "../gestureLifecycle.js";
+import { shapeKindInfo } from "../../../core/shapeKinds.js";
+import { insertShape, isCommittableExtent } from "./shape.js";
+import { resolveParams } from "@weasel-js/routing";
+
 //#region src/interactions/actions/insert/commit.ts
-function c(e) {
-	r(e.behaviors, e.gestureCtx), e.priorSelection.length > 0 && e.selection?.set([...e.priorSelection]);
+/**
+* A freshly inserted text box is empty, so it draws nothing and the tool's own
+* `click on selected body → enterTextEdit` binding has nothing visible to
+* click. Drop straight into the caret instead, for every kind that is text —
+* which is also what every other editor does. `textEdit` is optional: without
+* it the node is still committed.
+*/
+function enterInsertedText(textEdit, id, kind) {
+	if (id !== null && shapeKindInfo(kind)?.text) textEdit?.startEdit(id, { caret: 0 });
+}
+/** Cancel the insert: tell the behaviors, and put the selection the draw
+*  cleared back. */
+function cancelInsert(session) {
+	runBehaviorCancel(session.behaviors, session.gestureCtx);
+	if (session.priorSelection.length > 0) session.selection?.set([...session.priorSelection]);
 }
-function l(r, c, l, u) {
-	let d = s(r.opts?.params);
-	if (r.behaviors.length > 0) {
-		let a = n(r.behaviors, r.gestureCtx);
-		if (a === null) return !1;
-		if (a !== void 0) return r.scene ? e({
-			scene: r.scene,
-			applyOps: r.applyOps,
-			adapter: i(r.scene, r.selection?.adapterMethods)
-		}, t(d, "Insert", r.behaviors), a) : !1;
+/** Commit the insert. Returns whether it committed: a behavior's ops reached
+*  the scene, or the `insert` dep minted a node. `points` is the pointer
+*  trail as the release left it. */
+function commitInsert(session, frame, points, userRotation) {
+	const resolved = resolveParams(session.opts?.params);
+	if (session.behaviors.length > 0) {
+		const r = reduceBehaviorEnd(session.behaviors, session.gestureCtx);
+		if (r === null) return false;
+		if (r !== void 0) {
+			if (!session.scene) return false;
+			return commitGestureOps({
+				scene: session.scene,
+				applyOps: session.applyOps,
+				adapter: defaultCommitAdapter(session.scene, session.selection?.adapterMethods)
+			}, readGestureLifecycle(resolved, "Insert", session.behaviors), r);
+		}
 	}
-	let { bounds: f, extras: p } = a(d, c, l, u);
-	if (!o(f, p.kind)) return !1;
-	let m = r.dep.commit(f, p);
-	return m !== null && p.kind === "text" && r.textEdit?.startEdit(String(m), { caret: 0 }), m !== null;
+	const { bounds, extras, ends } = insertShape(resolved, frame, points, userRotation);
+	if (!isCommittableExtent(bounds, extras.kind)) return false;
+	const id = session.dep.commit(bounds, extras, ends);
+	enterInsertedText(session.textEdit, id === null ? null : String(id), extras.kind);
+	return id !== null;
 }
-//#endregion
-export { c as cancelInsert, l as commitInsert };
 
+//#endregion
+export { cancelInsert, commitInsert, enterInsertedText };
 //# sourceMappingURL=commit.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"commit.js","names":["cancelInsert","runBehaviorCancel","session","commitInsert","resolved","resolveParams","r","reduceBehaviorEnd","commitGestureOps","defaultCommitAdapter","readGestureLifecycle","insertShape","frame","points","userRotation","isCommittableExtent","bounds","extras","id"],"sources":["../../../../src/interactions/actions/insert/commit.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel } from '../gestureLifecycle';\nimport type { InsertFrame, InsertSession } from './session';\nimport { insertShape, isCommittableExtent } from './shape';\n\n/** Cancel the insert: tell the behaviors, and put the selection the draw\n *  cleared back. */\nexport function cancelInsert(\n  session: Pick<InsertSession, 'behaviors' | 'gestureCtx' | 'priorSelection' | 'selection'>,\n): void {\n  runBehaviorCancel(session.behaviors, session.gestureCtx);\n  if (session.priorSelection.length > 0) session.selection?.set([...session.priorSelection]);\n}\n\n/** Commit the insert. Returns whether it committed: a behavior's ops reached\n *  the scene, or the `insert` dep minted a node. `points` is the pointer\n *  trail as the release left it. */\nexport function commitInsert(\n  session: InsertSession,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): boolean {\n  // Resolve params at commit time so thunked params (polygon\n  // `sides` adjusted mid-drag, etc.) see the latest tool state.\n  const resolved = resolveParams(session.opts?.params);\n\n  if (session.behaviors.length > 0) {\n    const r = reduceBehaviorEnd(session.behaviors, session.gestureCtx);\n    if (r === null) return false;\n    if (r !== undefined) {\n      if (!session.scene) return false;\n      return commitGestureOps(\n        {\n          scene: session.scene,\n          applyOps: session.applyOps,\n          adapter: defaultCommitAdapter(session.scene, session.selection?.adapterMethods),\n        },\n        readGestureLifecycle(resolved, 'Insert', session.behaviors),\n        r,\n      );\n    }\n  }\n\n  const { bounds, extras } = insertShape(resolved, frame, points, userRotation);\n  // Sub-threshold drag — no insert.\n  if (!isCommittableExtent(bounds, extras.kind)) return false;\n\n  const id = session.dep.commit(bounds, extras);\n\n  // A freshly dragged text box is empty, so it draws nothing and the\n  // tool's own `click on selected body → enterTextEdit` binding has\n  // nothing visible to click. Drop straight into the caret instead —\n  // which is also what every other editor does with a text tool.\n  // `textEdit` is optional: without it the box is still committed,\n  // exactly as before.\n  if (id !== null && extras.kind === 'text') {\n    session.textEdit?.startEdit(String(id), { caret: 0 });\n  }\n  return id !== null;\n}\n"],"mappings":";;;;;AASA,SAAgBA,EACd,GACM;CAEN,AADAC,EAAkBC,EAAQ,WAAWA,EAAQ,UAAU,GACnDA,EAAQ,eAAe,SAAS,KAAGA,EAAQ,WAAW,IAAI,CAAC,GAAGA,EAAQ,cAAc,CAAC;AAC3F;AAKA,SAAgBC,EACd,GACA,GACA,GACA,GACS;CAGT,IAAMC,IAAWC,EAAcH,EAAQ,MAAM,MAAM;CAEnD,IAAIA,EAAQ,UAAU,SAAS,GAAG;EAChC,IAAMI,IAAIC,EAAkBL,EAAQ,WAAWA,EAAQ,UAAU;EACjE,IAAII,MAAM,MAAM,OAAO;EACvB,IAAIA,MAAM,KAAA,GAER,OADKJ,EAAQ,QACNM,EACL;GACE,OAAON,EAAQ;GACf,UAAUA,EAAQ;GAClB,SAASO,EAAqBP,EAAQ,OAAOA,EAAQ,WAAW,cAAc;EAChF,GACAQ,EAAqBN,GAAU,UAAUF,EAAQ,SAAS,GAC1DI,CACF,IAT2B;CAW/B;CAEA,IAAM,EAAE,WAAQ,cAAWK,EAAYP,GAAUQ,GAAOC,GAAQC,CAAY;CAE5E,IAAI,CAACC,EAAoBC,GAAQC,EAAO,IAAI,GAAG,OAAO;CAEtD,IAAMC,IAAKhB,EAAQ,IAAI,OAAOc,GAAQC,CAAM;CAW5C,OAHIC,MAAO,QAAQD,EAAO,SAAS,UACjCf,EAAQ,UAAU,UAAU,OAAOgB,CAAE,GAAG,EAAE,OAAO,EAAE,CAAC,GAE/CA,MAAO;AAChB"}
+{"version":3,"file":"commit.js","names":[],"sources":["../../../../src/interactions/actions/insert/commit.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel } from '../gestureLifecycle';\nimport type { InsertFrame, InsertSession } from './session';\nimport { insertShape, isCommittableExtent } from './shape';\nimport { shapeKindInfo } from 'core/shapeKinds';\nimport type { TextEditDep } from '../depSchema';\n\n/**\n * A freshly inserted text box is empty, so it draws nothing and the tool's own\n * `click on selected body → enterTextEdit` binding has nothing visible to\n * click. Drop straight into the caret instead, for every kind that is text —\n * which is also what every other editor does. `textEdit` is optional: without\n * it the node is still committed.\n */\nexport function enterInsertedText(textEdit: TextEditDep | undefined, id: string | null, kind: string): void {\n  if (id !== null && shapeKindInfo(kind)?.text) textEdit?.startEdit(id, { caret: 0 });\n}\n\n/** Cancel the insert: tell the behaviors, and put the selection the draw\n *  cleared back. */\nexport function cancelInsert(\n  session: Pick<InsertSession, 'behaviors' | 'gestureCtx' | 'priorSelection' | 'selection'>,\n): void {\n  runBehaviorCancel(session.behaviors, session.gestureCtx);\n  if (session.priorSelection.length > 0) session.selection?.set([...session.priorSelection]);\n}\n\n/** Commit the insert. Returns whether it committed: a behavior's ops reached\n *  the scene, or the `insert` dep minted a node. `points` is the pointer\n *  trail as the release left it. */\nexport function commitInsert(\n  session: InsertSession,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): boolean {\n  // Resolve params at commit time so thunked params (polygon\n  // `sides` adjusted mid-drag, etc.) see the latest tool state.\n  const resolved = resolveParams(session.opts?.params);\n\n  if (session.behaviors.length > 0) {\n    const r = reduceBehaviorEnd(session.behaviors, session.gestureCtx);\n    if (r === null) return false;\n    if (r !== undefined) {\n      if (!session.scene) return false;\n      return commitGestureOps(\n        {\n          scene: session.scene,\n          applyOps: session.applyOps,\n          adapter: defaultCommitAdapter(session.scene, session.selection?.adapterMethods),\n        },\n        readGestureLifecycle(resolved, 'Insert', session.behaviors),\n        r,\n      );\n    }\n  }\n\n  const { bounds, extras, ends } = insertShape(resolved, frame, points, userRotation);\n  // Sub-threshold drag — no insert.\n  if (!isCommittableExtent(bounds, extras.kind)) return false;\n\n  const id = session.dep.commit(bounds, extras, ends);\n  enterInsertedText(session.textEdit, id === null ? null : String(id), extras.kind);\n  return id !== null;\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAgB,kBAAkB,UAAmC,IAAmB,MAAoB;CAC1G,IAAI,OAAO,QAAQ,cAAc,IAAI,CAAC,EAAE,MAAM,UAAU,UAAU,IAAI,EAAE,OAAO,EAAE,CAAC;AACpF;;;AAIA,SAAgB,aACd,SACM;CACN,kBAAkB,QAAQ,WAAW,QAAQ,UAAU;CACvD,IAAI,QAAQ,eAAe,SAAS,GAAG,QAAQ,WAAW,IAAI,CAAC,GAAG,QAAQ,cAAc,CAAC;AAC3F;;;;AAKA,SAAgB,aACd,SACA,OACA,QACA,cACS;CAGT,MAAM,WAAW,cAAc,QAAQ,MAAM,MAAM;CAEnD,IAAI,QAAQ,UAAU,SAAS,GAAG;EAChC,MAAM,IAAI,kBAAkB,QAAQ,WAAW,QAAQ,UAAU;EACjE,IAAI,MAAM,MAAM,OAAO;EACvB,IAAI,MAAM,QAAW;GACnB,IAAI,CAAC,QAAQ,OAAO,OAAO;GAC3B,OAAO,iBACL;IACE,OAAO,QAAQ;IACf,UAAU,QAAQ;IAClB,SAAS,qBAAqB,QAAQ,OAAO,QAAQ,WAAW,cAAc;GAChF,GACA,qBAAqB,UAAU,UAAU,QAAQ,SAAS,GAC1D,CACF;EACF;CACF;CAEA,MAAM,EAAE,QAAQ,QAAQ,SAAS,YAAY,UAAU,OAAO,QAAQ,YAAY;CAElF,IAAI,CAAC,oBAAoB,QAAQ,OAAO,IAAI,GAAG,OAAO;CAEtD,MAAM,KAAK,QAAQ,IAAI,OAAO,QAAQ,QAAQ,IAAI;CAClD,kBAAkB,QAAQ,UAAU,OAAO,OAAO,OAAO,OAAO,EAAE,GAAG,OAAO,IAAI;CAChF,OAAO,OAAO;AAChB"}