@weasel-js/core 1.10.1 → 1.11.0

package/dist/features/snap/roles.js

@@ -0,0 +1,31 @@
+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 to: 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 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;\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 to: 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;;AAGzC,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,30 @@
+//#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() {
+	return {
+		id: "rotation",
+		roles: [],
+		gestures: ["rotate"],
+		collect: () => [],
+		*angles(q) {
+			for (let k = 0; k < 4; k++) yield { angle: k * QUARTER };
+			const { scene, rotationOf } = q;
+			if (!scene || !rotationOf) return;
+			const exclude = new Set(q.exclude);
+			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)) 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, 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  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      const { scene, rotationOf } = q;\n      if (!scene || !rotationOf) return;\n      const exclude = new Set(q.exclude);\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)) yield { angle };\n      }\n    },\n  };\n}\n"],"mappings":";AAGA,IAAM,UAAU,KAAK,KAAK;;;;;;AAO1B,SAAgB,qBAAiC;CAC/C,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,MAAM,EAAE,OAAO,eAAe;GAC9B,IAAI,CAAC,SAAS,CAAC,YAAY;GAC3B,MAAM,UAAU,IAAI,IAAI,EAAE,OAAO;GACjC,KAAK,MAAM,MAAM,MAAM,MAAM,KAAK,GAAG;IACnC,IAAI,QAAQ,IAAI,EAAE,KAAK,MAAM,SAAS,EAAY,GAAG;IACrD,MAAM,QAAQ,WAAW,EAAE;IAC3B,IAAI,UAAU,UAAa,OAAO,SAAS,KAAK,GAAG,MAAM,EAAE,MAAM;GACnE;EACF;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,79 @@
+import { drawnBoxes } from "../../interactions/actions/drawnBoxes.js";
+import { createSnapOutcomeStore } from "./outcomeStore.js";
+import { DEFAULT_SNAP_PX, createSession2d } from "./session2d.js";
+import { buildProbes, resizeSubjectOf, subjectBox } 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 } : {}
+	});
+	return createSession2d({
+		req: i.req,
+		sources: i.sources,
+		probes: buildProbes(i.req, reads),
+		box: i.req.ids ? subjectBox(i.req.ids, reads) : null,
+		resize: resizeSubjectOf(i.req, reads),
+		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.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, resizeSubjectOf, subjectBox } 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  return createSession2d({\n    req: i.req,\n    sources: i.sources,\n    probes: buildProbes(i.req, reads),\n    box: i.req.ids ? subjectBox(i.req.ids, reads) : null,\n    resize: resizeSubjectOf(i.req, reads),\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  /** 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.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,OAAO,gBAAgB;EACrB,KAAK,EAAE;EACP,SAAS,EAAE;EACX,QAAQ,YAAY,EAAE,KAAK,KAAK;EAChC,KAAK,EAAE,IAAI,MAAM,WAAW,EAAE,IAAI,KAAK,KAAK,IAAI;EAChD,QAAQ,gBAAgB,EAAE,KAAK,KAAK;EACpC,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;;;;;;;AAiDA,SAAgB,oBAAoB,MAAyC;CAC3E,MAAM,OAAO,KAAK;CAelB,OAAO,eAAe;EACpB;GAdA,SAAS,KAAK;GACd,OAAO,KAAK;GACZ,GAAI,KAAK,MAAM,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC;GACpC,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,129 @@
+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);
+	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 candidates = collectAll(inputs, sources, delta0, view, plane);
+			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 collectAll(inputs, sources, delta0, view, plane) {
+	const { req } = inputs;
+	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 = inputs.probes.map((q) => ({
+		...q,
+		at: {
+			x: q.at.x + delta0.x,
+			y: q.at.y + delta0.y
+		}
+	}));
+	return gatherSnapCandidates(sources, probes, (_source, offered, reachPx) => ({
+		gesture: req.gesture,
+		probes: offered,
+		delta0,
+		exclude: inputs.exclude ?? req.ids ?? [],
+		...plane ? { plane } : {},
+		...subjectAt(inputs, delta0),
+		...inputs.drawnBox ? { drawnBox: inputs.drawnBox } : {},
+		...req.origin ? { origin: req.origin } : {},
+		...req.also ? { also: req.also } : {},
+		reachWorld: (px) => px / scale,
+		reachPx,
+		...inputs.scene ? { scene: inputs.scene } : {}
+	}), {
+		toVec: (p) => [p.x, p.y],
+		reachPx: inputs.reachPx,
+		...req.origin ? { origin: req.origin } : {}
+	});
+}
+/** The subject's box where `delta0` puts it, and the sides that moved. */
+function subjectAt(inputs, delta0) {
+	if (inputs.resize) return {
+		box: resizedBox(inputs.resize, delta0),
+		edges: resizeEdges(inputs.resize, delta0)
+	};
+	const b = inputs.req.gesture === "move" ? inputs.box : null;
+	return b ? { box: {
+		...b,
+		x: b.x + delta0.x,
+		y: b.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\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  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 candidates = collectAll(inputs, sources, delta0, view, plane);\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\nfunction collectAll(\n  inputs: Session2dInputs, sources: readonly SnapSource[], delta0: Point, view: View | null, plane: PlaneMap | null,\n): SnapCandidate<SnapCandidateMark<Point>>[] {\n  const { req } = inputs;\n  const camera = view ? Math.min(Math.abs(view.scale.x), Math.abs(view.scale.y)) : 1;\n  // A plane unit is `plane.scale` camera units the other way round.\n  const scale = plane ? camera / Math.max(Math.abs(plane.scale.x), Math.abs(plane.scale.y)) : camera;\n  const probes = inputs.probes.map((q) => ({ ...q, at: { x: q.at.x + delta0.x, y: q.at.y + delta0.y } }));\n  return gatherSnapCandidates(sources, probes, (_source, offered, reachPx) => ({\n    gesture: req.gesture, probes: offered, delta0, exclude: inputs.exclude ?? req.ids ?? [],\n    ...(plane ? { plane } : {}),\n    ...subjectAt(inputs, delta0),\n    ...(inputs.drawnBox ? { drawnBox: inputs.drawnBox } : {}),\n    ...(req.origin ? { origin: req.origin } : {}),\n    ...(req.also ? { also: req.also } : {}),\n    reachWorld: (px) => px / scale,\n    reachPx,\n    ...(inputs.scene ? { scene: inputs.scene } : {}),\n  }), { toVec: (p) => [p.x, p.y], reachPx: inputs.reachPx, ...(req.origin ? { origin: req.origin } : {}) });\n}\n\n/** The subject's box where `delta0` puts it, and the sides that moved. */\nfunction subjectAt(inputs: Session2dInputs, delta0: Point): Pick<SnapCollect, 'box' | 'edges'> {\n  if (inputs.resize) return { box: resizedBox(inputs.resize, delta0), edges: resizeEdges(inputs.resize, delta0) };\n  const b = inputs.req.gesture === 'move' ? inputs.box : null;\n  return b ? { box: { ...b, x: b.x + delta0.x, y: b.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,77 @@
+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.
+*/
+function spanSnap(dep, constrain = () => void 0) {
+	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({
+				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({
+			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.\n */\nexport function spanSnap(dep: SnapDep | undefined, constrain: () => SnapConstrain | undefined = () => undefined): 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({ 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({ 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":";;;;;;;;;;AA8BA,SAAgB,SAAS,KAA0B,kBAAmD,QAAqB;CACzH,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,SAAS;IAAS,OAAO;IAAO,QAAQ;IAAO,GAAI,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC;GAAG,CAAC;GAAG;EAAI;EAChH,OAAO,KAAK;CACd;CACA,MAAM,SAAS,GAAU,SAAgC;EACvD,MAAM;EACN,MAAM,QAAQ,IAAI;EAClB,OAAO;EACP,MAAM,MAAM,MAAM;GAAE,SAAS;GAAS,OAAO;EAAE,CAAC;EAChD,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 };

package/dist/features/text/textHitAt.js

@@ -0,0 +1,51 @@
+import { targetTransformOf, worldToLocal } from "../../core/geometry/targetFrame.js";
+import { textBoxOf } from "../../canvas/nodeShapes/textPainter.js";
+import { scenePaintedPoseOf } from "../../canvas/derivedPath.js";
+import { caretIndexAt, pointInTextPose } from "@weasel-js/text";
+
+//#region src/features/text/textHitAt.ts
+/**
+* The top-most unlocked text node at world `(cx, cy)`, and the caret there.
+*
+* `pointInTextPose` and `caretIndexAt` work in the node's own box, so the
+* point is taken back through the frame the node is drawn in. The whole box
+* takes the point, padding included; the caret is placed in the inset one.
+*/
+function textHitAt(scene, read, cx, cy) {
+	const order = scene.renderOrderNodes();
+	const paintedPoseOf = scenePaintedPoseOf(scene);
+	for (let i = order.length - 1; i >= 0; i--) {
+		const node = order[i];
+		if (scene.isLocked(node.id) || scene.isHidden(node.id)) continue;
+		if (!read.isText(node.data)) continue;
+		const at = paintedPoseOf(node);
+		const p = worldToLocal(targetTransformOf(at), cx, cy);
+		if (!p) continue;
+		const pose = {
+			...textBoxOf({ padding: read.padding(node.data) }, at),
+			text: read.text(node.data),
+			runs: read.runs(node.data),
+			style: read.style(node.data),
+			verticalAlign: read.verticalAlign(node.data)
+		};
+		const box = {
+			x: at.x,
+			y: at.y,
+			width: at.width,
+			height: at.height
+		};
+		if (!pointInTextPose(p.x, p.y, {
+			...pose,
+			...box
+		})) continue;
+		return {
+			id: String(node.id),
+			caret: caretIndexAt(p.x, p.y, pose)
+		};
+	}
+	return null;
+}
+
+//#endregion
+export { textHitAt };
+//# sourceMappingURL=textHitAt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textHitAt.js","names":[],"sources":["../../../src/features/text/textHitAt.ts"],"sourcesContent":["import type { Scene } from '../../core/scene/types';\nimport type { RectPose } from 'core/geometry/unionBounds';\nimport { scenePaintedPoseOf } from '../../canvas/derivedPath';\nimport { targetTransformOf, worldToLocal } from 'core/geometry/targetFrame';\nimport { caretIndexAt, pointInTextPose, type StyledRun, type TextStyle, type TextVerticalAlign } from '@weasel-js/text';\nimport { textBoxOf } from '../../canvas/nodeShapes/textPainter';\n\n/** How a node's text fields are read from its `data`. */\nexport interface TextReads<TData> {\n  isText(data: TData): boolean;\n  text(data: TData): string;\n  style(data: TData): TextStyle | undefined;\n  runs(data: TData): readonly StyledRun[] | undefined;\n  verticalAlign(data: TData): TextVerticalAlign | undefined;\n  padding(data: TData): number | undefined;\n}\n\n/**\n * The top-most unlocked text node at world `(cx, cy)`, and the caret there.\n *\n * `pointInTextPose` and `caretIndexAt` work in the node's own box, so the\n * point is taken back through the frame the node is drawn in. The whole box\n * takes the point, padding included; the caret is placed in the inset one.\n */\nexport function textHitAt<TData, TPose extends RectPose>(\n  scene: Scene<TData, string, TPose>,\n  read: TextReads<TData>,\n  cx: number,\n  cy: number,\n): { id: string; caret: number } | null {\n  // renderOrder() is back-to-front, so iterate in reverse and stop on the first hit.\n  const order = scene.renderOrderNodes();\n  const paintedPoseOf = scenePaintedPoseOf(scene);\n  for (let i = order.length - 1; i >= 0; i--) {\n    const node = order[i];\n    if (scene.isLocked(node.id) || scene.isHidden(node.id)) continue;\n    if (!read.isText(node.data)) continue;\n    const at = paintedPoseOf(node);\n    const p = worldToLocal(targetTransformOf(at), cx, cy);\n    if (!p) continue;\n    const pose = {\n      ...textBoxOf({ padding: read.padding(node.data) }, at),\n      text: read.text(node.data),\n      runs: read.runs(node.data) as StyledRun[] | undefined,\n      style: read.style(node.data),\n      verticalAlign: read.verticalAlign(node.data),\n    };\n    const box = { x: at.x, y: at.y, width: at.width, height: at.height };\n    if (!pointInTextPose(p.x, p.y, { ...pose, ...box })) continue;\n    return { id: String(node.id), caret: caretIndexAt(p.x, p.y, pose) };\n  }\n  return null;\n}\n"],"mappings":";;;;;;;;;;;;;AAwBA,SAAgB,UACd,OACA,MACA,IACA,IACsC;CAEtC,MAAM,QAAQ,MAAM,iBAAiB;CACrC,MAAM,gBAAgB,mBAAmB,KAAK;CAC9C,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;EAC1C,MAAM,OAAO,MAAM;EACnB,IAAI,MAAM,SAAS,KAAK,EAAE,KAAK,MAAM,SAAS,KAAK,EAAE,GAAG;EACxD,IAAI,CAAC,KAAK,OAAO,KAAK,IAAI,GAAG;EAC7B,MAAM,KAAK,cAAc,IAAI;EAC7B,MAAM,IAAI,aAAa,kBAAkB,EAAE,GAAG,IAAI,EAAE;EACpD,IAAI,CAAC,GAAG;EACR,MAAM,OAAO;GACX,GAAG,UAAU,EAAE,SAAS,KAAK,QAAQ,KAAK,IAAI,EAAE,GAAG,EAAE;GACrD,MAAM,KAAK,KAAK,KAAK,IAAI;GACzB,MAAM,KAAK,KAAK,KAAK,IAAI;GACzB,OAAO,KAAK,MAAM,KAAK,IAAI;GAC3B,eAAe,KAAK,cAAc,KAAK,IAAI;EAC7C;EACA,MAAM,MAAM;GAAE,GAAG,GAAG;GAAG,GAAG,GAAG;GAAG,OAAO,GAAG;GAAO,QAAQ,GAAG;EAAO;EACnE,IAAI,CAAC,gBAAgB,EAAE,GAAG,EAAE,GAAG;GAAE,GAAG;GAAM,GAAG;EAAI,CAAC,GAAG;EACrD,OAAO;GAAE,IAAI,OAAO,KAAK,EAAE;GAAG,OAAO,aAAa,EAAE,GAAG,EAAE,GAAG,IAAI;EAAE;CACpE;CACA,OAAO;AACT"}