@weasel-js/core 1.10.1 → 1.11.1

package/dist/features/snap/resizeBox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizeBox.js","names":[],"sources":["../../../src/features/snap/resizeBox.ts"],"sourcesContent":["import type { ResizeAnchor } from '@weasel-js/routing';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { fixedCornerOf, movedEdges, movingPoint } from 'interactions/actions/resize/cornerHandles';\nimport type { SnapResizeBox } from 'interactions/actions/snapDep';\nimport type { SnapEdge, SnapEdges, SnapProbeAt } from './types';\n\ntype Point = { x: number; y: number };\n\nexport const EPS = 1e-9;\n\n/** A resize's box with its frame read out, in ctx coordinates. */\nexport interface ResizeSubject {\n  /** In the box's own frame. */\n  bounds: Bounds;\n  handle: ResizeAnchor;\n  at(p: Point): Point;\n  /** Where the frame's unit axes point. */\n  ex: Point;\n  ey: Point;\n}\n\nexport function resizeSubject(box: SnapResizeBox, handle: ResizeAnchor): ResizeSubject {\n  const at = box.toWorld ?? ((p: Point) => p);\n  const o = at({ x: 0, y: 0 });\n  const ax = at({ x: 1, y: 0 });\n  const ay = at({ x: 0, y: 1 });\n  return { bounds: box.bounds, handle, at, ex: { x: ax.x - o.x, y: ax.y - o.y }, ey: { x: ay.x - o.x, y: ay.y - o.y } };\n}\n\n/** The dragged corner or edge midpoint as `pointer`, and as `box` the dragged\n *  corner or both ends of the dragged edge: the points a drag δ moves by δ. */\nexport function resizeProbes(s: ResizeSubject): SnapProbeAt[] {\n  const { bounds: b, handle } = s;\n  const out: SnapProbeAt[] = [{ id: 'pointer', at: s.at(movingPoint(b, handle)), role: 'pointer' }];\n  const sides = (pin: ResizeAnchor['x'], lo: number, size: number): number[] =>\n    pin === 'min' ? [lo + size] : pin === 'max' ? [lo] : [lo, lo + size];\n  const xs = sides(handle.x, b.x, b.width);\n  const ys = sides(handle.y, b.y, b.height);\n  if (xs.length === 2 && ys.length === 2) return out;\n  for (const x of xs) for (const y of ys) out.push({ id: `box.${out.length - 1}`, at: s.at({ x, y }), role: 'box' });\n  return out;\n}\n\n/** The direction an edge handle's edge moves along; null for a corner. */\nexport function edgeAxis(s: ResizeSubject): Point | null {\n  const { x, y } = s.handle;\n  if ((x === 'free') === (y === 'free')) return null;\n  return y === 'free' ? s.ex : s.ey;\n}\n\n/** From the fixed corner to the dragged one. */\nexport function diagonal(s: ResizeSubject): Point {\n  const f = s.at(fixedCornerOf(s.bounds, s.handle));\n  const m = s.at(movingPoint(s.bounds, s.handle));\n  return { x: m.x - f.x, y: m.y - f.y };\n}\n\n/** The box in its own frame once the handle has moved by `delta`. */\nfunction movedBox(s: ResizeSubject, delta: Point): Bounds {\n  const det = s.ex.x * s.ey.y - s.ey.x * s.ex.y;\n  const local = Math.abs(det) < EPS\n    ? { x: 0, y: 0 }\n    : { x: (s.ey.y * delta.x - s.ey.x * delta.y) / det, y: (s.ex.x * delta.y - s.ex.y * delta.x) / det };\n  return movedEdges(s.bounds, s.handle, local.x, local.y);\n}\n\n/** The box's axis-aligned extent once the handle has moved by `delta`. */\nexport function resizedBox(s: ResizeSubject, delta: Point): Bounds {\n  const b = movedBox(s, delta);\n  const corners = [\n    s.at({ x: b.x, y: b.y }), s.at({ x: b.x + b.width, y: b.y }),\n    s.at({ x: b.x, y: b.y + b.height }), s.at({ x: b.x + b.width, y: b.y + b.height }),\n  ];\n  const xs = corners.map((c) => c.x);\n  const ys = corners.map((c) => c.y);\n  const x = Math.min(...xs);\n  const y = Math.min(...ys);\n  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };\n}\n\n/** The sides of {@link resizedBox} a drag of `delta` moves: the side across\n *  from the pinned one, or the pinned side's once the drag has flipped the\n *  box past it. A frame that turns or flips the box moves no side of its\n *  extent alone. */\nexport function resizeEdges(s: ResizeSubject, delta: Point): SnapEdges {\n  const square = Math.abs(s.ex.y) < EPS && Math.abs(s.ey.x) < EPS && s.ex.x > 0 && s.ey.y > 0;\n  if (!square) return { x: null, y: null };\n  const b = movedBox(s, delta);\n  const moved = (pin: ResizeAnchor['x'], size: number): SnapEdge => {\n    if (pin === 'free') return null;\n    const far = pin === 'min' ? 'max' : 'min';\n    return size >= 0 ? far : pin;\n  };\n  return { x: moved(s.handle.x, b.width), y: moved(s.handle.y, b.height) };\n}\n"],"mappings":"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"}

package/dist/features/snap/roles.js

@@ -0,0 +1,32 @@
+import { roleReader } from "@weasel-js/routing";
+
+//#region src/features/snap/roles.ts
+/** The modifier roles a snapping action declares. */
+var SNAP_ROLES = {
+	"snap.suspend": {
+		label: "Suspend snapping",
+		keys: ["ctrl"]
+	},
+	"snap.constrain": {
+		label: "Constrain",
+		keys: ["shift"]
+	}
+};
+/** The angle step `snap.constrain` (Shift) holds a direction to: a line, a
+*  measurement, a rotate, a symmetry axis. 15 degrees. */
+var SNAP_ANGLE_STEP = Math.PI / 12;
+/** The step an `'axis'` lock holds a move or an anchor drag to, and Shift a
+*  pen handle: the axes and the diagonals. */
+var SNAP_AXIS_STEP = Math.PI / 4;
+var held = roleReader(SNAP_ROLES);
+/** The snap roles `ctx` holds. */
+function snapMods(ctx) {
+	return {
+		suspend: held(ctx, "snap.suspend"),
+		constrain: held(ctx, "snap.constrain")
+	};
+}
+
+//#endregion
+export { SNAP_ANGLE_STEP, SNAP_AXIS_STEP, SNAP_ROLES, snapMods };
+//# sourceMappingURL=roles.js.map

package/dist/features/snap/roles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.js","names":[],"sources":["../../../src/features/snap/roles.ts"],"sourcesContent":["import { roleReader, type ModifierRoles, type ModifierState } from '@weasel-js/routing';\nimport type { SnapMods } from 'interactions/actions/snapDep';\n\n/** The modifier roles a snapping action declares. */\nexport const SNAP_ROLES = {\n  'snap.suspend': { label: 'Suspend snapping', keys: ['ctrl'] },\n  'snap.constrain': { label: 'Constrain', keys: ['shift'] },\n} as const satisfies ModifierRoles;\n\n/** The angle step `snap.constrain` (Shift) holds a direction to: a line, a\n *  measurement, a rotate, a symmetry axis. 15 degrees. */\nexport const SNAP_ANGLE_STEP = Math.PI / 12;\n\n/** The step an `'axis'` lock holds a move or an anchor drag to, and Shift a\n *  pen handle: the axes and the diagonals. */\nexport const SNAP_AXIS_STEP = Math.PI / 4;\n\nconst held = roleReader(SNAP_ROLES);\n\n/** The snap roles `ctx` holds. */\nexport function snapMods(ctx: { roles?: Readonly<Record<string, boolean>>; modifiers: ModifierState }): SnapMods {\n  return { suspend: held(ctx, 'snap.suspend'), constrain: held(ctx, 'snap.constrain') };\n}\n"],"mappings":";;;;AAIA,IAAa,aAAa;CACxB,gBAAgB;EAAE,OAAO;EAAoB,MAAM,CAAC,MAAM;CAAE;CAC5D,kBAAkB;EAAE,OAAO;EAAa,MAAM,CAAC,OAAO;CAAE;AAC1D;;;AAIA,IAAa,kBAAkB,KAAK,KAAK;;;AAIzC,IAAa,iBAAiB,KAAK,KAAK;AAExC,IAAM,OAAO,WAAW,UAAU;;AAGlC,SAAgB,SAAS,KAAwF;CAC/G,OAAO;EAAE,SAAS,KAAK,KAAK,cAAc;EAAG,WAAW,KAAK,KAAK,gBAAgB;CAAE;AACtF"}

package/dist/features/snap/rotationSource.js

@@ -0,0 +1,47 @@
+//#region src/features/snap/rotationSource.ts
+var QUARTER = Math.PI / 2;
+/**
+* A rotate's angle targets: every quarter turn, and the world rotation of
+* every other visible node that can turn. Shift's step is the rotate's own.
+* Every `<SceneCanvas>` asks it, under the id `'rotation'`.
+*/
+function rotationSnapSource() {
+	let cached = null;
+	const nodeAngles = (q) => {
+		const { scene, rotationOf } = q;
+		if (!scene || !rotationOf) return [];
+		const key = [
+			scene,
+			scene.getVersion(),
+			rotationOf,
+			q.exclude
+		];
+		if (cached && key.every((k, i) => k === cached.key[i])) return cached.angles;
+		const exclude = new Set(q.exclude);
+		const angles = [];
+		for (const id of scene.nodes.keys()) {
+			if (exclude.has(id) || scene.isHidden(id)) continue;
+			const angle = rotationOf(id);
+			if (angle !== void 0 && Number.isFinite(angle)) angles.push(angle);
+		}
+		cached = {
+			key,
+			angles
+		};
+		return angles;
+	};
+	return {
+		id: "rotation",
+		roles: [],
+		gestures: ["rotate"],
+		collect: () => [],
+		*angles(q) {
+			for (let k = 0; k < 4; k++) yield { angle: k * QUARTER };
+			for (const angle of nodeAngles(q)) yield { angle };
+		}
+	};
+}
+
+//#endregion
+export { rotationSnapSource };
+//# sourceMappingURL=rotationSource.js.map

package/dist/features/snap/rotationSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotationSource.js","names":[],"sources":["../../../src/features/snap/rotationSource.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport type { AngleCandidate, AngleCollect, SnapSource } from './types';\n\nconst QUARTER = Math.PI / 2;\n\n/**\n * A rotate's angle targets: every quarter turn, and the world rotation of\n * every other visible node that can turn. Shift's step is the rotate's own.\n * Every `<SceneCanvas>` asks it, under the id `'rotation'`.\n */\nexport function rotationSnapSource(): SnapSource {\n  let cached: { key: readonly unknown[]; angles: number[] } | null = null;\n  const nodeAngles = (q: AngleCollect): readonly number[] => {\n    const { scene, rotationOf } = q;\n    if (!scene || !rotationOf) return [];\n    const key = [scene, scene.getVersion(), rotationOf, q.exclude];\n    if (cached && key.every((k, i) => k === cached!.key[i])) return cached.angles;\n    const exclude = new Set(q.exclude);\n    const angles: number[] = [];\n    for (const id of scene.nodes.keys()) {\n      if (exclude.has(id) || scene.isHidden(id as NodeId)) continue;\n      const angle = rotationOf(id);\n      if (angle !== undefined && Number.isFinite(angle)) angles.push(angle);\n    }\n    cached = { key, angles };\n    return angles;\n  };\n  return {\n    id: 'rotation',\n    roles: [],\n    gestures: ['rotate'],\n    collect: () => [],\n    *angles(q): Iterable<AngleCandidate> {\n      for (let k = 0; k < 4; k++) yield { angle: k * QUARTER };\n      for (const angle of nodeAngles(q)) yield { angle };\n    },\n  };\n}\n"],"mappings":";AAGA,IAAM,UAAU,KAAK,KAAK;;;;;;AAO1B,SAAgB,qBAAiC;CAC/C,IAAI,SAA+D;CACnE,MAAM,cAAc,MAAuC;EACzD,MAAM,EAAE,OAAO,eAAe;EAC9B,IAAI,CAAC,SAAS,CAAC,YAAY,OAAO,CAAC;EACnC,MAAM,MAAM;GAAC;GAAO,MAAM,WAAW;GAAG;GAAY,EAAE;EAAO;EAC7D,IAAI,UAAU,IAAI,OAAO,GAAG,MAAM,MAAM,OAAQ,IAAI,EAAE,GAAG,OAAO,OAAO;EACvE,MAAM,UAAU,IAAI,IAAI,EAAE,OAAO;EACjC,MAAM,SAAmB,CAAC;EAC1B,KAAK,MAAM,MAAM,MAAM,MAAM,KAAK,GAAG;GACnC,IAAI,QAAQ,IAAI,EAAE,KAAK,MAAM,SAAS,EAAY,GAAG;GACrD,MAAM,QAAQ,WAAW,EAAE;GAC3B,IAAI,UAAU,UAAa,OAAO,SAAS,KAAK,GAAG,OAAO,KAAK,KAAK;EACtE;EACA,SAAS;GAAE;GAAK;EAAO;EACvB,OAAO;CACT;CACA,OAAO;EACL,IAAI;EACJ,OAAO,CAAC;EACR,UAAU,CAAC,QAAQ;EACnB,eAAe,CAAC;EAChB,CAAC,OAAO,GAA6B;GACnC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,MAAM,EAAE,OAAO,IAAI,QAAQ;GACvD,KAAK,MAAM,SAAS,WAAW,CAAC,GAAG,MAAM,EAAE,MAAM;EACnD;CACF;AACF"}

package/dist/features/snap/sceneReads.js

@@ -0,0 +1,45 @@
+import { scenePoseFrame } from "../../interactions/actions/poseFrame.js";
+import { nodeDescriptors, poseDescriptorOf } from "../../interactions/actions/poseDescriptorDep.js";
+import { AUTO_ORIGIN_PROJECTION } from "../../interactions/gestures/shared/originProjection.js";
+
+//#region src/features/snap/sceneReads.ts
+/** {@link ProbeReads} over a canvas's scene, read when a session begins.
+*  `boxes` is the canvas's `drawnBoxes`, which alignment measures with too. */
+function sceneProbeReads(args) {
+	const { scene } = args;
+	const frame = scenePoseFrame(scene);
+	return {
+		pose: (id) => scene.get(id) === void 0 ? void 0 : frame.world(id),
+		drawnBox: (id, pose) => args.boxes.aabb(id, pose),
+		origin: (pose) => (args.originProjection ?? AUTO_ORIGIN_PROJECTION).getOrigin(pose),
+		...args.geometryAt ? { geometryAt: args.geometryAt } : {}
+	};
+}
+/** Each node's world rotation, read through its own descriptor the way a
+*  rotate reads its subject; undefined for a node that cannot turn. */
+function sceneRotations(scene, descriptor) {
+	const frame = scenePoseFrame(scene);
+	const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(descriptor));
+	return (id) => {
+		const node = scene.get(id);
+		if (!node) return void 0;
+		const d = descriptorOf(id);
+		if (!d.withRotation || !d.getRotation || d.supportsRotation?.(node.pose) === false) return void 0;
+		return d.getRotation(frame.world(id));
+	};
+}
+/** `ids` and every node under them: what a gesture moving `ids` carries. */
+function withSubtrees(scene, ids) {
+	const out = /* @__PURE__ */ new Set();
+	const walk = (id) => {
+		if (out.has(id)) return;
+		out.add(id);
+		if (scene.get(id) !== void 0) for (const c of scene.childrenOf(id)) walk(c);
+	};
+	for (const id of ids) walk(id);
+	return [...out];
+}
+
+//#endregion
+export { sceneProbeReads, sceneRotations, withSubtrees };
+//# sourceMappingURL=sceneReads.js.map

package/dist/features/snap/sceneReads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneReads.js","names":[],"sources":["../../../src/features/snap/sceneReads.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { DrawnBoxes } from 'interactions/actions/drawnBoxes';\nimport { nodeDescriptors, poseDescriptorOf } from 'interactions/actions/poseDescriptorDep';\nimport { scenePoseFrame } from 'interactions/actions/poseFrame';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { AUTO_ORIGIN_PROJECTION, type OriginProjection } from 'interactions/gestures/shared/originProjection';\nimport type { ProbeReads } from './probes2d';\n\ntype Point = { x: number; y: number };\n\n/** {@link ProbeReads} over a canvas's scene, read when a session begins.\n *  `boxes` is the canvas's `drawnBoxes`, which alignment measures with too. */\nexport function sceneProbeReads(args: {\n  scene: Scene<unknown, string, unknown>;\n  boxes: DrawnBoxes;\n  geometryAt?: (press: Point, ids: readonly string[]) => Point | null;\n  /** How a pose's origin is read. Default `AUTO_ORIGIN_PROJECTION`. */\n  originProjection?: OriginProjection<unknown>;\n}): ProbeReads {\n  const { scene } = args;\n  const frame = scenePoseFrame(scene);\n  return {\n    pose: (id) => (scene.get(id as NodeId) === undefined ? undefined : frame.world(id as NodeId)),\n    drawnBox: (id, pose) => args.boxes.aabb(id, pose),\n    origin: (pose) => (args.originProjection ?? AUTO_ORIGIN_PROJECTION).getOrigin(pose),\n    ...(args.geometryAt ? { geometryAt: args.geometryAt } : {}),\n  };\n}\n\n/** Each node's world rotation, read through its own descriptor the way a\n *  rotate reads its subject; undefined for a node that cannot turn. */\nexport function sceneRotations(\n  scene: Scene<unknown, string, unknown>,\n  descriptor?: PoseDescriptor<unknown>,\n): (id: string) => number | undefined {\n  const frame = scenePoseFrame(scene);\n  const descriptorOf = nodeDescriptors(scene, poseDescriptorOf(descriptor));\n  return (id) => {\n    const node = scene.get(id as NodeId);\n    if (!node) return undefined;\n    const d = descriptorOf(id);\n    if (!d.withRotation || !d.getRotation || d.supportsRotation?.(node.pose) === false) return undefined;\n    return d.getRotation(frame.world(id as NodeId));\n  };\n}\n\n/** `ids` and every node under them: what a gesture moving `ids` carries. */\nexport function withSubtrees(scene: Scene<unknown, string, unknown>, ids: readonly string[]): string[] {\n  const out = new Set<string>();\n  const walk = (id: string): void => {\n    if (out.has(id)) return;\n    out.add(id);\n    if (scene.get(id as NodeId) !== undefined) for (const c of scene.childrenOf(id as NodeId)) walk(c);\n  };\n  for (const id of ids) walk(id);\n  return [...out];\n}\n"],"mappings":";;;;;;;AAYA,SAAgB,gBAAgB,MAMjB;CACb,MAAM,EAAE,UAAU;CAClB,MAAM,QAAQ,eAAe,KAAK;CAClC,OAAO;EACL,OAAO,OAAQ,MAAM,IAAI,EAAY,MAAM,SAAY,SAAY,MAAM,MAAM,EAAY;EAC3F,WAAW,IAAI,SAAS,KAAK,MAAM,KAAK,IAAI,IAAI;EAChD,SAAS,UAAU,KAAK,oBAAoB,uBAAA,CAAwB,UAAU,IAAI;EAClF,GAAI,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;CAC3D;AACF;;;AAIA,SAAgB,eACd,OACA,YACoC;CACpC,MAAM,QAAQ,eAAe,KAAK;CAClC,MAAM,eAAe,gBAAgB,OAAO,iBAAiB,UAAU,CAAC;CACxE,QAAQ,OAAO;EACb,MAAM,OAAO,MAAM,IAAI,EAAY;EACnC,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,IAAI,aAAa,EAAE;EACzB,IAAI,CAAC,EAAE,gBAAgB,CAAC,EAAE,eAAe,EAAE,mBAAmB,KAAK,IAAI,MAAM,OAAO,OAAO;EAC3F,OAAO,EAAE,YAAY,MAAM,MAAM,EAAY,CAAC;CAChD;AACF;;AAGA,SAAgB,aAAa,OAAwC,KAAkC;CACrG,MAAM,sBAAM,IAAI,IAAY;CAC5B,MAAM,QAAQ,OAAqB;EACjC,IAAI,IAAI,IAAI,EAAE,GAAG;EACjB,IAAI,IAAI,EAAE;EACV,IAAI,MAAM,IAAI,EAAY,MAAM,QAAW,KAAK,MAAM,KAAK,MAAM,WAAW,EAAY,GAAG,KAAK,CAAC;CACnG;CACA,KAAK,MAAM,MAAM,KAAK,KAAK,EAAE;CAC7B,OAAO,CAAC,GAAG,GAAG;AAChB"}

package/dist/features/snap/sceneSession2d.js

@@ -0,0 +1,81 @@
+import { drawnBoxes } from "../../interactions/actions/drawnBoxes.js";
+import { createSnapOutcomeStore } from "./outcomeStore.js";
+import { DEFAULT_SNAP_PX, createSession2d } from "./session2d.js";
+import { buildProbes, subjectOf } from "./probes2d.js";
+import { sceneProbeReads, sceneRotations, withSubtrees } from "./sceneReads.js";
+
+//#region src/features/snap/sceneSession2d.ts
+/** A 2D session whose probes are the subject's, read from the scene at press. */
+function sceneSession2d(i) {
+	const reads = sceneProbeReads({
+		scene: i.scene,
+		boxes: i.boxes,
+		...i.geometryAt ? { geometryAt: i.geometryAt } : {},
+		...i.originProjection ? { originProjection: i.originProjection } : {}
+	});
+	const subject = subjectOf(i.req, reads);
+	return createSession2d({
+		req: i.req,
+		sources: i.sources,
+		probes: buildProbes(i.req, reads, subject),
+		box: subject.box,
+		resize: subject.resize,
+		drawnBox: (id) => {
+			const pose = reads.pose(id);
+			return pose === void 0 ? void 0 : reads.drawnBox(id, pose);
+		},
+		...i.req.ids ? { exclude: withSubtrees(i.scene, i.req.ids) } : {},
+		view: i.view,
+		reachPx: i.reachPx,
+		scene: i.scene,
+		rotationOf: sceneRotations(i.scene, i.poseDescriptor),
+		store: i.store,
+		...i.debug ? { debug: i.debug } : {}
+	});
+}
+/**
+* One gesture's snapping over a scene, for a host without `<SceneCanvas>`:
+* the session a canvas's `snap` dep begins, built from the same probes and
+* drawn boxes. Call `at` with each world point the gesture reaches, and
+* `end` when it lets go.
+*/
+function createSnapSession2d(opts) {
+	const view = opts.view;
+	return sceneSession2d({
+		req: {
+			gesture: opts.gesture,
+			press: opts.press,
+			...opts.ids ? { ids: opts.ids } : {},
+			...opts.parent !== void 0 ? { parent: opts.parent } : {},
+			...opts.origin ? { origin: opts.origin } : {},
+			...opts.constrain ? { constrain: opts.constrain } : {},
+			...opts.handle ? { handle: opts.handle } : {},
+			...opts.pivot ? { pivot: opts.pivot } : {},
+			...opts.theta0 !== void 0 ? { theta0: opts.theta0 } : {},
+			...opts.reachRad !== void 0 ? { reachRad: opts.reachRad } : {},
+			...opts.box ? { box: opts.box } : {},
+			...opts.also ? { also: opts.also } : {},
+			...opts.plane ? { plane: () => opts.plane ?? null } : {}
+		},
+		scene: opts.scene,
+		boxes: drawnBoxes({
+			scene: opts.scene,
+			view: {
+				get: () => view,
+				set: () => {}
+			},
+			...opts.poseDescriptor ? { poseDescriptor: opts.poseDescriptor } : {},
+			...opts.boundsIncludeStroke !== void 0 ? { boundsIncludeStroke: opts.boundsIncludeStroke } : {}
+		}),
+		sources: opts.sources,
+		view: () => view,
+		reachPx: opts.reachPx ?? DEFAULT_SNAP_PX,
+		store: opts.store ?? createSnapOutcomeStore(),
+		...opts.originProjection ? { originProjection: opts.originProjection } : {},
+		...opts.poseDescriptor ? { poseDescriptor: opts.poseDescriptor } : {}
+	});
+}
+
+//#endregion
+export { createSnapSession2d, sceneSession2d };
+//# sourceMappingURL=sceneSession2d.js.map

package/dist/features/snap/sceneSession2d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneSession2d.js","names":[],"sources":["../../../src/features/snap/sceneSession2d.ts"],"sourcesContent":["import type { ResizeAnchor } from '@weasel-js/routing';\nimport type { View } from '@weasel-js/geom';\nimport type { DebugSink } from '@weasel-js/routing';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Scene } from 'core/scene/types';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { OriginProjection } from 'interactions/gestures/shared/originProjection';\nimport { drawnBoxes, type DrawnBoxes } from 'interactions/actions/drawnBoxes';\nimport type { SnapBegin, SnapConstrain, SnapGeometry, SnapResizeBox, SnapSession } from 'interactions/actions/snapDep';\nimport { createSnapOutcomeStore, type SnapOutcomeStore } from './outcomeStore';\nimport { buildProbes, subjectOf } from './probes2d';\nimport { sceneProbeReads, sceneRotations, withSubtrees } from './sceneReads';\nimport { createSession2d, DEFAULT_SNAP_PX } from './session2d';\nimport type { SnapGesture, SnapSource } from './types';\n\ntype Point = { x: number; y: number };\ntype AnyScene = Scene<unknown, string, unknown>;\n\n/** What a session over a scene runs on: its subject's probes and boxes come\n *  from `scene`, measured through `boxes`. */\nexport interface SceneSessionInputs {\n  req: SnapBegin;\n  scene: AnyScene;\n  boxes: DrawnBoxes;\n  sources: readonly SnapSource[];\n  view(): View | null;\n  reachPx: number;\n  store: SnapOutcomeStore;\n  geometryAt?: (press: Point, ids: readonly string[]) => Point | null;\n  /** How a pose's origin is read. Default `AUTO_ORIGIN_PROJECTION`. */\n  originProjection?: OriginProjection<unknown>;\n  /** How a node's rotation is read. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n  /** Where each frame's candidates are recorded. */\n  debug?: DebugSink;\n}\n\n/** A 2D session whose probes are the subject's, read from the scene at press. */\nexport function sceneSession2d(i: SceneSessionInputs): SnapSession {\n  const reads = sceneProbeReads({\n    scene: i.scene, boxes: i.boxes,\n    ...(i.geometryAt ? { geometryAt: i.geometryAt } : {}),\n    ...(i.originProjection ? { originProjection: i.originProjection } : {}),\n  });\n  const subject = subjectOf(i.req, reads);\n  return createSession2d({\n    req: i.req,\n    sources: i.sources,\n    probes: buildProbes(i.req, reads, subject),\n    box: subject.box,\n    resize: subject.resize,\n    drawnBox: (id) => {\n      const pose = reads.pose(id);\n      return pose === undefined ? undefined : reads.drawnBox(id, pose);\n    },\n    ...(i.req.ids ? { exclude: withSubtrees(i.scene, i.req.ids) } : {}),\n    view: i.view,\n    reachPx: i.reachPx,\n    scene: i.scene,\n    rotationOf: sceneRotations(i.scene, i.poseDescriptor),\n    store: i.store,\n    ...(i.debug ? { debug: i.debug } : {}),\n  });\n}\n\n/** Options for {@link createSnapSession2d}. */\nexport interface SnapSession2dOptions {\n  scene: AnyScene;\n  /** The camera the reach is measured through. */\n  view: View;\n  sources: readonly SnapSource[];\n  gesture: SnapGesture;\n  /** World coords. */\n  press: Point;\n  /** The subject, whose geometry offers no targets. */\n  ids?: readonly string[];\n  /** The container a subject not yet in the scene lands in. */\n  parent?: string;\n  /** Point gestures: the previous anchor, a line's start. */\n  origin?: Point;\n  constrain?: SnapConstrain;\n  /** Resize: the sides the drag pins. */\n  handle?: ResizeAnchor;\n  /** Rotate: the point the angle turns about. */\n  pivot?: Point;\n  /** Rotate: the subject's angle at press. */\n  theta0?: number;\n  /** Angle gestures: the reach as an angle, radians. */\n  reachRad?: number;\n  /** Resize: the box `handle` belongs to. Default: the subjects' drawn box. */\n  box?: SnapResizeBox;\n  also?: SnapGeometry;\n  /** The reach of a source that sets none, in screen px. Default `DEFAULT_SNAP_PX`. */\n  reachPx?: number;\n  /** Where the session writes its marks. Default: a store of its own. */\n  store?: SnapOutcomeStore;\n  /** How poses are read. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<unknown>;\n  /** Whether drawn boxes include the stroke. Default `true`. */\n  boundsIncludeStroke?: boolean;\n  /** How a pose's origin, the point a grid or a guide snaps, is read.\n   *  Default `AUTO_ORIGIN_PROJECTION`: a rect's `{x, y}`, a path's bounds. */\n  originProjection?: OriginProjection<unknown>;\n  /** How `view`'s world maps into the parallax plane the gesture's points\n   *  are in. Default: they are in `view`'s own world. */\n  plane?: PlaneMap | null;\n}\n\n/**\n * One gesture's snapping over a scene, for a host without `<SceneCanvas>`:\n * the session a canvas's `snap` dep begins, built from the same probes and\n * drawn boxes. Call `at` with each world point the gesture reaches, and\n * `end` when it lets go.\n */\nexport function createSnapSession2d(opts: SnapSession2dOptions): SnapSession {\n  const view = opts.view;\n  const req: SnapBegin = {\n    gesture: opts.gesture,\n    press: opts.press,\n    ...(opts.ids ? { ids: opts.ids } : {}),\n    ...(opts.parent !== undefined ? { parent: opts.parent } : {}),\n    ...(opts.origin ? { origin: opts.origin } : {}),\n    ...(opts.constrain ? { constrain: opts.constrain } : {}),\n    ...(opts.handle ? { handle: opts.handle } : {}),\n    ...(opts.pivot ? { pivot: opts.pivot } : {}),\n    ...(opts.theta0 !== undefined ? { theta0: opts.theta0 } : {}),\n    ...(opts.reachRad !== undefined ? { reachRad: opts.reachRad } : {}),\n    ...(opts.box ? { box: opts.box } : {}),\n    ...(opts.also ? { also: opts.also } : {}),\n    ...(opts.plane ? { plane: () => opts.plane ?? null } : {}),\n  };\n  return sceneSession2d({\n    req,\n    scene: opts.scene,\n    boxes: drawnBoxes({\n      scene: opts.scene,\n      view: { get: () => view, set: () => {} },\n      ...(opts.poseDescriptor ? { poseDescriptor: opts.poseDescriptor } : {}),\n      ...(opts.boundsIncludeStroke !== undefined ? { boundsIncludeStroke: opts.boundsIncludeStroke } : {}),\n    }),\n    sources: opts.sources,\n    view: () => view,\n    reachPx: opts.reachPx ?? DEFAULT_SNAP_PX,\n    store: opts.store ?? createSnapOutcomeStore(),\n    ...(opts.originProjection ? { originProjection: opts.originProjection } : {}),\n    ...(opts.poseDescriptor ? { poseDescriptor: opts.poseDescriptor } : {}),\n  });\n}\n"],"mappings":";;;;;;;;AAsCA,SAAgB,eAAe,GAAoC;CACjE,MAAM,QAAQ,gBAAgB;EAC5B,OAAO,EAAE;EAAO,OAAO,EAAE;EACzB,GAAI,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,IAAI,CAAC;EACnD,GAAI,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,iBAAiB,IAAI,CAAC;CACvE,CAAC;CACD,MAAM,UAAU,UAAU,EAAE,KAAK,KAAK;CACtC,OAAO,gBAAgB;EACrB,KAAK,EAAE;EACP,SAAS,EAAE;EACX,QAAQ,YAAY,EAAE,KAAK,OAAO,OAAO;EACzC,KAAK,QAAQ;EACb,QAAQ,QAAQ;EAChB,WAAW,OAAO;GAChB,MAAM,OAAO,MAAM,KAAK,EAAE;GAC1B,OAAO,SAAS,SAAY,SAAY,MAAM,SAAS,IAAI,IAAI;EACjE;EACA,GAAI,EAAE,IAAI,MAAM,EAAE,SAAS,aAAa,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,IAAI,CAAC;EACjE,MAAM,EAAE;EACR,SAAS,EAAE;EACX,OAAO,EAAE;EACT,YAAY,eAAe,EAAE,OAAO,EAAE,cAAc;EACpD,OAAO,EAAE;EACT,GAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;CACtC,CAAC;AACH;;;;;;;AAmDA,SAAgB,oBAAoB,MAAyC;CAC3E,MAAM,OAAO,KAAK;CAgBlB,OAAO,eAAe;EACpB;GAfA,SAAS,KAAK;GACd,OAAO,KAAK;GACZ,GAAI,KAAK,MAAM,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC;GACpC,GAAI,KAAK,WAAW,SAAY,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;GAC3D,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;GAC7C,GAAI,KAAK,YAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;GACtD,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;GAC7C,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;GAC1C,GAAI,KAAK,WAAW,SAAY,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;GAC3D,GAAI,KAAK,aAAa,SAAY,EAAE,UAAU,KAAK,SAAS,IAAI,CAAC;GACjE,GAAI,KAAK,MAAM,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC;GACpC,GAAI,KAAK,OAAO,EAAE,MAAM,KAAK,KAAK,IAAI,CAAC;GACvC,GAAI,KAAK,QAAQ,EAAE,aAAa,KAAK,SAAS,KAAK,IAAI,CAAC;EAGxD;EACA,OAAO,KAAK;EACZ,OAAO,WAAW;GAChB,OAAO,KAAK;GACZ,MAAM;IAAE,WAAW;IAAM,WAAW,CAAC;GAAE;GACvC,GAAI,KAAK,iBAAiB,EAAE,gBAAgB,KAAK,eAAe,IAAI,CAAC;GACrE,GAAI,KAAK,wBAAwB,SAAY,EAAE,qBAAqB,KAAK,oBAAoB,IAAI,CAAC;EACpG,CAAC;EACD,SAAS,KAAK;EACd,YAAY;EACZ,SAAS,KAAK,WAAW;EACzB,OAAO,KAAK,SAAS,uBAAuB;EAC5C,GAAI,KAAK,mBAAmB,EAAE,kBAAkB,KAAK,iBAAiB,IAAI,CAAC;EAC3E,GAAI,KAAK,iBAAiB,EAAE,gBAAgB,KAAK,eAAe,IAAI,CAAC;CACvE,CAAC;AACH"}

package/dist/features/snap/screen.js

@@ -0,0 +1,23 @@
+import { viewToTransform } from "../../core/viewport/view.js";
+import { fromPlane } from "../../core/viewport/parallax.js";
+import { worldToScreen } from "../../core/viewport/viewTransform.js";
+
+//#region src/features/snap/screen.ts
+/** A point in the gesture's plane to screen px. */
+function screenOf(view, plane) {
+	const t = view ? viewToTransform(view) : null;
+	return ([x, y]) => {
+		const w = plane ? fromPlane(plane, {
+			x,
+			y
+		}) : {
+			x,
+			y
+		};
+		return t ? worldToScreen(w.x, w.y, t) : [w.x, w.y];
+	};
+}
+
+//#endregion
+export { screenOf };
+//# sourceMappingURL=screen.js.map

package/dist/features/snap/screen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.js","names":[],"sources":["../../../src/features/snap/screen.ts"],"sourcesContent":["import type { View } from '@weasel-js/geom';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { fromPlane, type PlaneMap } from 'core/viewport/parallax';\n\n/** A point in the gesture's plane to screen px. */\nexport function screenOf(view: View | null, plane: PlaneMap | null): (w: readonly number[]) => readonly number[] {\n  const t = view ? viewToTransform(view) : null;\n  return ([x, y]) => {\n    const w = plane ? fromPlane(plane, { x, y }) : { x, y };\n    return t ? worldToScreen(w.x, w.y, t) : [w.x, w.y];\n  };\n}\n"],"mappings":";;;;;;AAMA,SAAgB,SAAS,MAAmB,OAAqE;CAC/G,MAAM,IAAI,OAAO,gBAAgB,IAAI,IAAI;CACzC,QAAQ,CAAC,GAAG,OAAO;EACjB,MAAM,IAAI,QAAQ,UAAU,OAAO;GAAE;GAAG;EAAE,CAAC,IAAI;GAAE;GAAG;EAAE;EACtD,OAAO,IAAI,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;CACnD;AACF"}

package/dist/features/snap/session2d.js

@@ -0,0 +1,143 @@
+import { resizeEdges, resizeSubject, resizedBox } from "./resizeBox.js";
+import { markFromPlane } from "./marks.js";
+import { screenOf } from "./screen.js";
+import { angleAt } from "./angle2d.js";
+import { inputFlat } from "./inputSubspace.js";
+import { gatherSnapCandidates, resolvedSnapMarks, snapSourcesFor } from "./gather.js";
+import { recordSnapCandidates } from "./debugCandidates.js";
+import { createSnapOutcomeStore } from "./outcomeStore.js";
+import { closestOnFlat, resolveSnap } from "@weasel-js/geom/nd";
+
+//#region src/features/snap/session2d.ts
+/** The canvas's reach when neither a source nor the kit settings name one. */
+var DEFAULT_SNAP_PX = 8;
+/** A snap session over a 2D canvas: ctx points are world points. */
+function createSession2d(inputs) {
+	const { req, store } = inputs;
+	const sources = snapSourcesFor(inputs.sources, req.gesture);
+	const fixed = collectAtPress(inputs);
+	return {
+		at(p, mods) {
+			const delta0 = {
+				x: p.x - req.press.x,
+				y: p.y - req.press.y
+			};
+			const input = inputFlat(req, mods, delta0, inputs.resize);
+			if (mods.suspend) {
+				store.set([]);
+				inputs.debug?.clearSnap();
+				return outcome(req.press, closestOnFlat(input, [delta0.x, delta0.y]), false, []);
+			}
+			const view = inputs.view();
+			const plane = req.plane?.() ?? null;
+			const subject = subjectAt(inputs, delta0);
+			const candidates = collectAll(sources, inputs.probes, {
+				...fixed,
+				...subject
+			}, {
+				delta0,
+				view,
+				plane
+			}, inputs.reachPx);
+			const res = resolveSnap({
+				probes: inputs.probes.map((q) => ({
+					id: q.id,
+					at: [q.at.x, q.at.y],
+					role: q.role
+				})),
+				input,
+				delta0: [delta0.x, delta0.y],
+				candidates,
+				toScreen: screenOf(view, plane)
+			});
+			if (inputs.debug) recordSnapCandidates(inputs.debug, candidates, res.satisfied, inputs.probes, delta0, plane);
+			const delta = {
+				x: res.delta[0],
+				y: res.delta[1]
+			};
+			const marks = resolvedSnapMarks(res.satisfied, delta);
+			store.set(plane ? marks.map((m) => markFromPlane(m, plane)) : marks);
+			return outcome(req.press, res.delta, res.members.length > 0, marks);
+		},
+		angle: (theta, mods) => angleAt(inputs, sources, theta, mods),
+		end() {
+			store.set([]);
+			inputs.debug?.clearSnap();
+		}
+	};
+}
+function outcome(press, delta, held, marks) {
+	return {
+		point: {
+			x: press.x + delta[0],
+			y: press.y + delta[1]
+		},
+		held,
+		marks
+	};
+}
+function collectAtPress(inputs) {
+	const { req } = inputs;
+	return {
+		gesture: req.gesture,
+		...req.ids ? { ids: req.ids } : {},
+		...req.parent !== void 0 ? { parent: req.parent } : {},
+		exclude: inputs.exclude ?? req.ids ?? [],
+		...inputs.drawnBox ? { drawnBox: inputs.drawnBox } : {},
+		...req.origin ? { origin: req.origin } : {},
+		...req.also ? { also: req.also } : {},
+		...inputs.scene ? { scene: inputs.scene } : {}
+	};
+}
+function collectAll(sources, probesAtPress, fixed, { delta0, view, plane }, reachPx) {
+	const camera = view ? Math.min(Math.abs(view.scale.x), Math.abs(view.scale.y)) : 1;
+	const scale = plane ? camera / Math.max(Math.abs(plane.scale.x), Math.abs(plane.scale.y)) : camera;
+	const probes = probesAtPress.map((q) => ({
+		...q,
+		at: {
+			x: q.at.x + delta0.x,
+			y: q.at.y + delta0.y
+		}
+	}));
+	return gatherSnapCandidates(sources, probes, (_source, offered, sourceReach) => ({
+		...fixed,
+		probes: offered,
+		delta0,
+		...plane ? { plane } : {},
+		reachWorld: (px) => px / scale,
+		reachPx: sourceReach
+	}), {
+		toVec: (p) => [p.x, p.y],
+		reachPx,
+		...fixed.origin ? { origin: fixed.origin } : {}
+	});
+}
+/** The subject's box where `delta0` puts it, and the sides that moved. */
+function subjectAt({ box, resize }, delta0) {
+	if (resize) return {
+		box: resizedBox(resize, delta0),
+		edges: resizeEdges(resize, delta0)
+	};
+	return box ? { box: {
+		...box,
+		x: box.x + delta0.x,
+		y: box.y + delta0.y
+	} } : {};
+}
+/** A session no source answers: it only holds the point to the gesture's
+*  input subspace, as when a host provides no `snap` dep. */
+function inputSession(req) {
+	return createSession2d({
+		req,
+		sources: [],
+		probes: [],
+		resize: req.gesture === "resize" && req.handle && req.box ? resizeSubject(req.box, req.handle) : null,
+		view: () => null,
+		reachPx: 0,
+		store: createSnapOutcomeStore()
+	});
+}
+
+//#endregion
+export { DEFAULT_SNAP_PX, createSession2d, inputSession };
+//# sourceMappingURL=session2d.js.map

package/dist/features/snap/session2d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session2d.js","names":[],"sources":["../../../src/features/snap/session2d.ts"],"sourcesContent":["import { closestOnFlat, resolveSnap, type SnapCandidate } from '@weasel-js/geom/nd';\nimport type { View } from '@weasel-js/geom';\nimport type { DebugSink } from '@weasel-js/routing';\nimport type { Scene } from 'core/scene/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { SnapBegin, SnapOutcome, SnapSession } from 'interactions/actions/snapDep';\nimport { angleAt } from './angle2d';\nimport { inputFlat } from './inputSubspace';\nimport { gatherSnapCandidates, resolvedSnapMarks, snapSourcesFor, type SnapCandidateMark } from './gather';\nimport { recordSnapCandidates } from './debugCandidates';\nimport { markFromPlane } from './marks';\nimport { createSnapOutcomeStore, type SnapOutcomeStore } from './outcomeStore';\nimport { resizedBox, resizeEdges, resizeSubject, type ResizeSubject } from './resizeBox';\nimport { screenOf } from './screen';\nimport type { SnapCollect, SnapMark, SnapProbeAt, SnapSource } from './types';\n\ntype Point = { x: number; y: number };\n\n/** The canvas's reach when neither a source nor the kit settings name one. */\nexport const DEFAULT_SNAP_PX = 8;\n\n/** What a 2D session runs on, captured at press. */\nexport interface Session2dInputs {\n  req: SnapBegin;\n  /** In source order: earlier wins a full tie. */\n  sources: readonly SnapSource[];\n  /** At press. */\n  probes: readonly SnapProbeAt[];\n  /** A move's subject: its drawn box at press. */\n  box?: Bounds | null;\n  /** A resize's box and frame. */\n  resize?: ResizeSubject | null;\n  /** `id`'s drawn box now, for sources measuring the scene the way the\n   *  subject's box was. */\n  drawnBox?: (id: string) => Bounds | undefined;\n  view(): View | null;\n  /** The reach of a source that sets none, in screen px. */\n  reachPx: number;\n  scene?: Scene<unknown, string, unknown>;\n  /** `id`'s world rotation, for angle targets; undefined for a node that\n   *  cannot turn. */\n  rotationOf?: (id: string) => number | undefined;\n  store: SnapOutcomeStore;\n  /** Nodes that offer no targets. Default `req.ids`. */\n  exclude?: readonly string[];\n  /** Where each frame's candidates are recorded, cleared at `end`. */\n  debug?: DebugSink;\n}\n\n/** A snap session over a 2D canvas: ctx points are world points. */\nexport function createSession2d(inputs: Session2dInputs): SnapSession {\n  const { req, store } = inputs;\n  const sources = snapSourcesFor(inputs.sources, req.gesture);\n  const fixed = collectAtPress(inputs);\n  return {\n    at(p, mods) {\n      const delta0 = { x: p.x - req.press.x, y: p.y - req.press.y };\n      const input = inputFlat(req, mods, delta0, inputs.resize);\n      if (mods.suspend) {\n        store.set([]);\n        inputs.debug?.clearSnap();\n        return outcome(req.press, closestOnFlat(input, [delta0.x, delta0.y]), false, []);\n      }\n      const view = inputs.view();\n      const plane = req.plane?.() ?? null;\n      const subject = subjectAt(inputs, delta0);\n      const candidates = collectAll(sources, inputs.probes, { ...fixed, ...subject }, { delta0, view, plane }, inputs.reachPx);\n      const res = resolveSnap({\n        probes: inputs.probes.map((q) => ({ id: q.id, at: [q.at.x, q.at.y], role: q.role })),\n        input,\n        delta0: [delta0.x, delta0.y],\n        candidates,\n        toScreen: screenOf(view, plane),\n      });\n      if (inputs.debug) recordSnapCandidates(inputs.debug, candidates, res.satisfied, inputs.probes, delta0, plane);\n      const delta = { x: res.delta[0], y: res.delta[1] };\n      const marks = resolvedSnapMarks(res.satisfied, delta);\n      store.set(plane ? marks.map((m) => markFromPlane(m, plane)) : marks);\n      return outcome(req.press, res.delta, res.members.length > 0, marks);\n    },\n    angle: (theta, mods) => angleAt(inputs, sources, theta, mods),\n    end() {\n      store.set([]);\n      inputs.debug?.clearSnap();\n    },\n  };\n}\n\nfunction outcome(press: Point, delta: readonly number[], held: boolean, marks: readonly SnapMark[]): SnapOutcome {\n  return { point: { x: press.x + delta[0], y: press.y + delta[1] }, held, marks };\n}\n\n/** What a source is told that holds from press to release. */\ntype FixedCollect = Pick<SnapCollect, 'gesture' | 'ids' | 'parent' | 'exclude' | 'drawnBox' | 'origin' | 'also' | 'scene'>;\n\n/** What changes from one frame to the next. */\ninterface Frame {\n  delta0: Point;\n  view: View | null;\n  plane: PlaneMap | null;\n}\n\nfunction collectAtPress(inputs: Session2dInputs): FixedCollect {\n  const { req } = inputs;\n  return {\n    gesture: req.gesture,\n    ...(req.ids ? { ids: req.ids } : {}),\n    ...(req.parent !== undefined ? { parent: req.parent } : {}),\n    exclude: inputs.exclude ?? req.ids ?? [],\n    ...(inputs.drawnBox ? { drawnBox: inputs.drawnBox } : {}),\n    ...(req.origin ? { origin: req.origin } : {}),\n    ...(req.also ? { also: req.also } : {}),\n    ...(inputs.scene ? { scene: inputs.scene } : {}),\n  };\n}\n\nfunction collectAll(\n  sources: readonly SnapSource[], probesAtPress: readonly SnapProbeAt[],\n  fixed: FixedCollect & Pick<SnapCollect, 'box' | 'edges'>, { delta0, view, plane }: Frame, reachPx: number,\n): SnapCandidate<SnapCandidateMark<Point>>[] {\n  const camera = view ? Math.min(Math.abs(view.scale.x), Math.abs(view.scale.y)) : 1;\n  // A camera unit is `plane.scale` plane units.\n  const scale = plane ? camera / Math.max(Math.abs(plane.scale.x), Math.abs(plane.scale.y)) : camera;\n  const probes = probesAtPress.map((q) => ({ ...q, at: { x: q.at.x + delta0.x, y: q.at.y + delta0.y } }));\n  return gatherSnapCandidates(sources, probes, (_source, offered, sourceReach) => ({\n    ...fixed, probes: offered, delta0,\n    ...(plane ? { plane } : {}),\n    reachWorld: (px) => px / scale,\n    reachPx: sourceReach,\n  }), { toVec: (p) => [p.x, p.y], reachPx, ...(fixed.origin ? { origin: fixed.origin } : {}) });\n}\n\n/** The subject's box where `delta0` puts it, and the sides that moved. */\nfunction subjectAt(\n  { box, resize }: Pick<Session2dInputs, 'box' | 'resize'>, delta0: Point,\n): Pick<SnapCollect, 'box' | 'edges'> {\n  if (resize) return { box: resizedBox(resize, delta0), edges: resizeEdges(resize, delta0) };\n  return box ? { box: { ...box, x: box.x + delta0.x, y: box.y + delta0.y } } : {};\n}\n\n/** A session no source answers: it only holds the point to the gesture's\n *  input subspace, as when a host provides no `snap` dep. */\nexport function inputSession(req: SnapBegin): SnapSession {\n  return createSession2d({\n    req,\n    sources: [],\n    probes: [],\n    resize: req.gesture === 'resize' && req.handle && req.box ? resizeSubject(req.box, req.handle) : null,\n    view: () => null,\n    reachPx: 0,\n    store: createSnapOutcomeStore(),\n  });\n}\n"],"mappings":"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"}

package/dist/features/snap/spanSnap.js

@@ -0,0 +1,80 @@
+import { inputSession } from "./session2d.js";
+
+//#region src/features/snap/spanSnap.ts
+/**
+* A `point` session for each end of a span. The end's session has the
+* snapped start as its `origin`, so a `constrain` step turns about the start
+* as drawn. `constrain` is read whenever the end snaps, and a new value
+* reopens the end's session. With no `snap` dep, or one that runs no
+* sessions, only `constrain` applies. `common` goes into every session's
+* request.
+*/
+function spanSnap(dep, constrain = () => void 0, common = {}) {
+	const begin = (req) => dep?.begin(req) ?? inputSession(req);
+	let raw = {
+		x: 0,
+		y: 0
+	};
+	let start = raw;
+	let held = false;
+	let live = null;
+	const open = () => {
+		const c = constrain();
+		const key = JSON.stringify(c ?? null);
+		if (live?.key === key) return live.session;
+		live?.session.end();
+		live = {
+			session: begin({
+				...common,
+				gesture: "point",
+				press: start,
+				origin: start,
+				...c ? { constrain: c } : {}
+			}),
+			key
+		};
+		return live.session;
+	};
+	const place = (p, mods) => {
+		raw = p;
+		live?.session.end();
+		live = null;
+		const out = begin({
+			...common,
+			gesture: "point",
+			press: p
+		});
+		const landed = out.at(p, mods);
+		out.end();
+		start = landed.point;
+		held = landed.held;
+		open().at(start, {
+			...mods,
+			constrain: false
+		});
+		return landed;
+	};
+	return {
+		start: place,
+		carry: (dx, dy, mods) => place({
+			x: raw.x + dx,
+			y: raw.y + dy
+		}, mods),
+		end: (p, mods) => open().at(p, mods),
+		anchor(p) {
+			if (p.x === start.x && p.y === start.y) return;
+			start = p;
+			live?.session.end();
+			live = null;
+		},
+		startHeld: () => held,
+		close() {
+			live?.session.end();
+			live = null;
+		}
+	};
+}
+
+//#endregion
+export { spanSnap };
+//# sourceMappingURL=spanSnap.js.map

package/dist/features/snap/spanSnap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanSnap.js","names":[],"sources":["../../../src/features/snap/spanSnap.ts"],"sourcesContent":["import type { SnapBegin, SnapConstrain, SnapDep, SnapMods, SnapOutcome, SnapSession } from 'interactions/actions/snapDep';\nimport { inputSession } from './session2d';\n\ntype Point = { x: number; y: number };\n\n/** A two-point gesture's snapping: a drawn line, a measurement, a box. */\nexport interface SpanSnap {\n  /** Snap the start, pressed at `p`. The end then snaps about where it lands. */\n  start(p: Point, mods: SnapMods): SnapOutcome;\n  /** Move the start by `(dx, dy)` from where it was pressed or last carried\n   *  to, unsnapped, and snap it there. */\n  carry(dx: number, dy: number, mods: SnapMods): SnapOutcome;\n  /** Snap the end. */\n  end(p: Point, mods: SnapMods): SnapOutcome;\n  /** Turn the end about `p`, a start placed by something other than this\n   *  snap. */\n  anchor(p: Point): void;\n  /** Whether a target holds the start. */\n  startHeld(): boolean;\n  /** Clears the gesture's marks. */\n  close(): void;\n}\n\n/**\n * A `point` session for each end of a span. The end's session has the\n * snapped start as its `origin`, so a `constrain` step turns about the start\n * as drawn. `constrain` is read whenever the end snaps, and a new value\n * reopens the end's session. With no `snap` dep, or one that runs no\n * sessions, only `constrain` applies. `common` goes into every session's\n * request.\n */\nexport function spanSnap(\n  dep: SnapDep | undefined,\n  constrain: () => SnapConstrain | undefined = () => undefined,\n  common: Pick<SnapBegin, 'parent'> = {},\n): SpanSnap {\n  const begin = (req: SnapBegin): SnapSession => dep?.begin(req) ?? inputSession(req);\n  let raw: Point = { x: 0, y: 0 };\n  let start: Point = raw;\n  let held = false;\n  let live: { session: SnapSession; key: string } | null = null;\n\n  const open = (): SnapSession => {\n    const c = constrain();\n    const key = JSON.stringify(c ?? null);\n    if (live?.key === key) return live.session;\n    live?.session.end();\n    live = { session: begin({ ...common, gesture: 'point', press: start, origin: start, ...(c ? { constrain: c } : {}) }), key };\n    return live.session;\n  };\n  const place = (p: Point, mods: SnapMods): SnapOutcome => {\n    raw = p;\n    live?.session.end();\n    live = null;\n    const out = begin({ ...common, gesture: 'point', press: p });\n    const landed = out.at(p, mods);\n    out.end();\n    start = landed.point;\n    held = landed.held;\n    // Draws the start's marks again, from the session the end runs in.\n    open().at(start, { ...mods, constrain: false });\n    return landed;\n  };\n\n  return {\n    start: place,\n    carry: (dx, dy, mods) => place({ x: raw.x + dx, y: raw.y + dy }, mods),\n    end: (p, mods) => open().at(p, mods),\n    anchor(p) {\n      if (p.x === start.x && p.y === start.y) return;\n      start = p;\n      live?.session.end();\n      live = null;\n    },\n    startHeld: () => held,\n    close() {\n      live?.session.end();\n      live = null;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;AA+BA,SAAgB,SACd,KACA,kBAAmD,QACnD,SAAoC,CAAC,GAC3B;CACV,MAAM,SAAS,QAAgC,KAAK,MAAM,GAAG,KAAK,aAAa,GAAG;CAClF,IAAI,MAAa;EAAE,GAAG;EAAG,GAAG;CAAE;CAC9B,IAAI,QAAe;CACnB,IAAI,OAAO;CACX,IAAI,OAAqD;CAEzD,MAAM,aAA0B;EAC9B,MAAM,IAAI,UAAU;EACpB,MAAM,MAAM,KAAK,UAAU,KAAK,IAAI;EACpC,IAAI,MAAM,QAAQ,KAAK,OAAO,KAAK;EACnC,MAAM,QAAQ,IAAI;EAClB,OAAO;GAAE,SAAS,MAAM;IAAE,GAAG;IAAQ,SAAS;IAAS,OAAO;IAAO,QAAQ;IAAO,GAAI,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC;GAAG,CAAC;GAAG;EAAI;EAC3H,OAAO,KAAK;CACd;CACA,MAAM,SAAS,GAAU,SAAgC;EACvD,MAAM;EACN,MAAM,QAAQ,IAAI;EAClB,OAAO;EACP,MAAM,MAAM,MAAM;GAAE,GAAG;GAAQ,SAAS;GAAS,OAAO;EAAE,CAAC;EAC3D,MAAM,SAAS,IAAI,GAAG,GAAG,IAAI;EAC7B,IAAI,IAAI;EACR,QAAQ,OAAO;EACf,OAAO,OAAO;EAEd,KAAK,CAAC,CAAC,GAAG,OAAO;GAAE,GAAG;GAAM,WAAW;EAAM,CAAC;EAC9C,OAAO;CACT;CAEA,OAAO;EACL,OAAO;EACP,QAAQ,IAAI,IAAI,SAAS,MAAM;GAAE,GAAG,IAAI,IAAI;GAAI,GAAG,IAAI,IAAI;EAAG,GAAG,IAAI;EACrE,MAAM,GAAG,SAAS,KAAK,CAAC,CAAC,GAAG,GAAG,IAAI;EACnC,OAAO,GAAG;GACR,IAAI,EAAE,MAAM,MAAM,KAAK,EAAE,MAAM,MAAM,GAAG;GACxC,QAAQ;GACR,MAAM,QAAQ,IAAI;GAClB,OAAO;EACT;EACA,iBAAiB;EACjB,QAAQ;GACN,MAAM,QAAQ,IAAI;GAClB,OAAO;EACT;CACF;AACF"}

package/dist/features/snap/stepAngles.js

@@ -0,0 +1,15 @@
+//#region src/features/snap/stepAngles.ts
+/** The multiples of `step` either side of `theta`, and the nearest: the
+*  angles an angle step offers a direction at `theta`. Radians. */
+function stepAngles(theta, step) {
+	const k = Math.round(theta / step);
+	return [
+		k - 1,
+		k,
+		k + 1
+	].map((i) => i * step);
+}
+
+//#endregion
+export { stepAngles };
+//# sourceMappingURL=stepAngles.js.map

package/dist/features/snap/stepAngles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepAngles.js","names":[],"sources":["../../../src/features/snap/stepAngles.ts"],"sourcesContent":["/** The multiples of `step` either side of `theta`, and the nearest: the\n *  angles an angle step offers a direction at `theta`. Radians. */\nexport function stepAngles(theta: number, step: number): number[] {\n  const k = Math.round(theta / step);\n  return [k - 1, k, k + 1].map((i) => i * step);\n}\n"],"mappings":";;;AAEA,SAAgB,WAAW,OAAe,MAAwB;CAChE,MAAM,IAAI,KAAK,MAAM,QAAQ,IAAI;CACjC,OAAO;EAAC,IAAI;EAAG;EAAG,IAAI;CAAC,CAAC,CAAC,KAAK,MAAM,IAAI,IAAI;AAC9C"}

package/dist/features/text/editingDrawOne.js

@@ -0,0 +1,32 @@
+import { defaultDrawOne } from "../../canvas/defaultDrawOne.js";
+
+//#region src/features/text/editingDrawOne.ts
+/** `defaultDrawOne`, less the text commands of the node `editingId` names. */
+function drawOneEditing(editingId) {
+	return (node, pose, view, ctx) => {
+		const out = defaultDrawOne(node, pose, view, ctx);
+		return node.id === editingId ? withoutText(out) : out;
+	};
+}
+/** `cmds` with every text command gone, at any depth, and any group left
+*  empty by it — a clipped node's glyphs ride in one. */
+function withoutText(cmds) {
+	const out = [];
+	for (const c of cmds) {
+		if (c.kind === "text") continue;
+		if (c.kind !== "group") {
+			out.push(c);
+			continue;
+		}
+		const children = withoutText(c.children);
+		if (children.length > 0) out.push({
+			...c,
+			children
+		});
+	}
+	return out;
+}
+
+//#endregion
+export { drawOneEditing };
+//# sourceMappingURL=editingDrawOne.js.map

package/dist/features/text/editingDrawOne.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editingDrawOne.js","names":[],"sources":["../../../src/features/text/editingDrawOne.ts"],"sourcesContent":["import type { Node } from '../../core/scene/types';\nimport type { View } from '../../core/viewport/view';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { defaultDrawOne } from '../../canvas/defaultDrawOne';\nimport type { NodePaintCtx } from '../../canvas/NodeShape';\n\n/** A scene `drawOne` that leaves out one node's glyphs. */\nexport type EditingDrawOne = <TNode extends Node<unknown, string, unknown>>(\n  node: TNode, pose: unknown, view?: View, ctx?: NodePaintCtx,\n) => DrawCommand[];\n\n/** `defaultDrawOne`, less the text commands of the node `editingId` names. */\nexport function drawOneEditing(editingId: string | null): EditingDrawOne {\n  return (node, pose, view, ctx) => {\n    const out = defaultDrawOne(node, pose, view, ctx);\n    return node.id === editingId ? withoutText(out) : out;\n  };\n}\n\n/** `cmds` with every text command gone, at any depth, and any group left\n *  empty by it — a clipped node's glyphs ride in one. */\nfunction withoutText(cmds: readonly DrawCommand[]): DrawCommand[] {\n  const out: DrawCommand[] = [];\n  for (const c of cmds) {\n    if (c.kind === 'text') continue;\n    if (c.kind !== 'group') {\n      out.push(c);\n      continue;\n    }\n    const children = withoutText(c.children);\n    if (children.length > 0) out.push({ ...c, children });\n  }\n  return out;\n}\n"],"mappings":";;;;AAYA,SAAgB,eAAe,WAA0C;CACvE,QAAQ,MAAM,MAAM,MAAM,QAAQ;EAChC,MAAM,MAAM,eAAe,MAAM,MAAM,MAAM,GAAG;EAChD,OAAO,KAAK,OAAO,YAAY,YAAY,GAAG,IAAI;CACpD;AACF;;;AAIA,SAAS,YAAY,MAA6C;CAChE,MAAM,MAAqB,CAAC;CAC5B,KAAK,MAAM,KAAK,MAAM;EACpB,IAAI,EAAE,SAAS,QAAQ;EACvB,IAAI,EAAE,SAAS,SAAS;GACtB,IAAI,KAAK,CAAC;GACV;EACF;EACA,MAAM,WAAW,YAAY,EAAE,QAAQ;EACvC,IAAI,SAAS,SAAS,GAAG,IAAI,KAAK;GAAE,GAAG;GAAG;EAAS,CAAC;CACtD;CACA,OAAO;AACT"}

package/dist/features/text/index.js

@@ -1,6 +1,7 @@
-import { createTextLayer as e } from "./textLayer.js";
-import { useSceneTextEdit as t } from "./useSceneTextEdit.js";
-import { textCommand as n, textCommandFromPose as r, textCommandFromRuns as i } from "@weasel-js/renderer";
-import { TextOutlinesError as a, loadTextOutlines as o, textToPath as s, textToPathsByPaint as c } from "@weasel-js/text";
-import { TEXT_EDIT_FONT_HOLD as l, charOffsetToDomPosition as u, domPositionToCharOffset as d, domToRuns as f, runsToDom as p, useTextEdit as m } from "@weasel-js/text-dom";
-export { l as TEXT_EDIT_FONT_HOLD, a as TextOutlinesError, u as charOffsetToDomPosition, e as createTextLayer, d as domPositionToCharOffset, f as domToRuns, o as loadTextOutlines, p as runsToDom, n as textCommand, r as textCommandFromPose, i as textCommandFromRuns, s as textToPath, c as textToPathsByPaint, t as useSceneTextEdit, m as useTextEdit };
+import { createTextLayer } from "./textLayer.js";
+import { useSceneTextEdit } from "./useSceneTextEdit.js";
+import { textCommand as textCommand$1, textCommandFromPose as textCommandFromPose$1, textCommandFromRuns as textCommandFromRuns$1 } from "@weasel-js/renderer";
+import { TextOutlinesError as TextOutlinesError$1, loadTextOutlines as loadTextOutlines$1, textToPath as textToPath$1, textToPathsByPaint as textToPathsByPaint$1 } from "@weasel-js/text";
+import { TEXT_EDIT_FONT_HOLD, charOffsetToDomPosition, domPositionToCharOffset, domToRuns, runsToDom, useTextEdit as useTextEdit$1 } from "@weasel-js/text-dom";
+
+export { TEXT_EDIT_FONT_HOLD, TextOutlinesError$1 as TextOutlinesError, charOffsetToDomPosition, createTextLayer, domPositionToCharOffset, domToRuns, loadTextOutlines$1 as loadTextOutlines, runsToDom, textCommand$1 as textCommand, textCommandFromPose$1 as textCommandFromPose, textCommandFromRuns$1 as textCommandFromRuns, textToPath$1 as textToPath, textToPathsByPaint$1 as textToPathsByPaint, useSceneTextEdit, useTextEdit$1 as useTextEdit };