@weasel-js/core 1.10.1 → 1.11.0

package/dist/features/measure/measureGestures.js

@@ -0,0 +1,185 @@
+import { measureBetween, measureEndsOf, withMeasureEnd } from "./measurement.js";
+import { commitOps } from "../../interactions/actions/defaultCommitAdapter.js";
+import { SNAP_ANGLE_STEP, SNAP_ROLES, snapMods } from "../snap/roles.js";
+import { spanSnap } from "../snap/spanSnap.js";
+import { measureAt } from "./measureHit.js";
+import { addMeasureOp, moveEndOps, moveMeasureOps, translatedMeasure } from "./measureEdits.js";
+import { MEASURE_ACTION_IDS } from "./actionIds.js";
+import { resolveParams } from "@weasel-js/routing";
+
+//#region src/features/measure/measureGestures.ts
+/** Screen-px radius around a measurement that picks it. */
+var MEASURE_HIT_PX = 6;
+var pointOf = (at) => at.drag?.current ?? at.world;
+/** World units `px` screen pixels span at the deps' view. */
+function pxToWorld(deps, px) {
+	return px / ((deps?.view?.get().scale.x ?? 1) || 1);
+}
+/**
+* The measure tool's drag: from press to pointer, each end through a `point`
+* session of the `snap` dep. While `snap.constrain` (Shift) is held the end
+* stays on the line through the snapped start at the nearest step of the
+* binding param `angleStep` (radians, default 15°), and lands where that line
+* meets a target. The drawing shows in `ms.draft`; on release it becomes a
+* measurement node, one undo step, and the picked one.
+*/
+function measureCreateAction(ms) {
+	return {
+		id: MEASURE_ACTION_IDS.measure,
+		label: "Measure",
+		modifierRoles: SNAP_ROLES,
+		requires: [
+			"snap",
+			"scene",
+			"applyOps",
+			"selection"
+		],
+		invoker: {
+			timing: "ongoing",
+			start(ctx, opts) {
+				const deps = ctx.deps;
+				const snap = spanSnap(deps.snap, () => {
+					const step = resolveParams(opts?.params)?.["angleStep"];
+					return { step: typeof step === "number" ? step : SNAP_ANGLE_STEP };
+				});
+				const start = snap.start(ctx.drag?.start ?? ctx.world, snapMods(ctx)).point;
+				const endAt = (at) => snap.end(pointOf(at), snapMods(at)).point;
+				ms.draft.set(measureBetween(start, start));
+				return {
+					kind: "measure",
+					onMove: (moveCtx) => ms.draft.set(measureBetween(start, endAt(moveCtx))),
+					onEnd: (endCtx, reason) => {
+						try {
+							ms.draft.set(null);
+							const scene = deps.scene;
+							if (reason !== "commit" || !scene) return;
+							const end = endAt(endCtx);
+							if (end.x === start.x && end.y === start.y) return;
+							const { id, op } = addMeasureOp(scene, ms.layer, start, end);
+							commitOps(deps, [op], "Measure");
+							ms.picked.set(id);
+						} finally {
+							snap.close();
+						}
+					}
+				};
+			}
+		}
+	};
+}
+/** The measure tool's click: picks the measurement under it, or drops the
+*  pick on empty canvas. */
+function measurePickAtAction(ms) {
+	return {
+		id: MEASURE_ACTION_IDS.pickAt,
+		label: "Pick Measurement",
+		requires: ["scene", "view"],
+		invoker: {
+			timing: "immediate",
+			run: (deps, params) => {
+				const p = params;
+				const scene = deps.scene;
+				if (!scene || p?.pressX === void 0 || p.pressY === void 0) return;
+				const hit = measureAt(scene, ms, {
+					x: p.pressX,
+					y: p.pressY
+				}, pxToWorld(deps, MEASURE_HIT_PX));
+				ms.picked.set(hit?.id ?? null);
+			}
+		}
+	};
+}
+/** What a press on the measurements layer resolved, as its hit-test claims it. */
+var hitOf = (affordance) => affordance?.payload ?? null;
+/** A click on a measurement under any tool: picks it, leaving the content
+*  selection as it was. */
+function measurePickAction(ms) {
+	return {
+		id: MEASURE_ACTION_IDS.pick,
+		label: "Pick Measurement",
+		invoker: {
+			timing: "immediate",
+			run: (_deps, params) => {
+				const hit = hitOf(params?.affordance);
+				if (hit) ms.picked.set(hit.id);
+			}
+		}
+	};
+}
+/** The node `id` on `scene`, as a measurement edit reads it. */
+function nodeOf(scene, id) {
+	return scene?.get(id);
+}
+/**
+* A drag on a measurement under any tool. On an end of the picked
+* measurement it moves that end, keeping its offset from the press, through
+* a `point` session of the `snap` dep in which the measurement's own ends
+* offer nothing; anywhere else on a
+* measurement it carries the whole measurement with the pointer. Previewed
+* while it runs; one undo step on release.
+*/
+function measureDragAction(ms) {
+	return {
+		id: MEASURE_ACTION_IDS.drag,
+		label: "Drag Measurement",
+		modifierRoles: SNAP_ROLES,
+		requires: [
+			"scene",
+			"snap",
+			"applyOps",
+			"selection"
+		],
+		invoker: {
+			timing: "ongoing",
+			start(ctx) {
+				const hit = hitOf(ctx.drag?.affordance);
+				const deps = ctx.deps;
+				const scene = deps.scene;
+				const node = hit ? nodeOf(scene, hit.id) : void 0;
+				if (!hit || !node) return {};
+				const end = hit.part !== "line" && ms.picked.get() === hit.id ? hit.part : null;
+				const from = ctx.drag?.start ?? ctx.world;
+				const grabbed = end && measureEndsOf(node)?.[end] || from;
+				const snap = end ? deps.snap?.begin({
+					gesture: "point",
+					press: grabbed,
+					ids: [hit.id]
+				}) ?? null : null;
+				let at = from;
+				let landed = grabbed;
+				const next = () => end ? withMeasureEnd(node, end, landed) : translatedMeasure(node, at.x - from.x, at.y - from.y);
+				const follow = (c) => {
+					at = pointOf(c);
+					const held = {
+						x: grabbed.x + at.x - from.x,
+						y: grabbed.y + at.y - from.y
+					};
+					landed = snap ? snap.at(held, snapMods(c)).point : held;
+				};
+				ms.picked.set(hit.id);
+				return {
+					kind: MEASURE_ACTION_IDS.drag,
+					onMove: follow,
+					onEnd: (endCtx, reason) => {
+						try {
+							if (reason !== "commit") return;
+							follow(endCtx);
+							const ops = end ? moveEndOps(node, end, landed) : moveMeasureOps(node, at.x - from.x, at.y - from.y);
+							commitOps(deps, ops, ops[0]?.label ?? "Move Measurement");
+						} finally {
+							snap?.end();
+						}
+					},
+					previewIds: () => [hit.id],
+					previewOpaqueIds: () => [hit.id],
+					previewPose: () => next()?.pose ?? null,
+					previewData: () => next()?.data ?? null
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+export { MEASURE_HIT_PX, hitOf, measureCreateAction, measureDragAction, measurePickAction, measurePickAtAction, pxToWorld };
+//# sourceMappingURL=measureGestures.js.map

package/dist/features/measure/measureGestures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measureGestures.js","names":[],"sources":["../../../src/features/measure/measureGestures.ts"],"sourcesContent":["import type { Action, ActionDeps, BindingOpts, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { commitOps } from 'interactions/actions/defaultCommitAdapter';\nimport { SNAP_ANGLE_STEP, SNAP_ROLES, snapMods } from 'features/snap/roles';\nimport { spanSnap } from 'features/snap/spanSnap';\nimport { measureBetween, measureEndsOf, withMeasureEnd, type MeasureEnd, type MeasurePoint } from './measurement';\nimport type { Measurements } from './measurements';\nimport { measureAt, type MeasureHit } from './measureHit';\nimport { addMeasureOp, moveEndOps, moveMeasureOps, translatedMeasure } from './measureEdits';\nimport { MEASURE_ACTION_IDS } from './actionIds';\n\ntype AnyScene = Scene<unknown, string, unknown>;\n\n/** Screen-px radius around a measurement that picks it. */\nexport const MEASURE_HIT_PX = 6;\n\nconst pointOf = (at: InvocationCtx): MeasurePoint => at.drag?.current ?? at.world;\n\n/** World units `px` screen pixels span at the deps' view. */\nexport function pxToWorld(deps: ActionDeps | undefined, px: number): number {\n  const scale = deps?.view?.get().scale.x ?? 1;\n  return px / (scale || 1);\n}\n\n/**\n * The measure tool's drag: from press to pointer, each end through a `point`\n * session of the `snap` dep. While `snap.constrain` (Shift) is held the end\n * stays on the line through the snapped start at the nearest step of the\n * binding param `angleStep` (radians, default 15°), and lands where that line\n * meets a target. The drawing shows in `ms.draft`; on release it becomes a\n * measurement node, one undo step, and the picked one.\n */\nexport function measureCreateAction(ms: Measurements): Action {\n  return {\n    id: MEASURE_ACTION_IDS.measure,\n    label: 'Measure',\n    modifierRoles: SNAP_ROLES,\n    requires: ['snap', 'scene', 'applyOps', 'selection'],\n    invoker: {\n      timing: 'ongoing',\n      // The dispatcher builds deps once, for `start`; later events carry none.\n      start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n        const deps = ctx.deps;\n        // Read on every event, so a step changed mid-drag reaches it.\n        const snap = spanSnap(deps.snap, () => {\n          const step = resolveParams(opts?.params)?.['angleStep'];\n          return { step: typeof step === 'number' ? step : SNAP_ANGLE_STEP };\n        });\n        const start = snap.start(ctx.drag?.start ?? ctx.world, snapMods(ctx)).point;\n        const endAt = (at: InvocationCtx): MeasurePoint => snap.end(pointOf(at), snapMods(at)).point;\n        ms.draft.set(measureBetween(start, start));\n        return {\n          kind: 'measure',\n          onMove: (moveCtx) => ms.draft.set(measureBetween(start, endAt(moveCtx))),\n          onEnd: (endCtx, reason) => {\n            try {\n              ms.draft.set(null);\n              const scene = deps.scene as AnyScene | undefined;\n              if (reason !== 'commit' || !scene) return;\n              const end = endAt(endCtx);\n              if (end.x === start.x && end.y === start.y) return;\n              const { id, op } = addMeasureOp(scene, ms.layer, start, end);\n              commitOps(deps, [op], 'Measure');\n              ms.picked.set(id);\n            } finally {\n              snap.close();\n            }\n          },\n        };\n      },\n    },\n  };\n}\n\n/** The measure tool's click: picks the measurement under it, or drops the\n *  pick on empty canvas. */\nexport function measurePickAtAction(ms: Measurements): Action {\n  return {\n    id: MEASURE_ACTION_IDS.pickAt,\n    label: 'Pick Measurement',\n    requires: ['scene', 'view'],\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const p = params as { pressX?: number; pressY?: number } | undefined;\n        const scene = deps.scene as AnyScene | undefined;\n        if (!scene || p?.pressX === undefined || p.pressY === undefined) return;\n        const hit = measureAt(scene, ms, { x: p.pressX, y: p.pressY }, pxToWorld(deps, MEASURE_HIT_PX));\n        ms.picked.set(hit?.id ?? null);\n      },\n    },\n  };\n}\n\n/** What a press on the measurements layer resolved, as its hit-test claims it. */\nexport const hitOf = (affordance: unknown): MeasureHit | null =>\n  (affordance as { payload?: MeasureHit } | null | undefined)?.payload ?? null;\n\n/** A click on a measurement under any tool: picks it, leaving the content\n *  selection as it was. */\nexport function measurePickAction(ms: Measurements): Action {\n  return {\n    id: MEASURE_ACTION_IDS.pick,\n    label: 'Pick Measurement',\n    invoker: {\n      timing: 'immediate',\n      run: (_deps, params) => {\n        const hit = hitOf((params as { affordance?: unknown } | undefined)?.affordance);\n        if (hit) ms.picked.set(hit.id);\n      },\n    },\n  };\n}\n\n/** The node `id` on `scene`, as a measurement edit reads it. */\nfunction nodeOf(scene: AnyScene | undefined, id: NodeId) {\n  return scene?.get(id);\n}\n\n/**\n * A drag on a measurement under any tool. On an end of the picked\n * measurement it moves that end, keeping its offset from the press, through\n * a `point` session of the `snap` dep in which the measurement's own ends\n * offer nothing; anywhere else on a\n * measurement it carries the whole measurement with the pointer. Previewed\n * while it runs; one undo step on release.\n */\nexport function measureDragAction(ms: Measurements): Action {\n  return {\n    id: MEASURE_ACTION_IDS.drag,\n    label: 'Drag Measurement',\n    modifierRoles: SNAP_ROLES,\n    requires: ['scene', 'snap', 'applyOps', 'selection'],\n    invoker: {\n      timing: 'ongoing',\n      start(ctx: InvocationCtx): OngoingHandle {\n        const hit = hitOf(ctx.drag?.affordance);\n        const deps = ctx.deps;\n        const scene = deps.scene as AnyScene | undefined;\n        const node = hit ? nodeOf(scene, hit.id) : undefined;\n        if (!hit || !node) return {};\n        const end: MeasureEnd | null = hit.part !== 'line' && ms.picked.get() === hit.id ? hit.part : null;\n        const from = ctx.drag?.start ?? ctx.world;\n        const grabbed = (end && measureEndsOf(node)?.[end]) || from;\n        const snap = end ? deps.snap?.begin({ gesture: 'point', press: grabbed, ids: [hit.id] }) ?? null : null;\n        let at = from;\n        let landed = grabbed;\n        const next = () => (end\n          ? withMeasureEnd(node, end, landed)\n          : translatedMeasure(node, at.x - from.x, at.y - from.y));\n        const follow = (c: InvocationCtx) => {\n          at = pointOf(c);\n          const held = { x: grabbed.x + at.x - from.x, y: grabbed.y + at.y - from.y };\n          landed = snap ? snap.at(held, snapMods(c)).point : held;\n        };\n        ms.picked.set(hit.id);\n        return {\n          kind: MEASURE_ACTION_IDS.drag,\n          onMove: follow,\n          onEnd: (endCtx, reason) => {\n            try {\n              if (reason !== 'commit') return;\n              follow(endCtx);\n              const ops = end ? moveEndOps(node, end, landed) : moveMeasureOps(node, at.x - from.x, at.y - from.y);\n              commitOps(deps, ops, ops[0]?.label ?? 'Move Measurement');\n            } finally {\n              snap?.end();\n            }\n          },\n          previewIds: () => [hit.id],\n          previewOpaqueIds: () => [hit.id],\n          previewPose: () => next()?.pose ?? null,\n          previewData: () => next()?.data ?? null,\n        };\n      },\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/features/measure/measureHit.js

@@ -0,0 +1,80 @@
+import { measureEndsOf } from "./measurement.js";
+import { nodeGates } from "../../core/scene/nodeGates.js";
+import { measureIds } from "./measurements.js";
+
+//#region src/features/measure/measureHit.ts
+function distanceToSegment(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const len2 = dx * dx + dy * dy;
+	const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));
+	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+/**
+* The measurement under `p`, newest first: an end within `tolerance` world
+* units of it, else a line within the same distance. A hidden or locked
+* measurement (`nodeGates`) is passed over.
+*/
+function measureAt(scene, ms, p, tolerance) {
+	const gates = nodeGates(scene);
+	const ids = measureIds(scene, ms).reverse().filter((id) => !gates.hidden(id) && !gates.locked(id));
+	for (const id of ids) {
+		const ends = measureEndsOf(scene.get(id));
+		if (!ends) continue;
+		for (const part of ["end", "start"]) if (Math.hypot(p.x - ends[part].x, p.y - ends[part].y) <= tolerance) return {
+			id,
+			part
+		};
+	}
+	for (const id of ids) {
+		const ends = measureEndsOf(scene.get(id));
+		if (ends && distanceToSegment(p, ends.start, ends.end) <= tolerance) return {
+			id,
+			part: "line"
+		};
+	}
+	return null;
+}
+/** The ends of every shown measurement as snap targets for a pointer probe. */
+function measureEndSource(opts = {}) {
+	return {
+		id: "measure-ends",
+		roles: ["pointer"],
+		...opts.reachPx !== void 0 ? { reachPx: opts.reachPx } : {},
+		*collect(q) {
+			if (!q.scene) return;
+			const gates = nodeGates(q.scene);
+			const skip = new Set(q.exclude);
+			const reach = q.reachWorld(q.reachPx);
+			for (const node of q.scene.renderOrderNodes()) {
+				const ends = measureEndsOf(node);
+				if (!ends || skip.has(node.id) || gates.hidden(node.id)) continue;
+				for (const end of [ends.start, ends.end]) {
+					const at = {
+						x: end.x,
+						y: end.y
+					};
+					for (const p of q.probes) {
+						if (Math.hypot(at.x - p.at.x, at.y - p.at.y) > reach) continue;
+						yield {
+							probe: p.id,
+							locus: {
+								at,
+								dirs: []
+							},
+							mark: {
+								kind: "point",
+								at,
+								glyph: "center"
+							}
+						};
+					}
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+export { measureAt, measureEndSource };
+//# sourceMappingURL=measureHit.js.map

package/dist/features/measure/measureHit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measureHit.js","names":[],"sources":["../../../src/features/measure/measureHit.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport { measureEndsOf, type MeasureEnd, type MeasurePoint } from './measurement';\nimport { measureIds, type Measurements } from './measurements';\nimport { nodeGates } from 'core/scene/nodeGates';\nimport type { SnapSource } from 'features/snap/types';\n\n/** Which part of which measurement lies under a point. */\nexport interface MeasureHit {\n  id: NodeId;\n  part: MeasureEnd | 'line';\n}\n\n\nfunction distanceToSegment(p: MeasurePoint, a: MeasurePoint, b: MeasurePoint): number {\n  const dx = b.x - a.x;\n  const dy = b.y - a.y;\n  const len2 = dx * dx + dy * dy;\n  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));\n  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));\n}\n\n/**\n * The measurement under `p`, newest first: an end within `tolerance` world\n * units of it, else a line within the same distance. A hidden or locked\n * measurement (`nodeGates`) is passed over.\n */\nexport function measureAt(\n  scene: Pick<Scene<unknown, string, unknown>, 'renderOrderNodes' | 'get' | 'layers'>,\n  ms: Pick<Measurements, 'layer'>,\n  p: MeasurePoint,\n  tolerance: number,\n): MeasureHit | null {\n  const gates = nodeGates(scene);\n  const ids = measureIds(scene, ms).reverse().filter((id) => !gates.hidden(id) && !gates.locked(id));\n  for (const id of ids) {\n    const ends = measureEndsOf(scene.get(id));\n    if (!ends) continue;\n    for (const part of ['end', 'start'] as const) {\n      if (Math.hypot(p.x - ends[part].x, p.y - ends[part].y) <= tolerance) return { id, part };\n    }\n  }\n  for (const id of ids) {\n    const ends = measureEndsOf(scene.get(id));\n    if (ends && distanceToSegment(p, ends.start, ends.end) <= tolerance) return { id, part: 'line' };\n  }\n  return null;\n}\n\n/** Options for `measureEndSource`. */\nexport interface MeasureEndSourceOptions {\n  /** Overrides the canvas's reach for measurement ends, in screen px. */\n  reachPx?: number;\n}\n\n/** The ends of every shown measurement as snap targets for a pointer probe. */\nexport function measureEndSource(opts: MeasureEndSourceOptions = {}): SnapSource {\n  return {\n    id: 'measure-ends',\n    roles: ['pointer'],\n    ...(opts.reachPx !== undefined ? { reachPx: opts.reachPx } : {}),\n    *collect(q) {\n      if (!q.scene) return;\n      const gates = nodeGates(q.scene);\n      const skip = new Set(q.exclude);\n      const reach = q.reachWorld(q.reachPx);\n      for (const node of q.scene.renderOrderNodes()) {\n        const ends = measureEndsOf(node);\n        if (!ends || skip.has(node.id) || gates.hidden(node.id)) continue;\n        for (const end of [ends.start, ends.end]) {\n          const at = { x: end.x, y: end.y };\n          for (const p of q.probes) {\n            if (Math.hypot(at.x - p.at.x, at.y - p.at.y) > reach) continue;\n            yield { probe: p.id, locus: { at, dirs: [] }, mark: { kind: 'point', at, glyph: 'center' } };\n          }\n        }\n      }\n    },\n  };\n}\n"],"mappings":";;;;;AAaA,SAAS,kBAAkB,GAAiB,GAAiB,GAAyB;CACpF,MAAM,KAAK,EAAE,IAAI,EAAE;CACnB,MAAM,KAAK,EAAE,IAAI,EAAE;CACnB,MAAM,OAAO,KAAK,KAAK,KAAK;CAC5B,MAAM,IAAI,SAAS,IAAI,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,KAAK,MAAM,IAAI,CAAC;CAChG,OAAO,KAAK,MAAM,EAAE,KAAK,EAAE,IAAI,IAAI,KAAK,EAAE,KAAK,EAAE,IAAI,IAAI,GAAG;AAC9D;;;;;;AAOA,SAAgB,UACd,OACA,IACA,GACA,WACmB;CACnB,MAAM,QAAQ,UAAU,KAAK;CAC7B,MAAM,MAAM,WAAW,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,QAAQ,OAAO,CAAC,MAAM,OAAO,EAAE,KAAK,CAAC,MAAM,OAAO,EAAE,CAAC;CACjG,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,OAAO,cAAc,MAAM,IAAI,EAAE,CAAC;EACxC,IAAI,CAAC,MAAM;EACX,KAAK,MAAM,QAAQ,CAAC,OAAO,OAAO,GAChC,IAAI,KAAK,MAAM,EAAE,IAAI,KAAK,KAAK,CAAC,GAAG,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC,KAAK,WAAW,OAAO;GAAE;GAAI;EAAK;CAE3F;CACA,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,OAAO,cAAc,MAAM,IAAI,EAAE,CAAC;EACxC,IAAI,QAAQ,kBAAkB,GAAG,KAAK,OAAO,KAAK,GAAG,KAAK,WAAW,OAAO;GAAE;GAAI,MAAM;EAAO;CACjG;CACA,OAAO;AACT;;AASA,SAAgB,iBAAiB,OAAgC,CAAC,GAAe;CAC/E,OAAO;EACL,IAAI;EACJ,OAAO,CAAC,SAAS;EACjB,GAAI,KAAK,YAAY,SAAY,EAAE,SAAS,KAAK,QAAQ,IAAI,CAAC;EAC9D,CAAC,QAAQ,GAAG;GACV,IAAI,CAAC,EAAE,OAAO;GACd,MAAM,QAAQ,UAAU,EAAE,KAAK;GAC/B,MAAM,OAAO,IAAI,IAAI,EAAE,OAAO;GAC9B,MAAM,QAAQ,EAAE,WAAW,EAAE,OAAO;GACpC,KAAK,MAAM,QAAQ,EAAE,MAAM,iBAAiB,GAAG;IAC7C,MAAM,OAAO,cAAc,IAAI;IAC/B,IAAI,CAAC,QAAQ,KAAK,IAAI,KAAK,EAAE,KAAK,MAAM,OAAO,KAAK,EAAE,GAAG;IACzD,KAAK,MAAM,OAAO,CAAC,KAAK,OAAO,KAAK,GAAG,GAAG;KACxC,MAAM,KAAK;MAAE,GAAG,IAAI;MAAG,GAAG,IAAI;KAAE;KAChC,KAAK,MAAM,KAAK,EAAE,QAAQ;MACxB,IAAI,KAAK,MAAM,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,IAAI,EAAE,GAAG,CAAC,IAAI,OAAO;MACtD,MAAM;OAAE,OAAO,EAAE;OAAI,OAAO;QAAE;QAAI,MAAM,CAAC;OAAE;OAAG,MAAM;QAAE,MAAM;QAAS;QAAI,OAAO;OAAS;MAAE;KAC7F;IACF;GACF;EACF;CACF;AACF"}

package/dist/features/measure/measureLayer.js

@@ -0,0 +1,86 @@
+import { viewToTransform } from "../../core/viewport/view.js";
+import { worldToScreen } from "../../core/viewport/viewTransform.js";
+import { OVERLAY_ROLE_STROKES } from "../../canvas/overlayRoleStrokes.js";
+import { measureEndsOf } from "./measurement.js";
+import { measureCommands } from "../../canvas/nodeShapes/measurePainter.js";
+import { measureAt } from "./measureHit.js";
+import { MEASURE_HIT_PX } from "./measureGestures.js";
+import { rectPath } from "@weasel-js/geom";
+
+//#region src/features/measure/measureLayer.ts
+/** The registered layer's id; a press it claims routes as `layer:<id>`. */
+var MEASURE_LAYER_ID = "weasel-measure";
+/** The affordance kind a press on a measurement routes under. */
+var MEASURE_AFFORDANCE_KIND = `layer:${MEASURE_LAYER_ID}`;
+var HANDLE_PX = 3.5;
+/**
+* The measurements' interactive layer, under every tool: it draws the
+* measurement a measure drag is making and a handle on each end of the picked
+* one, and claims a press on a measurement so a click picks it and a drag
+* edits it rather than reaching the tool. Under the measure tool it claims
+* only the picked measurement's ends, so a drag from anywhere else measures.
+*/
+function measurementsLayer(scene, ms) {
+	return {
+		id: MEASURE_LAYER_ID,
+		label: "Measurements",
+		space: "screen",
+		subscribe: (listener) => {
+			const offs = [
+				ms.picked.subscribe(listener),
+				ms.draft.subscribe(listener),
+				ms.measuring.subscribe(listener)
+			];
+			return () => {
+				for (const off of offs) off();
+			};
+		},
+		draw: (_data, view) => {
+			const t = viewToTransform(view);
+			const toScreen = (p) => {
+				const [x, y] = worldToScreen(p.x, p.y, t);
+				return {
+					x,
+					y
+				};
+			};
+			const out = [];
+			const draft = ms.draft.get();
+			if (draft) out.push(...measureCommands(toScreen(draft.start), toScreen(draft.end), 1));
+			const picked = ms.picked.get();
+			const ends = picked === null ? null : measureEndsOf(scene.get(picked));
+			if (ends && !scene.isHidden(picked)) {
+				const stroke = {
+					...OVERLAY_ROLE_STROKES["measure"],
+					width: 1
+				};
+				for (const p of [ends.start, ends.end].map(toScreen)) out.push({
+					kind: "path",
+					path: rectPath(p.x - HANDLE_PX, p.y - HANDLE_PX, HANDLE_PX * 2, HANDLE_PX * 2),
+					fill: { paint: { color: "#ffffff" } },
+					stroke
+				});
+			}
+			return out;
+		},
+		hitTest: (wx, wy, _data, view) => {
+			const hit = measureAt(scene, ms, {
+				x: wx,
+				y: wy
+			}, MEASURE_HIT_PX / (view.scale.x || 1));
+			if (!hit) return null;
+			const onPickedEnd = hit.part !== "line" && hit.id === ms.picked.get();
+			if (ms.measuring.get() && !onPickedEnd) return null;
+			return {
+				initialScratch: hit,
+				strength: "exclusive",
+				claimedKinds: ["pointer"],
+				cursor: onPickedEnd ? "crosshair" : "move"
+			};
+		}
+	};
+}
+
+//#endregion
+export { MEASURE_AFFORDANCE_KIND, MEASURE_LAYER_ID, measurementsLayer };
+//# sourceMappingURL=measureLayer.js.map

package/dist/features/measure/measureLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measureLayer.js","names":[],"sources":["../../../src/features/measure/measureLayer.ts"],"sourcesContent":["import type { RenderLayer } from 'core/layers/render';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { LayerHit } from 'affordances/types';\nimport type { Scene } from 'core/scene/types';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport { viewToTransform } from 'core/viewport/view';\nimport { rectPath } from '@weasel-js/geom';\nimport { OVERLAY_ROLE_STROKES } from 'canvas/overlayRoleStrokes';\nimport { measureCommands } from 'canvas/nodeShapes/measurePainter';\nimport { measureEndsOf, type MeasurePoint } from './measurement';\nimport type { Measurements } from './measurements';\nimport { measureAt, type MeasureHit } from './measureHit';\nimport { MEASURE_HIT_PX } from './measureGestures';\n\n/** The registered layer's id; a press it claims routes as `layer:<id>`. */\nexport const MEASURE_LAYER_ID = 'weasel-measure';\n/** The affordance kind a press on a measurement routes under. */\nexport const MEASURE_AFFORDANCE_KIND = `layer:${MEASURE_LAYER_ID}`;\n\nconst HANDLE_PX = 3.5;\n\ntype AnyScene = Scene<unknown, string, unknown>;\n\n/**\n * The measurements' interactive layer, under every tool: it draws the\n * measurement a measure drag is making and a handle on each end of the picked\n * one, and claims a press on a measurement so a click picks it and a drag\n * edits it rather than reaching the tool. Under the measure tool it claims\n * only the picked measurement's ends, so a drag from anywhere else measures.\n */\nexport function measurementsLayer(scene: AnyScene, ms: Measurements): RenderLayer<unknown> {\n  return {\n    id: MEASURE_LAYER_ID,\n    label: 'Measurements',\n    space: 'screen',\n    subscribe: (listener) => {\n      const offs = [ms.picked.subscribe(listener), ms.draft.subscribe(listener), ms.measuring.subscribe(listener)];\n      return () => { for (const off of offs) off(); };\n    },\n    draw: (_data, view) => {\n      const t = viewToTransform(view);\n      const toScreen = (p: MeasurePoint): MeasurePoint => {\n        const [x, y] = worldToScreen(p.x, p.y, t);\n        return { x, y };\n      };\n      const out: DrawCommand[] = [];\n      const draft = ms.draft.get();\n      if (draft) out.push(...measureCommands(toScreen(draft.start), toScreen(draft.end), 1));\n      const picked = ms.picked.get();\n      const ends = picked === null ? null : measureEndsOf(scene.get(picked));\n      if (ends && !scene.isHidden(picked!)) {\n        const stroke = { ...OVERLAY_ROLE_STROKES['measure'], width: 1 };\n        for (const p of [ends.start, ends.end].map(toScreen)) {\n          out.push({\n            kind: 'path',\n            path: rectPath(p.x - HANDLE_PX, p.y - HANDLE_PX, HANDLE_PX * 2, HANDLE_PX * 2),\n            fill: { paint: { color: '#ffffff' } },\n            stroke,\n          });\n        }\n      }\n      return out;\n    },\n    hitTest: (wx, wy, _data, view): LayerHit<MeasureHit> | null => {\n      const hit = measureAt(scene, ms, { x: wx, y: wy }, MEASURE_HIT_PX / (view.scale.x || 1));\n      if (!hit) return null;\n      const onPickedEnd = hit.part !== 'line' && hit.id === ms.picked.get();\n      if (ms.measuring.get() && !onPickedEnd) return null;\n      return {\n        initialScratch: hit,\n        strength: 'exclusive',\n        claimedKinds: ['pointer'],\n        cursor: onPickedEnd ? 'crosshair' : 'move',\n      };\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;AAeA,IAAa,mBAAmB;;AAEhC,IAAa,0BAA0B,SAAS;AAEhD,IAAM,YAAY;;;;;;;;AAWlB,SAAgB,kBAAkB,OAAiB,IAAwC;CACzF,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,YAAY,aAAa;GACvB,MAAM,OAAO;IAAC,GAAG,OAAO,UAAU,QAAQ;IAAG,GAAG,MAAM,UAAU,QAAQ;IAAG,GAAG,UAAU,UAAU,QAAQ;GAAC;GAC3G,aAAa;IAAE,KAAK,MAAM,OAAO,MAAM,IAAI;GAAG;EAChD;EACA,OAAO,OAAO,SAAS;GACrB,MAAM,IAAI,gBAAgB,IAAI;GAC9B,MAAM,YAAY,MAAkC;IAClD,MAAM,CAAC,GAAG,KAAK,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC;IACxC,OAAO;KAAE;KAAG;IAAE;GAChB;GACA,MAAM,MAAqB,CAAC;GAC5B,MAAM,QAAQ,GAAG,MAAM,IAAI;GAC3B,IAAI,OAAO,IAAI,KAAK,GAAG,gBAAgB,SAAS,MAAM,KAAK,GAAG,SAAS,MAAM,GAAG,GAAG,CAAC,CAAC;GACrF,MAAM,SAAS,GAAG,OAAO,IAAI;GAC7B,MAAM,OAAO,WAAW,OAAO,OAAO,cAAc,MAAM,IAAI,MAAM,CAAC;GACrE,IAAI,QAAQ,CAAC,MAAM,SAAS,MAAO,GAAG;IACpC,MAAM,SAAS;KAAE,GAAG,qBAAqB;KAAY,OAAO;IAAE;IAC9D,KAAK,MAAM,KAAK,CAAC,KAAK,OAAO,KAAK,GAAG,CAAC,CAAC,IAAI,QAAQ,GACjD,IAAI,KAAK;KACP,MAAM;KACN,MAAM,SAAS,EAAE,IAAI,WAAW,EAAE,IAAI,WAAW,YAAY,GAAG,YAAY,CAAC;KAC7E,MAAM,EAAE,OAAO,EAAE,OAAO,UAAU,EAAE;KACpC;IACF,CAAC;GAEL;GACA,OAAO;EACT;EACA,UAAU,IAAI,IAAI,OAAO,SAAsC;GAC7D,MAAM,MAAM,UAAU,OAAO,IAAI;IAAE,GAAG;IAAI,GAAG;GAAG,GAAG,kBAAkB,KAAK,MAAM,KAAK,EAAE;GACvF,IAAI,CAAC,KAAK,OAAO;GACjB,MAAM,cAAc,IAAI,SAAS,UAAU,IAAI,OAAO,GAAG,OAAO,IAAI;GACpE,IAAI,GAAG,UAAU,IAAI,KAAK,CAAC,aAAa,OAAO;GAC/C,OAAO;IACL,gBAAgB;IAChB,UAAU;IACV,cAAc,CAAC,SAAS;IACxB,QAAQ,cAAc,cAAc;GACtC;EACF;CACF;AACF"}

package/dist/features/measure/measurement.js

@@ -0,0 +1,79 @@
+//#region src/features/measure/measurement.ts
+/** Measure from `start` to `end`. */
+function measureBetween(start, end) {
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	return {
+		start: {
+			x: start.x,
+			y: start.y
+		},
+		end: {
+			x: end.x,
+			y: end.y
+		},
+		dx,
+		dy,
+		distance: Math.hypot(dx, dy),
+		angle: dx === 0 && dy === 0 ? 0 : Math.atan2(-dy || 0, dx)
+	};
+}
+/** The ends `node` measures between, or null when it is not a measurement. */
+function measureEndsOf(node) {
+	const m = (node?.data)?.measure;
+	if (!m || typeof m !== "object" || !m.start || !m.end) return null;
+	return m;
+}
+/** The measurement `node` holds, or null when it is not one. */
+function measurementOf(node) {
+	const ends = measureEndsOf(node);
+	return ends ? measureBetween(ends.start, ends.end) : null;
+}
+/** The box a measurement's pose holds: its two ends' bounds, which is what
+*  culling, area queries, and fitting the view read. */
+function measurePose(start, end) {
+	return {
+		x: Math.min(start.x, end.x),
+		y: Math.min(start.y, end.y),
+		width: Math.abs(end.x - start.x),
+		height: Math.abs(end.y - start.y)
+	};
+}
+/** A measurement node on `layer`, ready to insert. */
+function measureNode(id, layer, start, end) {
+	const data = { measure: {
+		start: { ...start },
+		end: { ...end }
+	} };
+	return {
+		id,
+		kind: "leaf",
+		layer,
+		parent: null,
+		pose: measurePose(start, end),
+		data
+	};
+}
+/** `node`'s data and pose with its `which` end moved to `to`. */
+function withMeasureEnd(node, which, to) {
+	const ends = measureEndsOf(node);
+	if (!ends) return null;
+	const next = {
+		...ends,
+		[which]: {
+			x: to.x,
+			y: to.y
+		}
+	};
+	return {
+		data: {
+			...node.data,
+			measure: next
+		},
+		pose: measurePose(next.start, next.end)
+	};
+}
+
+//#endregion
+export { measureBetween, measureEndsOf, measureNode, measurePose, measurementOf, withMeasureEnd };
+//# sourceMappingURL=measurement.js.map

package/dist/features/measure/measurement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.js","names":[],"sources":["../../../src/features/measure/measurement.ts"],"sourcesContent":["import type { Node, NodeId, RectPose } from 'core/scene/types';\n\n/** A world-space point. */\nexport interface MeasurePoint { x: number; y: number }\n\n/**\n * The offset from `start` to `end`, in world units. `dx` and `dy` are on the\n * world's own axes, where y grows downward; `angle` reads like a protractor\n * instead, counterclockwise-positive on screen, so a line rising up and to\n * the right at 30° reads +30°. The canvas's own rotations are\n * clockwise-positive: a rotate that follows the line turns by `-angle`.\n */\nexport interface Measurement {\n  readonly start: MeasurePoint;\n  readonly end: MeasurePoint;\n  readonly dx: number;\n  readonly dy: number;\n  readonly distance: number;\n  /** `atan2(-dy, dx)`, in `(-π, π]`. Zero for a zero-length measurement. */\n  readonly angle: number;\n}\n\n/** Measure from `start` to `end`. */\nexport function measureBetween(start: MeasurePoint, end: MeasurePoint): Measurement {\n  const dx = end.x - start.x;\n  const dy = end.y - start.y;\n  return {\n    start: { x: start.x, y: start.y },\n    end: { x: end.x, y: end.y },\n    dx,\n    dy,\n    distance: Math.hypot(dx, dy),\n    // `|| 0` drops the sign of a negated zero, which would read a leftward line as -π.\n    angle: dx === 0 && dy === 0 ? 0 : Math.atan2(-dy || 0, dx),\n  };\n}\n\n/** What a measurement node keeps in `data`: its two ends, in world units. A\n *  `label` beside it names the node in a layer list. */\nexport interface MeasureData {\n  measure: { start: MeasurePoint; end: MeasurePoint };\n  label?: string;\n}\n\n/** Which end of a measurement. */\nexport type MeasureEnd = 'start' | 'end';\n\n\n/** The ends `node` measures between, or null when it is not a measurement. */\nexport function measureEndsOf(node: Pick<Node<unknown, string, unknown>, 'data'> | undefined): MeasureData['measure'] | null {\n  const m = (node?.data as Partial<MeasureData> | null | undefined)?.measure;\n  if (!m || typeof m !== 'object' || !m.start || !m.end) return null;\n  return m;\n}\n\n/** The measurement `node` holds, or null when it is not one. */\nexport function measurementOf(node: Pick<Node<unknown, string, unknown>, 'data'> | undefined): Measurement | null {\n  const ends = measureEndsOf(node);\n  return ends ? measureBetween(ends.start, ends.end) : null;\n}\n\n/** The box a measurement's pose holds: its two ends' bounds, which is what\n *  culling, area queries, and fitting the view read. */\nexport function measurePose(start: MeasurePoint, end: MeasurePoint): RectPose {\n  return {\n    x: Math.min(start.x, end.x),\n    y: Math.min(start.y, end.y),\n    width: Math.abs(end.x - start.x),\n    height: Math.abs(end.y - start.y),\n  };\n}\n\n/** A measurement node on `layer`, ready to insert. */\nexport function measureNode(id: NodeId, layer: string, start: MeasurePoint, end: MeasurePoint): Node<unknown, string, unknown> {\n  const data: MeasureData = { measure: { start: { ...start }, end: { ...end } } };\n  return { id, kind: 'leaf', layer, parent: null, pose: measurePose(start, end), data };\n}\n\n/** `node`'s data and pose with its `which` end moved to `to`. */\nexport function withMeasureEnd(\n  node: Node<unknown, string, unknown>,\n  which: MeasureEnd,\n  to: MeasurePoint,\n): { data: MeasureData; pose: RectPose } | null {\n  const ends = measureEndsOf(node);\n  if (!ends) return null;\n  const next = { ...ends, [which]: { x: to.x, y: to.y } };\n  const data: MeasureData = { ...(node.data as MeasureData), measure: next };\n  return { data, pose: measurePose(next.start, next.end) };\n}\n"],"mappings":";;AAuBA,SAAgB,eAAe,OAAqB,KAAgC;CAClF,MAAM,KAAK,IAAI,IAAI,MAAM;CACzB,MAAM,KAAK,IAAI,IAAI,MAAM;CACzB,OAAO;EACL,OAAO;GAAE,GAAG,MAAM;GAAG,GAAG,MAAM;EAAE;EAChC,KAAK;GAAE,GAAG,IAAI;GAAG,GAAG,IAAI;EAAE;EAC1B;EACA;EACA,UAAU,KAAK,MAAM,IAAI,EAAE;EAE3B,OAAO,OAAO,KAAK,OAAO,IAAI,IAAI,KAAK,MAAM,CAAC,MAAM,GAAG,EAAE;CAC3D;AACF;;AAcA,SAAgB,cAAc,MAA+F;CAC3H,MAAM,KAAK,MAAM,KAAA,EAAkD;CACnE,IAAI,CAAC,KAAK,OAAO,MAAM,YAAY,CAAC,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO;CAC9D,OAAO;AACT;;AAGA,SAAgB,cAAc,MAAoF;CAChH,MAAM,OAAO,cAAc,IAAI;CAC/B,OAAO,OAAO,eAAe,KAAK,OAAO,KAAK,GAAG,IAAI;AACvD;;;AAIA,SAAgB,YAAY,OAAqB,KAA6B;CAC5E,OAAO;EACL,GAAG,KAAK,IAAI,MAAM,GAAG,IAAI,CAAC;EAC1B,GAAG,KAAK,IAAI,MAAM,GAAG,IAAI,CAAC;EAC1B,OAAO,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC;EAC/B,QAAQ,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC;CAClC;AACF;;AAGA,SAAgB,YAAY,IAAY,OAAe,OAAqB,KAAmD;CAC7H,MAAM,OAAoB,EAAE,SAAS;EAAE,OAAO,EAAE,GAAG,MAAM;EAAG,KAAK,EAAE,GAAG,IAAI;CAAE,EAAE;CAC9E,OAAO;EAAE;EAAI,MAAM;EAAQ;EAAO,QAAQ;EAAM,MAAM,YAAY,OAAO,GAAG;EAAG;CAAK;AACtF;;AAGA,SAAgB,eACd,MACA,OACA,IAC8C;CAC9C,MAAM,OAAO,cAAc,IAAI;CAC/B,IAAI,CAAC,MAAM,OAAO;CAClB,MAAM,OAAO;EAAE,GAAG;GAAO,QAAQ;GAAE,GAAG,GAAG;GAAG,GAAG,GAAG;EAAE;CAAE;CAEtD,OAAO;EAAE;GADmB,GAAI,KAAK;GAAsB,SAAS;EAC3D;EAAM,MAAM,YAAY,KAAK,OAAO,KAAK,GAAG;CAAE;AACzD"}

package/dist/features/measure/measurements.js

@@ -0,0 +1,41 @@
+import { measurementOf } from "./measurement.js";
+import { createEmitter } from "@weasel-js/registry";
+
+//#region src/features/measure/measurements.ts
+function cell(initial) {
+	let value = initial;
+	const changed = createEmitter();
+	return {
+		get: () => value,
+		set: (next) => {
+			if (Object.is(next, value)) return;
+			value = next;
+			changed.emit();
+		},
+		subscribe: changed.subscribe
+	};
+}
+/** The measurements on `layer`, none picked and none in progress. */
+function createMeasurements(options) {
+	return {
+		layer: options.layer,
+		picked: cell(null),
+		draft: cell(null),
+		measuring: cell(false)
+	};
+}
+/** The measurement nodes on `ms.layer`, oldest first. */
+function measureIds(scene, ms) {
+	return scene.renderOrderNodes().filter((n) => n.layer === ms.layer && measurementOf(n) !== null).map((n) => n.id);
+}
+/** The measurement commands act on: the picked one while it is still in the
+*  scene, else the newest. */
+function currentMeasureId(scene, ms) {
+	const picked = ms.picked.get();
+	if (picked !== null && measurementOf(scene.get(picked)) !== null) return picked;
+	return measureIds(scene, ms).at(-1) ?? null;
+}
+
+//#endregion
+export { createMeasurements, currentMeasureId, measureIds };
+//# sourceMappingURL=measurements.js.map

package/dist/features/measure/measurements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurements.js","names":[],"sources":["../../../src/features/measure/measurements.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { measurementOf, type Measurement } from './measurement';\n\n/** One value, readable and watchable — what a readout re-renders from. */\nexport interface MeasureCell<T> {\n  get(): T;\n  set(next: T): void;\n  subscribe(listener: () => void): () => void;\n}\n\nfunction cell<T>(initial: T): MeasureCell<T> {\n  let value = initial;\n  const changed = createEmitter();\n  return {\n    get: () => value,\n    set: (next) => {\n      if (Object.is(next, value)) return;\n      value = next;\n      changed.emit();\n    },\n    subscribe: changed.subscribe,\n  };\n}\n\n/**\n * Where a scene's measurements go, and the state around them that is not\n * the document's: which one is picked, and the one a measure drag is still\n * drawing. The measurements themselves are nodes on `layer`, an annotation\n * layer (`isAnnotationLayer`), so they save with the scene, undo with it,\n * and stay out of export and content picking.\n *\n * The pick sits beside the content selection rather than in it: picking a\n * measurement leaves the selection alone, so Move by can carry the selection\n * by the picked measurement.\n */\nexport interface Measurements {\n  /** The annotation layer new measurements are added to. */\n  readonly layer: string;\n  /** The picked measurement's id. */\n  readonly picked: MeasureCell<NodeId | null>;\n  /** The measurement a measure drag is drawing, before it is added. */\n  readonly draft: MeasureCell<Measurement | null>;\n  /** Whether the measure tool is active, which changes what a press on a\n   *  measurement does: under it, only the picked one's ends take a drag, so a\n   *  drag from anywhere else starts a new measurement. */\n  readonly measuring: MeasureCell<boolean>;\n}\n\n/** The measurements on `layer`, none picked and none in progress. */\nexport function createMeasurements(options: { layer: string }): Measurements {\n  return {\n    layer: options.layer,\n    picked: cell<NodeId | null>(null),\n    draft: cell<Measurement | null>(null),\n    measuring: cell(false),\n  };\n}\n\n\n/** The measurement nodes on `ms.layer`, oldest first. */\nexport function measureIds(scene: Pick<Scene<unknown, string, unknown>, 'renderOrderNodes'>, ms: Pick<Measurements, 'layer'>): NodeId[] {\n  return scene.renderOrderNodes()\n    .filter((n) => n.layer === ms.layer && measurementOf(n) !== null)\n    .map((n) => n.id);\n}\n\n/** The measurement commands act on: the picked one while it is still in the\n *  scene, else the newest. */\nexport function currentMeasureId(\n  scene: Pick<Scene<unknown, string, unknown>, 'renderOrderNodes' | 'get'>,\n  ms: Pick<Measurements, 'layer' | 'picked'>,\n): NodeId | null {\n  const picked = ms.picked.get();\n  if (picked !== null && measurementOf(scene.get(picked)) !== null) return picked;\n  return measureIds(scene, ms).at(-1) ?? null;\n}\n"],"mappings":";;;;AAWA,SAAS,KAAQ,SAA4B;CAC3C,IAAI,QAAQ;CACZ,MAAM,UAAU,cAAc;CAC9B,OAAO;EACL,WAAW;EACX,MAAM,SAAS;GACb,IAAI,OAAO,GAAG,MAAM,KAAK,GAAG;GAC5B,QAAQ;GACR,QAAQ,KAAK;EACf;EACA,WAAW,QAAQ;CACrB;AACF;;AA2BA,SAAgB,mBAAmB,SAA0C;CAC3E,OAAO;EACL,OAAO,QAAQ;EACf,QAAQ,KAAoB,IAAI;EAChC,OAAO,KAAyB,IAAI;EACpC,WAAW,KAAK,KAAK;CACvB;AACF;;AAIA,SAAgB,WAAW,OAAkE,IAA2C;CACtI,OAAO,MAAM,iBAAiB,CAAC,CAC5B,QAAQ,MAAM,EAAE,UAAU,GAAG,SAAS,cAAc,CAAC,MAAM,IAAI,CAAC,CAChE,KAAK,MAAM,EAAE,EAAE;AACpB;;;AAIA,SAAgB,iBACd,OACA,IACe;CACf,MAAM,SAAS,GAAG,OAAO,IAAI;CAC7B,IAAI,WAAW,QAAQ,cAAc,MAAM,IAAI,MAAM,CAAC,MAAM,MAAM,OAAO;CACzE,OAAO,WAAW,OAAO,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK;AACzC"}