@weasel-js/core 1.9.3 → 1.10.0

package/dist/interactions/actions/gestureLifecycle.js

@@ -1,9 +1,10 @@
+import { SceneArrivalRefused as e } from "../../core/scene/arrivals.js";
 //#region src/interactions/actions/gestureLifecycle.ts
-function e(e) {
+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;
 }
-function t(e, t, n = []) {
+function n(e, t, n = []) {
 	let r = e ?? {}, i = !1, a = !1;
 	return {
 		label: r.label ?? t,
@@ -17,28 +18,54 @@ function t(e, t, n = []) {
 		}
 	};
 }
-function n(e, t, n) {
-	if (t.transient) {
-		e.scene.untracked(() => {
-			for (let t of n) t.apply(e.adapter);
-		});
-		return;
+function r(t, n, r) {
+	if (n.transient) {
+		try {
+			t.scene.untracked(() => {
+				for (let e of r) e.apply(t.adapter);
+			});
+		} catch (t) {
+			if (!(t instanceof e)) throw t;
+			return !1;
+		}
+		return !0;
 	}
-	let r = t.labelFor(n);
-	e.applyOps ? e.applyOps(n, r) : e.scene.applyBatch(n, r, e.adapter);
-}
-function r(e, t) {
-	let n;
-	for (let r of e) {
-		let e = r.onEnd?.(t, { answered: n !== void 0 });
-		n === void 0 && e !== void 0 && (n = e);
+	let i = n.labelFor(r);
+	return t.applyOps ? (t.applyOps(r, i), !0) : t.scene.applyBatch(r, i, t.adapter);
+}
+function i(e, t, ...[n]) {
+	let r, i = !1;
+	return a(e, (e) => {
+		try {
+			let a = e.onEnd?.(t, {
+				...n,
+				answered: i || r !== void 0
+			});
+			r === void 0 && a !== void 0 && (r = a);
+		} catch (e) {
+			throw i = !0, e;
+		}
+	}), r;
+}
+function a(e, t) {
+	let n = [];
+	for (let r of e) try {
+		t(r);
+	} catch (e) {
+		n.push(e);
 	}
-	return n;
+	if (n.length > 0) throw n[0];
+}
+function o(e, t) {
+	a(e, (e) => e.onCancel?.(t));
+}
+function s(e, t, n) {
+	a(e, (e) => e.onSettled?.(t, n));
 }
-function i(e, t) {
-	for (let n of e) n.onCancel?.(t);
+function c(e, t) {
+	e.hold.drop(), e.previews.clear(), a([() => s(e.behaviors, e.ctx, t), () => e.lifecycle.end(t)], (e) => e());
 }
 //#endregion
-export { n as commitGestureOps, e as gestureLifecycleParams, t as readGestureLifecycle, r as reduceBehaviorEnd, i as runBehaviorCancel };
+export { c as closeGesture, r as commitGestureOps, t as gestureLifecycleParams, n as readGestureLifecycle, i as reduceBehaviorEnd, o as runBehaviorCancel, s as 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","label","reduceBehaviorEnd","answer","r","ctx","runBehaviorCancel"],"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 type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/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. */\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): void {\n  if (lifecycle.transient) {\n    target.scene.untracked(() => {\n      for (const op of ops) op.apply(target.adapter);\n    });\n    return;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (target.applyOps) target.applyOps(ops, label);\n  else target.scene.applyBatch(ops, label, target.adapter);\n}\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. */\nexport function reduceBehaviorEnd<TCtx>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: BehaviorEnd): Op[] | null | void }[],\n  ctx: TCtx,\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  for (const b of behaviors) {\n    const r = b.onEnd?.(ctx, { answered: answer !== undefined });\n    if (answer === undefined && r !== undefined) answer = r;\n  }\n  return answer;\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  for (const b of behaviors) b.onCancel?.(ctx);\n}\n"],"mappings":";AAgCA,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;AAIA,SAAgBC,EACd,GAKA,GACA,GACM;CACN,IAAIC,EAAU,WAAW;EACvB,EAAO,MAAM,gBAAgB;GAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;EAC/C,CAAC;EACD;CACF;CACA,IAAMC,IAAQH,EAAU,SAASN,CAAG;CACpC,AAAIQ,EAAO,WAAUA,EAAO,SAASR,GAAKS,CAAK,IAC1CD,EAAO,MAAM,WAAWR,GAAKS,GAAOD,EAAO,OAAO;AACzD;AAMA,SAAgBE,EACd,GACA,GACyB;CACzB,IAAIC;CACJ,KAAK,IAAMT,KAAKD,GAAW;EACzB,IAAMW,IAAIV,EAAE,QAAQW,GAAK,EAAE,UAAUF,MAAW,KAAA,EAAU,CAAC;EAC3D,AAAIA,MAAW,KAAA,KAAaC,MAAM,KAAA,MAAW,IAASA;CACxD;CACA,OAAOD;AACT;AAGA,SAAgBG,EACd,GACA,GACM;CACN,KAAK,IAAMZ,KAAKD,GAAW,EAAE,WAAWY,CAAG;AAC7C"}
+{"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"}

package/dist/interactions/actions/hitSelection.js

@@ -0,0 +1,8 @@
+//#region src/interactions/actions/hitSelection.ts
+function e(e, t, n) {
+	return [...new Set(n ? [...e, ...t] : t)];
+}
+//#endregion
+export { e as selectionFromHits };
+
+//# sourceMappingURL=hitSelection.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,72 @@
+import { runBehaviorSettled as e } from "../gestureLifecycle.js";
+import { inPlane as t, insertLayer as n } from "../planeInput.js";
+import { shapeKindInfo as r } from "../../../core/shapeKinds.js";
+import { insertKind as i, insertShape as a } from "./shape.js";
+import { cancelInsert as o, commitInsert as s } from "./commit.js";
+import { beginInsert as c } from "./session.js";
+import { nextFrame as l } from "./frame.js";
+import { resolveParams as u } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/action.ts
+var d = t({
+	id: "insert",
+	label: "Insert",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	requires: [
+		"insert",
+		"insertLive",
+		"selection",
+		"snap",
+		"textEdit",
+		"scene",
+		"applyOps",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(t, n) {
+			let d = c(t, n);
+			if (!d) return {};
+			let { session: f, readers: p } = d, m = d.frame, h = {
+				open: !0,
+				userRotation: 0
+			}, g = t.deps.insertLive;
+			return g && (g.gesture = h), {
+				kind: "insert",
+				onMove(e) {
+					m = l(f, p, m, e);
+				},
+				overlay() {
+					if (!h.open) return null;
+					let e = u(f.opts?.params);
+					if (!r(i(e))?.insertPreview) return null;
+					let { bounds: t, extras: n, start: o } = a(e, m, m.points, h.userRotation);
+					return {
+						kind: "insertPreview",
+						shape: n.kind,
+						bounds: t,
+						extras: n,
+						anchorPoint: {
+							x: o.x,
+							y: o.y
+						}
+					};
+				},
+				onEnd(t, n) {
+					h.open = !1, g?.gesture === h && (g.gesture = null);
+					let r = !1;
+					try {
+						n === "cancel" ? o(f) : r = s(f, m, t.drag?.points ?? m.points, h.userRotation);
+					} finally {
+						e(f.behaviors, f.gestureCtx, r);
+					}
+				}
+			};
+		}
+	},
+	enabled: () => !0
+}, n);
+//#endregion
+export { d as insertAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["insertAction","inPlane","begun","beginInsert","ctx","opts","frame","gesture","live","nextFrame","session","readers","moveCtx","resolved","resolveParams","shapeKindInfo","insertKind","insertShape","extras","start","committed","reason","cancelInsert","commitInsert","endCtx","insertLayer"],"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 { runBehaviorSettled } from '../gestureLifecycle';\nimport { inPlane, insertLayer } from '../planeInput';\nimport { cancelInsert, commitInsert } from './commit';\nimport { 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', '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 };\n      const live = ctx.deps.insertLive;\n      if (live) live.gesture = gesture;\n\n      return {\n        kind: 'insert',\n        onMove(moveCtx: InvocationCtx): void {\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          };\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":";;;;;;;;;AA2BA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,UAAU;EAAC;EAAU;EAAc;EAAa;EAAQ;EAAY;EAAS;EAAY;CAAM;CAC/F,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;GAAE,GAC3DC,IAAOJ,EAAI,KAAK;GAGtB,OAFII,MAAM,EAAK,UAAUD,IAElB;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAQE,EAAUC,GAASC,GAASL,GAAOM,CAAO;IACpD;IACA,UAAiC;KAC/B,IAAI,CAACL,EAAQ,MAAM,OAAO;KAG1B,IAAMM,IAAWC,EAAcJ,EAAQ,MAAM,MAAM;KACnD,IAAI,CAACK,EAAcC,EAAWH,CAAQ,CAAC,CAAC,EAAE,eAAe,OAAO;KAChE,IAAM,EAAE,WAAQ,WAAQ,aAAUI,EAAYJ,GAAUP,GAAOA,EAAM,QAAQC,EAAQ,YAAY;KACjG,OAAO;MACL,MAAM;MACN,OAAOW,EAAO;MACd;MACA;MAGA,aAAa;OAAE,GAAGC,EAAM;OAAG,GAAGA,EAAM;MAAE;KACxC;IACF;IACA,MAAM,GAAuB,GAAmC;KAE9D,AADA,EAAQ,OAAO,IACXX,GAAM,YAAYD,MAAS,EAAK,UAAU;KAC9C,IAAIa,IAAY;KAChB,IAAI;MACF,AAAIC,MAAW,WAAUC,EAAaZ,CAAO,IACxC,IAAYa,EAAab,GAASJ,GAAOkB,EAAO,MAAM,UAAUlB,EAAM,QAAQC,EAAQ,YAAY;KACzG,UAAU;MACR,EAAmBG,EAAQ,WAAWA,EAAQ,YAAYU,CAAS;KACrE;IACF;GACF;EACF;CACF;CAEA,eAAe;AACjB,GAAGK,CAAW"}

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

@@ -0,0 +1,28 @@
+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";
+//#region src/interactions/actions/insert/commit.ts
+function c(e) {
+	r(e.behaviors, e.gestureCtx), e.priorSelection.length > 0 && e.selection?.set([...e.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;
+	}
+	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;
+}
+//#endregion
+export { c as cancelInsert, l as commitInsert };
+
+//# sourceMappingURL=commit.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,65 @@
+//#region src/interactions/actions/insert/extras.ts
+function e(e, t, n, r, i, a) {
+	let o = e?.kind ?? "rect";
+	switch (o) {
+		case "rect":
+		case "ellipse": return { kind: o };
+		case "line": return {
+			kind: "line",
+			a: {
+				x: t,
+				y: n
+			},
+			b: {
+				x: r,
+				y: i
+			}
+		};
+		case "polygon": {
+			let a = Number(e?.sides ?? 6), o = r === t && i === n ? 0 : Math.atan2(i - n, r - t), s = {
+				kind: "polygon",
+				sides: a,
+				rotation: e?.rotation === void 0 ? o : Number(e.rotation)
+			};
+			if (e?.originMode === "center") {
+				let e = r - t, a = i - n;
+				s.center = {
+					x: t,
+					y: n
+				}, s.radius = Math.hypot(e, a);
+			} else e?.center !== void 0 && (s.center = e.center), e?.radius !== void 0 && (s.radius = e.radius);
+			return s;
+		}
+		case "star": {
+			let a = Number(e?.points ?? 5), o = Number(e?.innerRadiusRatio ?? .5), s = r === t && i === n ? 0 : Math.atan2(i - n, r - t), c = {
+				kind: "star",
+				points: a,
+				innerRadiusRatio: o,
+				rotation: e?.rotation === void 0 ? s : Number(e.rotation)
+			};
+			if (e?.originMode === "center") {
+				let e = r - t, a = i - n;
+				c.center = {
+					x: t,
+					y: n
+				}, c.outerRadius = Math.hypot(e, a);
+			} else e?.center !== void 0 && (c.center = e.center), e?.outerRadius !== void 0 && (c.outerRadius = e.outerRadius);
+			return c;
+		}
+		case "pencil": return {
+			kind: "pencil",
+			samples: e?.samples ?? a ?? []
+		};
+		default: return {
+			...e ?? {},
+			kind: o
+		};
+	}
+}
+function t(e, t) {
+	t !== 0 && (e.kind === "star" || e.kind === "polygon") && (e.rotation += t);
+}
+//#endregion
+export { t as applyUserRotation, e as buildExtras };
+
+//# sourceMappingURL=extras.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extras.js","names":["buildExtras","kind","params","\"kind\"","startX","startY","currentX","currentY","sides","\"sides\"","dragAngle","extras","\"rotation\"","\"originMode\"","dx","dy","\"center\"","\"radius\"","pts","\"points\"","ir","\"innerRadiusRatio\"","\"outerRadius\"","\"samples\"","points","applyUserRotation","userRotation"],"sources":["../../../../src/interactions/actions/insert/extras.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertExtras } from '../depSchema';\n\n/** Build a typed `InsertExtras` from the static params + gesture context.\n *  Kit-built-in kinds (line / polygon / star / pencil) read kind-specific\n *  fields; unknown kinds pass the raw params through as `{ kind, ... }`. */\nexport function buildExtras(\n  params: Record<string, unknown> | undefined,\n  startX: number,\n  startY: number,\n  currentX: number,\n  currentY: number,\n  points: ReadonlyArray<DragSample> | null,\n): InsertExtras {\n  const kind = ((params?.['kind'] as string | undefined) ?? 'rect');\n  switch (kind) {\n    case 'rect':\n    case 'ellipse':\n      return { kind } as InsertExtras;\n    case 'line':\n      // Use the live drag endpoints (not AABB) so the line preserves the\n      // user's drag direction — drag from bottom-left to top-right makes a\n      // line that slopes up, not the bounds diagonal.\n      return { kind: 'line', a: { x: startX, y: startY }, b: { x: currentX, y: currentY } };\n    case 'polygon': {\n      const sides = Number(params?.['sides'] ?? 6);\n      // When the tool omits rotation, point the first vertex along the\n      // drag vector so dragging in a direction orients the shape that\n      // way. Sub-pixel drags (no direction yet) fall back to 0.\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'polygon', sides, rotation };\n      // Drag-from-center: tool's Alt binding passes `originMode:'center'`.\n      // Compute polygon center + radius from the drag vector so the shape\n      // anchors on the click point. Without this, the dep falls back to\n      // inscribing in the AABB (drag-from-corner default).\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { radius?: unknown }).radius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['radius'] !== undefined) (extras as { radius?: unknown }).radius = params['radius'];\n      }\n      return extras;\n    }\n    case 'star': {\n      const pts = Number(params?.['points'] ?? 5);\n      const ir = Number(params?.['innerRadiusRatio'] ?? 0.5);\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'star', points: pts, innerRadiusRatio: ir, rotation };\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { outerRadius?: unknown }).outerRadius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['outerRadius'] !== undefined) (extras as { outerRadius?: unknown }).outerRadius = params['outerRadius'];\n      }\n      return extras;\n    }\n    case 'pencil':\n      // Prefer tool-supplied samples (param) when present — pencil tools may\n      // capture richer per-sample data (pressure/tilt). Fall back to the\n      // dispatcher's accumulated pointer trail.\n      return {\n        kind: 'pencil',\n        samples: (params?.['samples'] as ReadonlyArray<DragSample> | undefined)\n          ?? points\n          ?? [],\n      };\n    default:\n      // Consumer-defined kind: pass everything through so a custom insert\n      // dep can read its own fields.\n      return { ...(params ?? {}), kind } as InsertExtras;\n  }\n}\n\n/** Add a user-driven rotation offset onto kinds that carry rotation. Rect\n *  / ellipse / line / pencil don't expose a rotation field on their\n *  extras today, so they ignore the offset. */\nexport function applyUserRotation(extras: InsertExtras, userRotation: number): void {\n  if (userRotation === 0) return;\n  if (extras.kind === 'star' || extras.kind === 'polygon') {\n    (extras as { rotation: number }).rotation += userRotation;\n  }\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACc;CACd,IAAMC,IAASC,GAASC,QAAkC;CAC1D,QAAQF,GAAR;EACE,KAAK;EACL,KAAK,WACH,OAAO,EAAE,QAAK;EAChB,KAAK,QAIH,OAAO;GAAE,MAAM;GAAQ,GAAG;IAAE,GAAGG;IAAQ,GAAGC;GAAO;GAAG,GAAG;IAAE,GAAGC;IAAU,GAAGC;GAAS;EAAE;EACtF,KAAK,WAAW;GACd,IAAMC,IAAQ,OAAON,GAASO,SAAY,CAAC,GAIrCC,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAW;IAAO,UAHtCT,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAEmC;GAKhE,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAiC,SAAS,KAAK,MAAMS,GAAIC,CAAE;GAC7D,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASe,WAAc,KAAA,MAAW,EAAiC,SAASf,EAAOe;GAEzF,OAAON;EACT;EACA,KAAK,QAAQ;GACX,IAAMO,IAAM,OAAOhB,GAASiB,UAAa,CAAC,GACpCC,IAAK,OAAOlB,GAASmB,oBAAuB,EAAG,GAC/CX,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAQ,QAAQO;IAAK,kBAAkBE;IAAI,UAH/DlB,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAE4D;GACzF,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAsC,cAAc,KAAK,MAAMS,GAAIC,CAAE;GACvE,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASoB,gBAAmB,KAAA,MAAW,EAAsC,cAAcpB,EAAOoB;GAExG,OAAOX;EACT;EACA,KAAK,UAIH,OAAO;GACL,MAAM;GACN,SAAUT,GAASqB,WACdC,KACA,CAAC;EACR;EACF,SAGE,OAAO;GAAE,GAAItB,KAAU,CAAC;GAAI;EAAK;CACrC;AACF;AAKA,SAAgBuB,EAAkB,GAAsB,GAA4B;CAClF,AAAIC,MAAiB,MACjBf,EAAO,SAAS,UAAUA,EAAO,SAAS,eAC5C,EAAiC,YAAYe;AAEjD"}

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

@@ -0,0 +1,48 @@
+import { pointerStateOf as e } from "../pointerState.js";
+import { computeBounds as t, effectiveOriginMode as n, snapTo15Degrees as r } from "./geometry.js";
+import { GESTURE_KEY as i } from "./session.js";
+import { resolveParams as a } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/frame.ts
+function o(o, s, c, l) {
+	let u = a(o.opts?.params), d = u?.kind ?? "rect", f = o.gestureCtx, p = f.origin.get(i), m = {
+		x: c.pointer.x,
+		y: c.pointer.y
+	};
+	if (d === "line" && c.shiftHeld && (m = r(p, m)), m = o.snap(m), o.behaviors.length > 0) {
+		f.modifiers = { ...l.modifiers }, f.pointer = e(c.pointer, l), f.view = s.view(), f.plane = s.plane(), f.current.set(i, m);
+		let r = n(u?.originMode, c.altHeld);
+		for (let e of o.behaviors) {
+			let n = t(p.x, p.y, m.x, m.y, r), i = e.onMove?.(f, {
+				start: p,
+				current: m,
+				bounds: n,
+				pose: n
+			});
+			i && (i.start && (p = i.start), i.current && (m = i.current));
+		}
+		f.current.set(i, m);
+	}
+	return {
+		start: p,
+		current: m
+	};
+}
+function s(e, t, n, r) {
+	let i = {
+		pointer: {
+			x: r.world.x,
+			y: r.world.y
+		},
+		altHeld: r.modifiers.alt,
+		shiftHeld: r.modifiers.shift
+	};
+	return {
+		...i,
+		points: r.drag?.points ? r.drag.points : n.points,
+		shaped: o(e, t, i, r)
+	};
+}
+//#endregion
+export { s as nextFrame };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","names":["shapeEndpoints","resolved","resolveParams","session","kind","\"kind\"","gctx","start","GESTURE_KEY","current","raw","snapTo15Degrees","moveCtx","pointerStateOf","readers","mode","effectiveOriginMode","\"originMode\"","b","bounds","computeBounds","r","nextFrame","prev"],"sources":["../../../../src/interactions/actions/insert/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { InsertPoint } from '../../gestures/types';\nimport { computeBounds, effectiveOriginMode, snapTo15Degrees } from './geometry';\nimport { GESTURE_KEY, type InsertFrame, type InsertSession } from './session';\n\n/**\n * Shape the raw pointer into the drag's endpoints, in order: the line tool's\n * Shift-constrain (on the raw pointer, around the shaped start, so the locked\n * angle survives), the `snap` dep, then each behavior's `onMove`, each seeing\n * the points the one before it returned.\n */\nfunction shapeEndpoints(\n  session: Pick<InsertSession, 'opts' | 'snap' | 'behaviors' | 'gestureCtx'>,\n  readers: GestureReaders,\n  raw: Pick<InsertFrame, 'pointer' | 'altHeld' | 'shiftHeld'>,\n  moveCtx: Pick<InvocationCtx, 'modifiers' | 'screen'>,\n): { start: InsertPoint; current: InsertPoint } {\n  const resolved = resolveParams(session.opts?.params);\n  const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n  const gctx = session.gestureCtx;\n  let start = gctx.origin.get(GESTURE_KEY) as InsertPoint;\n  let current = { x: raw.pointer.x, y: raw.pointer.y };\n  if (kind === 'line' && raw.shiftHeld) {\n    current = snapTo15Degrees(start, current);\n  }\n  current = session.snap(current);\n\n  if (session.behaviors.length > 0) {\n    gctx.modifiers = { ...moveCtx.modifiers };\n    gctx.pointer = pointerStateOf(raw.pointer, moveCtx);\n    gctx.view = readers.view();\n    gctx.plane = readers.plane();\n    gctx.current.set(GESTURE_KEY, current);\n    const mode = effectiveOriginMode(resolved?.['originMode'], raw.altHeld);\n    for (const b of session.behaviors) {\n      const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n      const r = b.onMove?.(gctx, { start, current, bounds, pose: bounds });\n      if (!r) continue;\n      if (r.start) start = r.start;\n      if (r.current) current = r.current;\n    }\n    gctx.current.set(GESTURE_KEY, current);\n  }\n  return { start, current };\n}\n\n/** One pump event's pointer, modifiers, and trail, and the endpoints they\n *  shape to. Each behavior's `onMove` runs once per call. */\nexport function nextFrame(\n  session: InsertSession,\n  readers: GestureReaders,\n  prev: Pick<InsertFrame, 'points'>,\n  moveCtx: InvocationCtx,\n): InsertFrame {\n  const raw = {\n    pointer: { x: moveCtx.world.x, y: moveCtx.world.y },\n    // Each pointermove carries fresh modifier state from the dispatcher;\n    // releasing / pressing a key mid-drag takes effect on the next move tick\n    // (true modifier-only events don't fire without a cursor change).\n    altHeld: moveCtx.modifiers.alt,\n    shiftHeld: moveCtx.modifiers.shift,\n  };\n  return {\n    ...raw,\n    // The dispatcher mutates its own per-gesture trail in place but\n    // attaches the array reference to each InvocationCtx.drag — keep\n    // the latest reference in case the dispatcher swaps it.\n    points: moveCtx.drag?.points ? moveCtx.drag.points : prev.points,\n    shaped: shapeEndpoints(session, readers, raw, moveCtx),\n  };\n}\n"],"mappings":";;;;;AAcA,SAASA,EACP,GACA,GACA,GACA,GAC8C;CAC9C,IAAMC,IAAWC,EAAcC,EAAQ,MAAM,MAAM,GAC7CC,IAAQH,GAAWI,QAAkC,QACrDC,IAAOH,EAAQ,YACjBI,IAAQD,EAAK,OAAO,IAAIE,CAAW,GACnCC,IAAU;EAAE,GAAGC,EAAI,QAAQ;EAAG,GAAGA,EAAI,QAAQ;CAAE;CAMnD,IALIN,MAAS,UAAUM,EAAI,cACzB,IAAUC,EAAgBJ,GAAOE,CAAO,IAE1C,IAAUN,EAAQ,KAAKM,CAAO,GAE1BN,EAAQ,UAAU,SAAS,GAAG;EAKhC,AAJA,EAAK,YAAY,EAAE,GAAGS,EAAQ,UAAU,GACxC,EAAK,UAAUC,EAAeH,EAAI,SAASE,CAAO,GAClD,EAAK,OAAOE,EAAQ,KAAK,GACzB,EAAK,QAAQA,EAAQ,MAAM,GAC3BR,EAAK,QAAQ,IAAIE,GAAaC,CAAO;EACrC,IAAMM,IAAOC,EAAoBf,GAAWgB,YAAeP,EAAI,OAAO;EACtE,KAAK,IAAMQ,KAAKf,EAAQ,WAAW;GACjC,IAAMgB,IAASC,EAAcb,EAAM,GAAGA,EAAM,GAAGE,EAAQ,GAAGA,EAAQ,GAAGM,CAAI,GACnEM,IAAIH,EAAE,SAASZ,GAAM;IAAE;IAAO;IAAS;IAAQ,MAAMa;GAAO,CAAC;GACnE,AAAKE,MACDA,EAAE,UAAO,IAAQA,EAAE,QACnBA,EAAE,YAAS,IAAUA,EAAE;EAC7B;EACA,EAAK,QAAQ,IAAIb,GAAaC,CAAO;CACvC;CACA,OAAO;EAAE;EAAO;CAAQ;AAC1B;AAIA,SAAgBa,EACd,GACA,GACA,GACA,GACa;CACb,IAAMZ,IAAM;EACV,SAAS;GAAE,GAAGE,EAAQ,MAAM;GAAG,GAAGA,EAAQ,MAAM;EAAE;EAIlD,SAASA,EAAQ,UAAU;EAC3B,WAAWA,EAAQ,UAAU;CAC/B;CACA,OAAO;EACL,GAAGF;EAIH,QAAQE,EAAQ,MAAM,SAASA,EAAQ,KAAK,SAASW,EAAK;EAC1D,QAAQvB,EAAeG,GAASW,GAASJ,GAAKE,CAAO;CACvD;AACF"}

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

@@ -0,0 +1,35 @@
+//#region src/interactions/actions/insert/geometry.ts
+function e(e, t) {
+	let n = e === "center" ? "center" : "corner";
+	return t ? n === "center" ? "corner" : "center" : n;
+}
+function t(e, t, n, r, i) {
+	if (i === "center") {
+		let i = Math.abs(n - e), a = Math.abs(r - t);
+		return {
+			x: e - i,
+			y: t - a,
+			width: i * 2,
+			height: a * 2
+		};
+	}
+	return {
+		x: Math.min(e, n),
+		y: Math.min(t, r),
+		width: Math.abs(n - e),
+		height: Math.abs(r - t)
+	};
+}
+function n(e, t) {
+	let n = t.x - e.x, r = t.y - e.y, i = Math.hypot(n, r);
+	if (i === 0) return t;
+	let a = Math.PI / 12, o = Math.round(Math.atan2(r, n) / a) * a;
+	return {
+		x: e.x + i * Math.cos(o),
+		y: e.y + i * Math.sin(o)
+	};
+}
+//#endregion
+export { t as computeBounds, e as effectiveOriginMode, n as snapTo15Degrees };
+
+//# sourceMappingURL=geometry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","names":["effectiveOriginMode","nominal","paramsOrigin","altHeld","computeBounds","originMode","dx","currentX","startX","dy","currentY","startY","snapTo15Degrees","end","start","len","step","snapped"],"sources":["../../../../src/interactions/actions/insert/geometry.ts"],"sourcesContent":["/** Resolve the effective origin mode from the binding's nominal opt\n *  and live Alt state. Alt inverts: `corner` ⇄ `center`. Applies to\n *  every shape kind — radial shapes (polygon/star) included; the\n *  overlay paints an `anchorPoint` dot at the click so corner mode\n *  reads as anchored even though no polygon vertex sits there.\n */\nexport function effectiveOriginMode(\n  paramsOrigin: unknown,\n  altHeld: boolean,\n): 'corner' | 'center' {\n  const nominal: 'corner' | 'center' = paramsOrigin === 'center' ? 'center' : 'corner';\n  if (!altHeld) return nominal;\n  return nominal === 'center' ? 'corner' : 'center';\n}\n\n/** Compute the insert AABB from drag endpoints.\n *  - `'corner'` (default): bounds = drag rect (top-left → bottom-right of cursor sweep).\n *  - `'center'`: bounds = symmetric AABB anchored on the start point.\n *    Used when the tool's Alt-modifier binding passes\n *    `originMode: 'center'` (Illustrator/Figma convention). */\nexport function computeBounds(\n  startX: number, startY: number,\n  currentX: number, currentY: number,\n  originMode: 'corner' | 'center',\n): { x: number; y: number; width: number; height: number } {\n  if (originMode === 'center') {\n    const dx = Math.abs(currentX - startX);\n    const dy = Math.abs(currentY - startY);\n    return { x: startX - dx, y: startY - dy, width: dx * 2, height: dy * 2 };\n  }\n  return {\n    x: Math.min(startX, currentX),\n    y: Math.min(startY, currentY),\n    width: Math.abs(currentX - startX),\n    height: Math.abs(currentY - startY),\n  };\n}\n\n/** Constrain `end` to the nearest 15° increment around `start`, preserving\n *  the drag length. The line tool's documented Shift behavior. */\nexport function snapTo15Degrees(\n  start: { x: number; y: number },\n  end: { x: number; y: number },\n): { x: number; y: number } {\n  const dx = end.x - start.x;\n  const dy = end.y - start.y;\n  const len = Math.hypot(dx, dy);\n  if (len === 0) return end;\n  const step = Math.PI / 12; // 15°\n  const snapped = Math.round(Math.atan2(dy, dx) / step) * step;\n  return { x: start.x + len * Math.cos(snapped), y: start.y + len * Math.sin(snapped) };\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACqB;CACrB,IAAMC,IAA+BC,MAAiB,WAAW,WAAW;CAE5E,OADKC,IACEF,MAAY,WAAW,WAAW,WADpBA;AAEvB;AAOA,SAAgBG,EACd,GAAgB,GAChB,GAAkB,GAClB,GACyD;CACzD,IAAIC,MAAe,UAAU;EAC3B,IAAMC,IAAK,KAAK,IAAIC,IAAWC,CAAM,GAC/BC,IAAK,KAAK,IAAIC,IAAWC,CAAM;EACrC,OAAO;GAAE,GAAGH,IAASF;GAAI,GAAGK,IAASF;GAAI,OAAOH,IAAK;GAAG,QAAQG,IAAK;EAAE;CACzE;CACA,OAAO;EACL,GAAG,KAAK,IAAID,GAAQD,CAAQ;EAC5B,GAAG,KAAK,IAAII,GAAQD,CAAQ;EAC5B,OAAO,KAAK,IAAIH,IAAWC,CAAM;EACjC,QAAQ,KAAK,IAAIE,IAAWC,CAAM;CACpC;AACF;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,IAAMN,IAAKO,EAAI,IAAIC,EAAM,GACnBL,IAAKI,EAAI,IAAIC,EAAM,GACnBC,IAAM,KAAK,MAAMT,GAAIG,CAAE;CAC7B,IAAIM,MAAQ,GAAG,OAAOF;CACtB,IAAMG,IAAO,KAAK,KAAK,IACjBC,IAAU,KAAK,MAAM,KAAK,MAAMR,GAAIH,CAAE,IAAIU,CAAI,IAAIA;CACxD,OAAO;EAAE,GAAGF,EAAM,IAAIC,IAAM,KAAK,IAAIE,CAAO;EAAG,GAAGH,EAAM,IAAIC,IAAM,KAAK,IAAIE,CAAO;CAAE;AACtF"}

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

@@ -0,0 +1,21 @@
+//#region src/interactions/actions/insert/rotateAction.ts
+var e = Math.PI / 720, t = {
+	id: "insert.adjustRotation",
+	label: "Insert — rotate",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	invoker: {
+		timing: "immediate",
+		run: (t, n) => {
+			let r = t.insertLive?.gesture;
+			if (!r || !r.open) return;
+			let i = n?.deltaY ?? 0;
+			i !== 0 && (r.userRotation += i * e);
+		}
+	},
+	requires: ["insertLive"]
+};
+//#endregion
+export { t as insertRotateAction };
+
+//# sourceMappingURL=rotateAction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rotateAction.js","names":["ROTATION_SENSITIVITY","insertRotateAction","gesture","deps","deltaY","params"],"sources":["../../../../src/interactions/actions/insert/rotateAction.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/** Radians per unit of wheel deltaY. Tuned so a typical mouse-wheel click\n *  (deltaY ≈ 100) yields ~25°, while a trackpad event (deltaY ≈ 1–10)\n *  yields a smooth 0.25–2.5° increment. */\nconst ROTATION_SENSITIVITY = Math.PI / 720;\n\n/**\n * @experimental\n * Companion to `insertAction` — adjusts the live insert gesture's\n * `userRotation` based on wheel deltaY. Intended to be bound to\n * Shift+wheel during the insert tool's engaged phase. No-op when no\n * insert is in flight.\n */\nexport const insertRotateAction: Action = {\n  id: 'insert.adjustRotation',\n  label: 'Insert — rotate',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'immediate' as const,\n    run: (deps, params) => {\n      const gesture = deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return;\n      const deltaY = (params as { deltaY?: number } | undefined)?.deltaY ?? 0;\n      if (deltaY === 0) return;\n      gesture.userRotation += deltaY * ROTATION_SENSITIVITY;\n    },\n  },\n  requires: ['insertLive'],\n};\n"],"mappings":";AAMA,IAAMA,IAAuB,KAAK,KAAK,KAS1BC,IAA6B;CACxC,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,MAAM,GAAM,MAAW;GACrB,IAAMC,IAAUC,EAAK,YAAY;GACjC,IAAI,CAACD,KAAW,CAACA,EAAQ,MAAM;GAC/B,IAAME,IAAUC,GAA4C,UAAU;GACtE,AAAID,MAAW,MACf,EAAQ,gBAAgBA,IAASJ;EACnC;CACF;CACA,UAAU,CAAC,YAAY;AACzB"}

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

@@ -0,0 +1,59 @@
+import { gestureReaders as e } from "../../gestures/shared/screenTolerance.js";
+import { pointerStateOf as t } from "../pointerState.js";
+//#region src/interactions/actions/insert/session.ts
+var n = "gesture";
+function r(r, i) {
+	let a = r.deps.insert;
+	if (!a) return null;
+	let o = r.deps.selection, s = o ? [...o.get()] : [];
+	o && s.length > 0 && o.clear();
+	let c = r.deps.snap, l = c ? (e) => c.point(e) : (e) => e, u = i?.behaviors ?? [], d = e(r.deps), f = l({
+		x: r.world.x,
+		y: r.world.y
+	}), p = {
+		draggedIds: [n],
+		origin: /* @__PURE__ */ new Map([[n, f]]),
+		current: /* @__PURE__ */ new Map([[n, f]]),
+		snap: null,
+		modifiers: { ...r.modifiers },
+		pointer: t(r.world, r),
+		view: d.view(),
+		plane: d.plane(),
+		adapter: void 0,
+		scratch: {}
+	};
+	for (let e of u) e.onStart?.(p);
+	let m = p.origin.get(n);
+	return {
+		session: {
+			dep: a,
+			textEdit: r.deps.textEdit,
+			snap: l,
+			opts: i,
+			priorSelection: s,
+			behaviors: u,
+			gestureCtx: p,
+			scene: r.deps.scene,
+			applyOps: r.deps.applyOps,
+			selection: o
+		},
+		readers: d,
+		frame: {
+			pointer: {
+				x: r.world.x,
+				y: r.world.y
+			},
+			points: r.drag?.points ?? null,
+			altHeld: r.modifiers.alt,
+			shiftHeld: r.modifiers.shift,
+			shaped: {
+				start: m,
+				current: m
+			}
+		}
+	};
+}
+//#endregion
+export { n as GESTURE_KEY, r as beginInsert };
+
+//# sourceMappingURL=session.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["GESTURE_KEY","beginInsert","dep","ctx","selection","priorSelection","snapDep","snap","p","behaviors","opts","readers","gestureReaders","origin","gestureCtx","pointerStateOf","b","startPoint"],"sources":["../../../../src/interactions/actions/insert/session.ts"],"sourcesContent":["import type { BindingOpts, DragSample, InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, InsertBehavior, InsertPoint } from '../../gestures/types';\nimport type { InsertDep, TextEditDep } from '../depSchema';\n\n/** The key an insert's single gesture point rides under in the behaviors'\n *  `draggedIds` / `origin` / `current` — insert has no node id yet. */\nexport const GESTURE_KEY = 'gesture';\n\n/** What an insert captured at press. Nothing here changes during the drag.\n *  The deps are captured because the dispatcher builds the deps bag once, on\n *  `start`: every later pump event carries `deps: {}`. */\nexport interface InsertSession {\n  readonly dep: InsertDep;\n  /** For the text kind's drop-into-the-caret step. */\n  readonly textEdit: TextEditDep | undefined;\n  /** World-space point snapper from the `snap` dep, or identity when the\n   *  dep isn't registered. Applied to the drag's start and current point so\n   *  the live preview and the committed geometry agree. Freehand pencil\n   *  samples are deliberately NOT snapped — a grid-quantized freehand trail\n   *  is a staircase, not a stroke. */\n  readonly snap: (p: { x: number; y: number }) => { x: number; y: number };\n  /** The active binding's opts — re-resolved on every read so thunked\n   *  params see the latest tool state (e.g. polygon `sides` after ArrowUp). */\n  readonly opts: BindingOpts | undefined;\n  /** What was selected before the draw cleared it, to put back on cancel. */\n  readonly priorSelection: readonly NodeId[];\n  /** Behaviors from `opts.behaviors`; empty when none were bound. */\n  readonly behaviors: readonly InsertBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors. Its `origin` holds the\n   *  start point under {@link GESTURE_KEY}, after `onStart` shaped it. */\n  readonly gestureCtx: GestureContext<unknown>;\n  /** For committing a behavior's `Op[]`. */\n  readonly scene: Scene<unknown, string, unknown> | undefined;\n  readonly applyOps: ((ops: Op[], label: string) => void) | undefined;\n  readonly selection: SelectionApi | undefined;\n}\n\n/** What the latest pump event left. Replaced, not mutated, by the next. */\nexport interface InsertFrame {\n  /** The raw (unsnapped) pointer in world space. */\n  readonly pointer: InsertPoint;\n  /** Pointer trail accumulated by the dispatcher in world space; pencil-kind\n   *  commits read it. */\n  readonly points: ReadonlyArray<DragSample> | null;\n  /** Alt inverts the binding's nominal `originMode` (corner ⇄ center), so\n   *  pressing or releasing it mid-drag flips the preview and the commit\n   *  without the dispatcher re-routing to another binding. */\n  readonly altHeld: boolean;\n  /** Shift constrains the `line` kind to 15° increments. */\n  readonly shiftHeld: boolean;\n  /** The endpoints after Shift-constrain, the `snap` dep, and the behaviors. */\n  readonly shaped: { start: InsertPoint; current: InsertPoint };\n}\n\n/** Capture an insert at press. Null with no `insert` dep. Clears the\n *  selection and runs each behavior's `onStart`. */\nexport function beginInsert(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n): { session: InsertSession; readers: GestureReaders; frame: InsertFrame } | null {\n  const dep = ctx.deps.insert;\n  if (!dep) return null;\n\n  // Starting a draw retires any prior selection — the lingering halo\n  // around an unrelated node while the user is drawing a new shape is\n  // just visual noise, and it primes the UX bug where a drag that\n  // continues over the selected node would otherwise drive the move\n  // action via fall-through. The clear is unconditional: the user has\n  // committed to \"I'm making a new thing\" by engaging a creation tool.\n  const selection = ctx.deps.selection;\n  const priorSelection = selection ? [...selection.get()] : [];\n  if (selection && priorSelection.length > 0) {\n    selection.clear();\n  }\n\n  const snapDep = ctx.deps.snap;\n  const snap = snapDep\n    ? (p: { x: number; y: number }) => snapDep.point(p)\n    : (p: { x: number; y: number }) => p;\n  const behaviors = (opts?.behaviors ?? []) as InsertBehavior<unknown>[];\n  const readers = gestureReaders(ctx.deps);\n  const origin = snap({ x: ctx.world.x, y: ctx.world.y });\n  const gestureCtx: GestureContext<unknown> = {\n    draggedIds: [GESTURE_KEY],\n    origin: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    current: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(ctx.world, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    // No node exists to adapt until commit; insert behaviors read points.\n    adapter: undefined as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n  const startPoint = gestureCtx.origin.get(GESTURE_KEY) as InsertPoint;\n\n  const session: InsertSession = {\n    dep,\n    textEdit: ctx.deps.textEdit,\n    snap,\n    opts,\n    priorSelection,\n    behaviors,\n    gestureCtx,\n    scene: ctx.deps.scene,\n    applyOps: ctx.deps.applyOps,\n    selection,\n  };\n  const frame: InsertFrame = {\n    pointer: { x: ctx.world.x, y: ctx.world.y },\n    points: ctx.drag?.points ?? null,\n    altHeld: ctx.modifiers.alt,\n    shiftHeld: ctx.modifiers.shift,\n    shaped: { start: startPoint, current: startPoint },\n  };\n  return { session, readers, frame };\n}\n"],"mappings":";;;AAWA,IAAaA,IAAc;AAkD3B,SAAgBC,EACd,GACA,GACgF;CAChF,IAAMC,IAAMC,EAAI,KAAK;CACrB,IAAI,CAACD,GAAK,OAAO;CAQjB,IAAME,IAAYD,EAAI,KAAK,WACrBE,IAAiBD,IAAY,CAAC,GAAGA,EAAU,IAAI,CAAC,IAAI,CAAC;CAC3D,AAAIA,KAAaC,EAAe,SAAS,KACvCD,EAAU,MAAM;CAGlB,IAAME,IAAUH,EAAI,KAAK,MACnBI,IAAOD,KACR,MAAgCA,EAAQ,MAAME,CAAC,KAC/C,MAAgCA,GAC/BC,IAAaC,GAAM,aAAa,CAAC,GACjCC,IAAUC,EAAeT,EAAI,IAAI,GACjCU,IAASN,EAAK;EAAE,GAAGJ,EAAI,MAAM;EAAG,GAAGA,EAAI,MAAM;CAAE,CAAC,GAChDW,IAAsC;EAC1C,YAAY,CAACd,CAAW;EACxB,wBAAQ,IAAI,IAAqB,CAAC,CAACA,GAAaa,CAAM,CAAC,CAAC;EACxD,yBAAS,IAAI,IAAqB,CAAC,CAACb,GAAaa,CAAM,CAAC,CAAC;EACzD,MAAM;EACN,WAAW,EAAE,GAAGV,EAAI,UAAU;EAC9B,SAASY,EAAeZ,EAAI,OAAOA,CAAG;EACtC,MAAMQ,EAAQ,KAAK;EACnB,OAAOA,EAAQ,MAAM;EAErB,SAAS,KAAA;EACT,SAAS,CAAC;CACZ;CACA,KAAK,IAAMK,KAAKP,GAAW,EAAE,UAAUK,CAAU;CACjD,IAAMG,IAAaH,EAAW,OAAO,IAAId,CAAW;CAqBpD,OAAO;EAAE,SAAA;GAlBP;GACA,UAAUG,EAAI,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA,OAAOA,EAAI,KAAK;GAChB,UAAUA,EAAI,KAAK;GACnB;EASO;EAAS;EAAS,OAAA;GANzB,SAAS;IAAE,GAAGA,EAAI,MAAM;IAAG,GAAGA,EAAI,MAAM;GAAE;GAC1C,QAAQA,EAAI,MAAM,UAAU;GAC5B,SAASA,EAAI,UAAU;GACvB,WAAWA,EAAI,UAAU;GACzB,QAAQ;IAAE,OAAOc;IAAY,SAASA;GAAW;EAExB;CAAM;AACnC"}

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

@@ -0,0 +1,34 @@
+import { applyUserRotation as e, buildExtras as t } from "./extras.js";
+import { computeBounds as n, effectiveOriginMode as r } from "./geometry.js";
+//#region src/interactions/actions/insert/shape.ts
+function i(e) {
+	return e?.kind ?? "rect";
+}
+function a(e, t, n) {
+	let { start: r } = e, { current: i } = e;
+	return t === "line" && n === "center" && (r = {
+		x: r.x - (i.x - r.x),
+		y: r.y - (i.y - r.y)
+	}), {
+		start: r,
+		current: i
+	};
+}
+function o(o, s, c, l) {
+	let u = r(o?.originMode, s.altHeld), { start: d, current: f } = a(s.shaped, i(o), u), p = n(d.x, d.y, f.x, f.y, u), m = t({
+		...o ?? {},
+		originMode: u
+	}, d.x, d.y, f.x, f.y, c);
+	return e(m, l), {
+		bounds: p,
+		extras: m,
+		start: d
+	};
+}
+function s(e, t) {
+	return t === "pencil" ? !0 : t === "line" ? e.width !== 0 || e.height !== 0 : e.width !== 0 && e.height !== 0;
+}
+//#endregion
+export { i as insertKind, o as insertShape, s as isCommittableExtent };
+
+//# sourceMappingURL=shape.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","names":["insertKind","resolved","\"kind\"","resolveEndpoints","shaped","kind","mode","start","current","insertShape","effectiveOriginMode","\"originMode\"","frame","bounds","computeBounds","extras","buildExtras","points","applyUserRotation","userRotation","isCommittableExtent"],"sources":["../../../../src/interactions/actions/insert/shape.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertPoint } from '../../gestures/types';\nimport type { InsertExtras } from '../depSchema';\nimport { applyUserRotation, buildExtras } from './extras';\nimport { computeBounds, effectiveOriginMode } from './geometry';\nimport type { InsertFrame } from './session';\n\n/** The node kind a binding's resolved params ask for. */\nexport function insertKind(resolved: Record<string, unknown> | undefined): string {\n  return (resolved?.['kind'] as string | undefined) ?? 'rect';\n}\n\n/** The effective endpoints: `shaped`, plus — for the `line` kind only — the\n *  alt/center reading as \"mirror the start around the pointer\" rather than\n *  \"grow a symmetric AABB\". */\nfunction resolveEndpoints(\n  shaped: InsertFrame['shaped'],\n  kind: string,\n  mode: 'corner' | 'center',\n): { start: InsertPoint; current: InsertPoint } {\n  let { start } = shaped;\n  const { current } = shaped;\n\n  // A line has no area, so \"from center\" means the drag is a half-line:\n  // mirror the start to the far side of the pointer.\n  if (kind === 'line' && mode === 'center') {\n    start = { x: start.x - (current.x - start.x), y: start.y - (current.y - start.y) };\n  }\n  return { start, current };\n}\n\nexport interface InsertShape {\n  bounds: { x: number; y: number; width: number; height: number };\n  extras: InsertExtras;\n  /** Where the drag started, after the endpoints were resolved. */\n  start: InsertPoint;\n}\n\n/** The shape an insert has at `frame`. The live overlay and the commit both\n *  read it from here, so they can't disagree. Extras are derived with the\n *  effective origin mode, so polygon/star center+radius follow the live Alt\n *  toggle and not the binding's nominal `originMode`. */\nexport function insertShape(\n  resolved: Record<string, unknown> | undefined,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): InsertShape {\n  const mode = effectiveOriginMode(resolved?.['originMode'], frame.altHeld);\n  const { start, current } = resolveEndpoints(frame.shaped, insertKind(resolved), mode);\n  const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n  const extras = buildExtras(\n    { ...(resolved ?? {}), originMode: mode },\n    start.x, start.y, current.x, current.y,\n    points,\n  );\n  applyUserRotation(extras, userRotation);\n  return { bounds, extras, start };\n}\n\n/** Whether a drag produced enough extent to be worth committing. The test\n *  is kind-aware because \"zero size\" isn't one shape:\n *   - pencil: a sample trail can be meaningful even when start ≈ end\n *     (a closed loop), so no guard at all.\n *   - line: has no area by construction. An axis-aligned line has a\n *     zero-height (or zero-width) AABB and is perfectly valid — only\n *     a zero-LENGTH drag is degenerate. (Shift-constrain makes\n *     axis-aligned the common case, which is how this surfaced.)\n *   - everything else: a zero extent in either axis is degenerate. */\nexport function isCommittableExtent(\n  bounds: { width: number; height: number },\n  kind: string,\n): boolean {\n  if (kind === 'pencil') return true;\n  if (kind === 'line') return bounds.width !== 0 || bounds.height !== 0;\n  return bounds.width !== 0 && bounds.height !== 0;\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAuD;CAChF,OAAQC,GAAWC,QAAkC;AACvD;AAKA,SAASC,EACP,GACA,GACA,GAC8C;CAC9C,IAAI,EAAE,aAAUC,GACV,EAAE,eAAYA;CAOpB,OAHIC,MAAS,UAAUC,MAAS,aAC9B,IAAQ;EAAE,GAAGC,EAAM,KAAKC,EAAQ,IAAID,EAAM;EAAI,GAAGA,EAAM,KAAKC,EAAQ,IAAID,EAAM;CAAG,IAE5E;EAAE;EAAO;CAAQ;AAC1B;AAaA,SAAgBE,EACd,GACA,GACA,GACA,GACa;CACb,IAAMH,IAAOI,EAAoBT,GAAWU,YAAeC,EAAM,OAAO,GAClE,EAAE,UAAO,eAAYT,EAAiBS,EAAM,QAAQZ,EAAWC,CAAQ,GAAGK,CAAI,GAC9EO,IAASC,EAAcP,EAAM,GAAGA,EAAM,GAAGC,EAAQ,GAAGA,EAAQ,GAAGF,CAAI,GACnES,IAASC,EACb;EAAE,GAAIf,KAAY,CAAC;EAAI,YAAYK;CAAK,GACxCC,EAAM,GAAGA,EAAM,GAAGC,EAAQ,GAAGA,EAAQ,GACrCS,CACF;CAEA,OADAC,EAAkBH,GAAQI,CAAY,GAC/B;EAAE;EAAQ;EAAQ;CAAM;AACjC;AAWA,SAAgBC,EACd,GACA,GACS;CAGT,OAFIf,MAAS,WAAiB,KAC1BA,MAAS,SAAeQ,EAAO,UAAU,KAAKA,EAAO,WAAW,IAC7DA,EAAO,UAAU,KAAKA,EAAO,WAAW;AACjD"}