@weasel-js/core 1.11.1 → 1.12.0

package/dist/features/viewports/aim.js

@@ -0,0 +1,105 @@
+import { ZOOM_FLOOR } from "../../core/viewport/zoomBounds.js";
+import { normalizeView } from "../../core/viewport/view.js";
+import { fitViewToBounds } from "../../core/viewport/fitViewToBounds.js";
+
+//#region src/features/viewports/aim.ts
+/** The aim of view `viewId` (`null`: a surface's root) showing world rect `rect`. */
+function rectAim(viewId, rect) {
+	return {
+		viewId,
+		kind: "rect",
+		extent: rect,
+		outlineIn(space) {
+			const { x, y, width, height } = rect;
+			const out = [];
+			for (const corner of [
+				{
+					x,
+					y
+				},
+				{
+					x: x + width,
+					y
+				},
+				{
+					x: x + width,
+					y: y + height
+				},
+				{
+					x,
+					y: y + height
+				}
+			]) {
+				const p = space.project(corner);
+				if (!p) return null;
+				out.push(p);
+			}
+			return out;
+		},
+		pannedIn(space, from, to) {
+			const a = space.unproject(from);
+			const b = space.unproject(to);
+			if (!a || !b) return null;
+			return rectAim(viewId, {
+				...rect,
+				x: rect.x + (b.x - a.x),
+				y: rect.y + (b.y - a.y)
+			});
+		}
+	};
+}
+/** Whether `aim` is core's 2D rect aim, so its `extent` is a world rect. */
+function isRectAim(aim) {
+	return aim.kind === "rect";
+}
+/** A 2D view's frame: `view` is its camera and `size` its frame; frame px are measured from the frame's top-left. */
+function aimSpace2d(viewId, view, size) {
+	return {
+		viewId,
+		kind: "2d",
+		size: {
+			width: size.width,
+			height: size.height
+		},
+		project: (p) => ({
+			x: (p.x - view.x) * view.scale.x,
+			y: (p.y - view.y) * view.scale.y
+		}),
+		unproject: (px) => ({
+			x: px.x / view.scale.x + view.x,
+			y: px.y / view.scale.y + view.y
+		})
+	};
+}
+var UNUSED_CURRENT = {
+	x: 0,
+	y: 0,
+	scale: {
+		x: 1,
+		y: 1
+	}
+};
+/**
+* The camera that shows `rect` in a frame of `size`: `'exact'` per axis (the inverse of `viewportWorldRect`),
+* `'contain'` uniform and centered. Not clamped to a zoom range, and finite for an empty rect or frame. Normalized.
+*/
+function viewForAim(rect, size, fit) {
+	if (!(rect.width > 0 && rect.height > 0 && size.width > 0 && size.height > 0)) return normalizeView({
+		x: rect.x,
+		y: rect.y,
+		scale: {
+			x: ZOOM_FLOOR,
+			y: ZOOM_FLOOR
+		}
+	});
+	return normalizeView(fitViewToBounds(rect, size, UNUSED_CURRENT, {
+		mode: fit === "exact" ? "stretch" : "contain",
+		padding: 0,
+		minScale: 0,
+		maxScale: Infinity
+	}));
+}
+
+//#endregion
+export { aimSpace2d, isRectAim, rectAim, viewForAim };
+//# sourceMappingURL=aim.js.map

package/dist/features/viewports/aim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aim.js","names":[],"sources":["../../../src/features/viewports/aim.ts"],"sourcesContent":["import { fitViewToBounds, type Bounds } from 'core/viewport/fitViewToBounds';\nimport type { Dims } from 'core/layers/render';\nimport { normalizeView, type View } from 'core/viewport/view';\nimport { ZOOM_FLOOR } from 'core/viewport/zoomBounds';\n\n/** A point in a view's world. A 2D world is the plane z = 0, so `z` is absent there. */\nexport interface AimPoint {\n  x: number;\n  y: number;\n  z?: number;\n}\n\n/** A closed outline in a frame's CSS px, from the frame's top-left; at least 3 points. */\nexport type AimOutline = readonly { x: number; y: number }[];\n\n/** A target view, as an aim is drawn into it: its world, and its frame. */\nexport interface AimSpace {\n  /** The view whose frame this is; `null` for a surface's root view. */\n  readonly viewId: string | null;\n  /** `'2d'` for core's views; any other value is its owner's (kernel3d: `'3d'`). */\n  readonly kind: string;\n  readonly size: { width: number; height: number };\n  /** World point to frame px; `null` where the point does not draw (behind a 3D camera). */\n  project(p: AimPoint): { x: number; y: number } | null;\n  /** Frame px to the world point under it; `null` where there is none (a 3D ray missing its plane). */\n  unproject(px: { x: number; y: number }): AimPoint | null;\n}\n\n/** What a viewport shows, read in the world of the view it names. */\nexport interface ViewAim<TExtent = unknown> {\n  readonly viewId: string | null;\n  /** Discriminates `extent`: `'rect'` for core's 2D views. */\n  readonly kind: string;\n  /** Where the aim lies in its world, in its owner's own terms. */\n  readonly extent: TExtent;\n  /** The aim's outline in `space`'s frame, or `null` when it cannot be drawn there. */\n  outlineIn(space: AimSpace): AimOutline | null;\n  /** This aim moved so the world point under frame px `from` in `space` ends up under `to`; `null` when either misses. */\n  pannedIn(space: AimSpace, from: { x: number; y: number }, to: { x: number; y: number }): ViewAim<TExtent> | null;\n}\n\n/** Core's 2D aim: a world rect a view shows. */\nexport type RectAim = ViewAim<Bounds> & { readonly kind: 'rect' };\n\n/** The aim of view `viewId` (`null`: a surface's root) showing world rect `rect`. */\nexport function rectAim(viewId: string | null, rect: Bounds): RectAim {\n  return {\n    viewId,\n    kind: 'rect',\n    extent: rect,\n    outlineIn(space) {\n      const { x, y, width, height } = rect;\n      const out: { x: number; y: number }[] = [];\n      for (const corner of [\n        { x, y },\n        { x: x + width, y },\n        { x: x + width, y: y + height },\n        { x, y: y + height },\n      ]) {\n        const p = space.project(corner);\n        if (!p) return null;\n        out.push(p);\n      }\n      return out;\n    },\n    pannedIn(space, from, to) {\n      const a = space.unproject(from);\n      const b = space.unproject(to);\n      if (!a || !b) return null;\n      return rectAim(viewId, { ...rect, x: rect.x + (b.x - a.x), y: rect.y + (b.y - a.y) });\n    },\n  };\n}\n\n/** Whether `aim` is core's 2D rect aim, so its `extent` is a world rect. */\nexport function isRectAim(aim: ViewAim): aim is RectAim {\n  return aim.kind === 'rect';\n}\n\n/** A 2D view's frame: `view` is its camera and `size` its frame; frame px are measured from the frame's top-left. */\nexport function aimSpace2d(viewId: string | null, view: View, size: Dims): AimSpace {\n  return {\n    viewId,\n    kind: '2d',\n    size: { width: size.width, height: size.height },\n    project: (p) => ({ x: (p.x - view.x) * view.scale.x, y: (p.y - view.y) * view.scale.y }),\n    unproject: (px) => ({ x: px.x / view.scale.x + view.x, y: px.y / view.scale.y + view.y }),\n  };\n}\n\nconst UNUSED_CURRENT: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/**\n * The camera that shows `rect` in a frame of `size`: `'exact'` per axis (the inverse of `viewportWorldRect`),\n * `'contain'` uniform and centered. Not clamped to a zoom range, and finite for an empty rect or frame. Normalized.\n */\nexport function viewForAim(rect: Bounds, size: Dims, fit: 'exact' | 'contain'): View {\n  if (!(rect.width > 0 && rect.height > 0 && size.width > 0 && size.height > 0)) {\n    return normalizeView({ x: rect.x, y: rect.y, scale: { x: ZOOM_FLOOR, y: ZOOM_FLOOR } });\n  }\n  return normalizeView(fitViewToBounds(rect, size, UNUSED_CURRENT, {\n    mode: fit === 'exact' ? 'stretch' : 'contain', padding: 0, minScale: 0, maxScale: Infinity,\n  }));\n}\n"],"mappings":";;;;;;AA6CA,SAAgB,QAAQ,QAAuB,MAAuB;CACpE,OAAO;EACL;EACA,MAAM;EACN,QAAQ;EACR,UAAU,OAAO;GACf,MAAM,EAAE,GAAG,GAAG,OAAO,WAAW;GAChC,MAAM,MAAkC,CAAC;GACzC,KAAK,MAAM,UAAU;IACnB;KAAE;KAAG;IAAE;IACP;KAAE,GAAG,IAAI;KAAO;IAAE;IAClB;KAAE,GAAG,IAAI;KAAO,GAAG,IAAI;IAAO;IAC9B;KAAE;KAAG,GAAG,IAAI;IAAO;GACrB,GAAG;IACD,MAAM,IAAI,MAAM,QAAQ,MAAM;IAC9B,IAAI,CAAC,GAAG,OAAO;IACf,IAAI,KAAK,CAAC;GACZ;GACA,OAAO;EACT;EACA,SAAS,OAAO,MAAM,IAAI;GACxB,MAAM,IAAI,MAAM,UAAU,IAAI;GAC9B,MAAM,IAAI,MAAM,UAAU,EAAE;GAC5B,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO;GACrB,OAAO,QAAQ,QAAQ;IAAE,GAAG;IAAM,GAAG,KAAK,KAAK,EAAE,IAAI,EAAE;IAAI,GAAG,KAAK,KAAK,EAAE,IAAI,EAAE;GAAG,CAAC;EACtF;CACF;AACF;;AAGA,SAAgB,UAAU,KAA8B;CACtD,OAAO,IAAI,SAAS;AACtB;;AAGA,SAAgB,WAAW,QAAuB,MAAY,MAAsB;CAClF,OAAO;EACL;EACA,MAAM;EACN,MAAM;GAAE,OAAO,KAAK;GAAO,QAAQ,KAAK;EAAO;EAC/C,UAAU,OAAO;GAAE,IAAI,EAAE,IAAI,KAAK,KAAK,KAAK,MAAM;GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,KAAK,MAAM;EAAE;EACtF,YAAY,QAAQ;GAAE,GAAG,GAAG,IAAI,KAAK,MAAM,IAAI,KAAK;GAAG,GAAG,GAAG,IAAI,KAAK,MAAM,IAAI,KAAK;EAAE;CACzF;AACF;AAEA,IAAM,iBAAuB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE;;;;;AAMjE,SAAgB,WAAW,MAAc,MAAY,KAAgC;CACnF,IAAI,EAAE,KAAK,QAAQ,KAAK,KAAK,SAAS,KAAK,KAAK,QAAQ,KAAK,KAAK,SAAS,IACzE,OAAO,cAAc;EAAE,GAAG,KAAK;EAAG,GAAG,KAAK;EAAG,OAAO;GAAE,GAAG;GAAY,GAAG;EAAW;CAAE,CAAC;CAExF,OAAO,cAAc,gBAAgB,MAAM,MAAM,gBAAgB;EAC/D,MAAM,QAAQ,UAAU,YAAY;EAAW,SAAS;EAAG,UAAU;EAAG,UAAU;CACpF,CAAC,CAAC;AACJ"}

package/dist/features/viewports/viewMarker.js

@@ -0,0 +1,82 @@
+import { aimSpace2d } from "./aim.js";
+import { pointInPolygon, pointSegmentDist2, polygonFromPoints } from "@weasel-js/geom";
+
+//#region src/features/viewports/viewMarker.ts
+/** The marker style a {@link ViewMarkerProps.style} fills in from: the minimap indicator's. */
+var VIEW_MARKER_DEFAULT_STYLE = {
+	stroke: "#ffffff",
+	width: 1,
+	dash: [2, 3]
+};
+/** The aim `source` names: a view's through `host`, or one handed in by value. */
+function markerSourceAim(source, host) {
+	return source === null || typeof source === "string" ? host.aimOf(source) : source.aim();
+}
+/** A screen-space layer, id `view-marker:<id>`, drawing `props`'s source aim in the frame it is handed. */
+function createViewMarkerLayer(props, host) {
+	const { id } = props();
+	return {
+		id: `view-marker:${id}`,
+		label: `View marker ${id}`,
+		space: "screen",
+		draw: (_data, view, dims) => {
+			const { source, target, style } = props();
+			if (source === target) return [];
+			const outline = markerSourceAim(source, host)?.outlineIn(aimSpace2d(target, view, dims));
+			if (!outline) return [];
+			const d = VIEW_MARKER_DEFAULT_STYLE;
+			return [{
+				kind: "path",
+				path: polygonFromPoints(outline),
+				stroke: {
+					paint: {
+						kind: "solid",
+						color: style?.stroke ?? d.stroke
+					},
+					width: style?.width ?? d.width,
+					dash: [...style?.dash ?? d.dash]
+				}
+			}];
+		}
+	};
+}
+/** A press this many screen px outside the outline still counts. */
+var VIEW_MARKER_HIT_SLOP_PX = 4;
+/**
+* The grab for a press at frame px `at` in `space`, the marker's target, or
+* `null` when the marker is not interactive, its source has no writer or no
+* aim, or `at` is not on its outline or within {@link VIEW_MARKER_HIT_SLOP_PX} of it. A surface with views
+* calls this itself; a canvas with none, such as a detached minimap, calls it to route a press to its marker.
+*/
+function grabViewMarker(props, host, space, at) {
+	const { id, source, target, interactive } = props;
+	if (interactive === false || source === target) return null;
+	const write = source === null || typeof source === "string" ? (aim) => {
+		host.setAim(source, aim);
+	} : source.setAim?.bind(source);
+	if (!write) return null;
+	const startAim = markerSourceAim(source, host);
+	const outline = startAim?.outlineIn(space);
+	if (!startAim || !outline || !outlineHolds(outline, at, VIEW_MARKER_HIT_SLOP_PX)) return null;
+	return {
+		markerId: id,
+		moveTo: (world) => {
+			const to = space.project(world);
+			const next = to && startAim.pannedIn(space, at, to);
+			if (next) write(next);
+		}
+	};
+}
+function outlineHolds(outline, p, slop) {
+	if (pointInPolygon(outline.flatMap((q) => [q.x, q.y]), p.x, p.y)) return true;
+	for (let i = 0; i < outline.length; i++) {
+		const a = outline[i];
+		const b = outline[(i + 1) % outline.length];
+		if (pointSegmentDist2(p.x, p.y, a.x, a.y, b.x, b.y) <= slop * slop) return true;
+	}
+	return false;
+}
+
+//#endregion
+export { VIEW_MARKER_DEFAULT_STYLE, VIEW_MARKER_HIT_SLOP_PX, createViewMarkerLayer, grabViewMarker, markerSourceAim };
+//# sourceMappingURL=viewMarker.js.map

package/dist/features/viewports/viewMarker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewMarker.js","names":[],"sources":["../../../src/features/viewports/viewMarker.ts"],"sourcesContent":["import { pointInPolygon, pointSegmentDist2, polygonFromPoints } from '@weasel-js/geom';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { aimSpace2d, type AimOutline, type AimSpace, type ViewAim } from './aim';\n\n/** An aim handed in by value (another surface's view, a 3D pane), with the writer that moves it. */\nexport interface AimSource {\n  aim(): ViewAim | null;\n  setAim?(aim: ViewAim): void;\n}\n\n/** How a marker's outline is stroked, in screen px. */\nexport interface ViewMarkerStyle {\n  stroke?: string;\n  width?: number;\n  dash?: readonly number[];\n}\n\n/** One view's aim, drawn inside another view's frame. */\nexport interface ViewMarkerProps {\n  /** Unique among the markers on one surface. */\n  id: string;\n  /** Whose aim: a view id on this surface, `null` for the root view, or an aim by value. */\n  source: string | null | AimSource;\n  /** Whose frame it is drawn in, after that view's layers: a view id, or `null` for the root. */\n  target: string | null;\n  /** Screen px. Default: stroke `#ffffff`, width 1, dash [2, 3]. */\n  style?: ViewMarkerStyle;\n  /** Default true: dragging the marker edits the source's aim. A source with no writer is never interactive.\n   *  A marker grabs its whole interior plus {@link VIEW_MARKER_HIT_SLOP_PX}, so one covering much of its\n   *  frame takes every press there; `false` opts out. */\n  interactive?: boolean;\n}\n\n/** The marker style a {@link ViewMarkerProps.style} fills in from: the minimap indicator's. */\nexport const VIEW_MARKER_DEFAULT_STYLE: Required<ViewMarkerStyle> = { stroke: '#ffffff', width: 1, dash: [2, 3] };\n\n/** What a marker resolves aims through: the surface's views. */\nexport interface ViewMarkerHost {\n  aimOf(id: string | null): ViewAim | null;\n  setAim(id: string | null, aim: ViewAim): boolean;\n}\n\n/** The aim `source` names: a view's through `host`, or one handed in by value. */\nexport function markerSourceAim(source: ViewMarkerProps['source'], host: ViewMarkerHost): ViewAim | null {\n  return source === null || typeof source === 'string' ? host.aimOf(source) : source.aim();\n}\n\n/** A screen-space layer, id `view-marker:<id>`, drawing `props`'s source aim in the frame it is handed. */\nexport function createViewMarkerLayer(props: () => ViewMarkerProps, host: ViewMarkerHost): RenderLayer<unknown> {\n  const { id } = props();\n  return {\n    id: `view-marker:${id}`,\n    label: `View marker ${id}`,\n    space: 'screen',\n    draw: (_data, view, dims): DrawCommand[] => {\n      const { source, target, style } = props();\n      if (source === target) return [];\n      const aim = markerSourceAim(source, host);\n      const outline = aim?.outlineIn(aimSpace2d(target, view, dims));\n      if (!outline) return [];\n      const d = VIEW_MARKER_DEFAULT_STYLE;\n      return [{\n        kind: 'path',\n        path: polygonFromPoints(outline),\n        stroke: {\n          paint: { kind: 'solid', color: style?.stroke ?? d.stroke },\n          width: style?.width ?? d.width,\n          dash: [...(style?.dash ?? d.dash)],\n        },\n      }];\n    },\n  };\n}\n\n/** A press on a marker, held for the drag: where it started, and the aim it started from. */\nexport interface ViewMarkerGrab {\n  readonly markerId: string;\n  /** Pan the source so the world point under the press ends up under `world`, a point in the target's world. */\n  moveTo(world: { x: number; y: number }): void;\n}\n\n/** A press this many screen px outside the outline still counts. */\nexport const VIEW_MARKER_HIT_SLOP_PX = 4;\n\n/**\n * The grab for a press at frame px `at` in `space`, the marker's target, or\n * `null` when the marker is not interactive, its source has no writer or no\n * aim, or `at` is not on its outline or within {@link VIEW_MARKER_HIT_SLOP_PX} of it. A surface with views\n * calls this itself; a canvas with none, such as a detached minimap, calls it to route a press to its marker.\n */\nexport function grabViewMarker(\n  props: ViewMarkerProps,\n  host: ViewMarkerHost,\n  space: AimSpace,\n  at: { x: number; y: number },\n): ViewMarkerGrab | null {\n  const { id, source, target, interactive } = props;\n  if (interactive === false || source === target) return null;\n  const write = source === null || typeof source === 'string'\n    ? (aim: ViewAim) => { host.setAim(source, aim); }\n    : source.setAim?.bind(source);\n  if (!write) return null;\n  const startAim = markerSourceAim(source, host);\n  const outline = startAim?.outlineIn(space);\n  if (!startAim || !outline || !outlineHolds(outline, at, VIEW_MARKER_HIT_SLOP_PX)) return null;\n  return {\n    markerId: id,\n    moveTo: (world) => {\n      const to = space.project(world);\n      const next = to && startAim.pannedIn(space, at, to);\n      if (next) write(next);\n    },\n  };\n}\n\nfunction outlineHolds(outline: AimOutline, p: { x: number; y: number }, slop: number): boolean {\n  if (pointInPolygon(outline.flatMap((q) => [q.x, q.y]), p.x, p.y)) return true;\n  for (let i = 0; i < outline.length; i++) {\n    const a = outline[i]!;\n    const b = outline[(i + 1) % outline.length]!;\n    if (pointSegmentDist2(p.x, p.y, a.x, a.y, b.x, b.y) <= slop * slop) return true;\n  }\n  return false;\n}\n"],"mappings":";;;;;AAmCA,IAAa,4BAAuD;CAAE,QAAQ;CAAW,OAAO;CAAG,MAAM,CAAC,GAAG,CAAC;AAAE;;AAShH,SAAgB,gBAAgB,QAAmC,MAAsC;CACvG,OAAO,WAAW,QAAQ,OAAO,WAAW,WAAW,KAAK,MAAM,MAAM,IAAI,OAAO,IAAI;AACzF;;AAGA,SAAgB,sBAAsB,OAA8B,MAA4C;CAC9G,MAAM,EAAE,OAAO,MAAM;CACrB,OAAO;EACL,IAAI,eAAe;EACnB,OAAO,eAAe;EACtB,OAAO;EACP,OAAO,OAAO,MAAM,SAAwB;GAC1C,MAAM,EAAE,QAAQ,QAAQ,UAAU,MAAM;GACxC,IAAI,WAAW,QAAQ,OAAO,CAAC;GAE/B,MAAM,UADM,gBAAgB,QAAQ,IACpB,CAAA,EAAK,UAAU,WAAW,QAAQ,MAAM,IAAI,CAAC;GAC7D,IAAI,CAAC,SAAS,OAAO,CAAC;GACtB,MAAM,IAAI;GACV,OAAO,CAAC;IACN,MAAM;IACN,MAAM,kBAAkB,OAAO;IAC/B,QAAQ;KACN,OAAO;MAAE,MAAM;MAAS,OAAO,OAAO,UAAU,EAAE;KAAO;KACzD,OAAO,OAAO,SAAS,EAAE;KACzB,MAAM,CAAC,GAAI,OAAO,QAAQ,EAAE,IAAK;IACnC;GACF,CAAC;EACH;CACF;AACF;;AAUA,IAAa,0BAA0B;;;;;;;AAQvC,SAAgB,eACd,OACA,MACA,OACA,IACuB;CACvB,MAAM,EAAE,IAAI,QAAQ,QAAQ,gBAAgB;CAC5C,IAAI,gBAAgB,SAAS,WAAW,QAAQ,OAAO;CACvD,MAAM,QAAQ,WAAW,QAAQ,OAAO,WAAW,YAC9C,QAAiB;EAAE,KAAK,OAAO,QAAQ,GAAG;CAAG,IAC9C,OAAO,QAAQ,KAAK,MAAM;CAC9B,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,WAAW,gBAAgB,QAAQ,IAAI;CAC7C,MAAM,UAAU,UAAU,UAAU,KAAK;CACzC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,aAAa,SAAS,IAAI,uBAAuB,GAAG,OAAO;CACzF,OAAO;EACL,UAAU;EACV,SAAS,UAAU;GACjB,MAAM,KAAK,MAAM,QAAQ,KAAK;GAC9B,MAAM,OAAO,MAAM,SAAS,SAAS,OAAO,IAAI,EAAE;GAClD,IAAI,MAAM,MAAM,IAAI;EACtB;CACF;AACF;AAEA,SAAS,aAAa,SAAqB,GAA6B,MAAuB;CAC7F,IAAI,eAAe,QAAQ,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO;CACzE,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,IAAI,QAAQ;EAClB,MAAM,IAAI,SAAS,IAAI,KAAK,QAAQ;EACpC,IAAI,kBAAkB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,MAAM,OAAO;CAC7E;CACA,OAAO;AACT"}

package/dist/features/viewports/viewMarkerDrag.js

@@ -0,0 +1,55 @@
+import { hitPredicate } from "@weasel-js/gestures";
+
+//#region src/features/viewports/viewMarkerDrag.ts
+/** The action id a drag on a view marker routes to. */
+var VIEW_MARKER_DRAG = "view.marker.drag";
+/** The id of the entry {@link createViewMarkerContribution} builds. */
+var VIEW_MARKER_ENTRY_ID = "view-marker";
+var MARKER_KIND_PREFIX = "layer:view-marker:";
+function grabIn(affordance) {
+	return affordance?.payload ?? null;
+}
+/** Drags the grabbed marker. There is nothing to commit, so a cancel ends where a release does. */
+function viewMarkerDragAction() {
+	return {
+		id: VIEW_MARKER_DRAG,
+		label: "View marker — drag",
+		invoker: {
+			timing: "ongoing",
+			start: (ctx) => {
+				const grab = grabIn(ctx.drag?.affordance);
+				if (!grab) return {};
+				return {
+					kind: VIEW_MARKER_DRAG,
+					onMove: (m) => {
+						grab.moveTo(m.drag?.current ?? m.world);
+					}
+				};
+			}
+		}
+	};
+}
+/**
+* The always-on entry (id `'view-marker'`) that binds a drag on any marker to {@link VIEW_MARKER_DRAG}.
+* A `<SceneCanvas>` installs it unless `actions={null}` or a `tools` takeover leaves it out; to turn marker
+* dragging back on there, pass it in `ambient`, or in the takeover's own `useTools` ambient list.
+*/
+function createViewMarkerContribution() {
+	return {
+		id: VIEW_MARKER_ENTRY_ID,
+		eligibility: { always: true },
+		actions: [viewMarkerDragAction()],
+		bindings: [{
+			spec: {
+				kind: "drag",
+				target: { kindOf: hitPredicate((hit) => hit?.kind?.startsWith(MARKER_KIND_PREFIX) ?? false) }
+			},
+			actionId: VIEW_MARKER_DRAG,
+			opts: { id: "view-marker.drag" }
+		}]
+	};
+}
+
+//#endregion
+export { VIEW_MARKER_DRAG, VIEW_MARKER_ENTRY_ID, createViewMarkerContribution, viewMarkerDragAction };
+//# sourceMappingURL=viewMarkerDrag.js.map

package/dist/features/viewports/viewMarkerDrag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewMarkerDrag.js","names":[],"sources":["../../../src/features/viewports/viewMarkerDrag.ts"],"sourcesContent":["import { hitPredicate } from '@weasel-js/gestures';\nimport type { Action, InvocationCtx } from '@weasel-js/routing';\nimport type { SurfaceContribution } from 'canvas/surfaceContribution';\nimport type { ViewMarkerGrab } from './viewMarker';\n\n/** The action id a drag on a view marker routes to. */\nexport const VIEW_MARKER_DRAG = 'view.marker.drag';\n\n/** The id of the entry {@link createViewMarkerContribution} builds. */\nexport const VIEW_MARKER_ENTRY_ID = 'view-marker';\n\nconst MARKER_KIND_PREFIX = 'layer:view-marker:';\n\nfunction grabIn(affordance: unknown): ViewMarkerGrab | null {\n  return (affordance as { payload?: ViewMarkerGrab } | null | undefined)?.payload ?? null;\n}\n\n/** Drags the grabbed marker. There is nothing to commit, so a cancel ends where a release does. */\nexport function viewMarkerDragAction(): Action {\n  return {\n    id: VIEW_MARKER_DRAG,\n    label: 'View marker — drag',\n    invoker: {\n      timing: 'ongoing',\n      start: (ctx: InvocationCtx) => {\n        const grab = grabIn(ctx.drag?.affordance);\n        if (!grab) return {};\n        return {\n          kind: VIEW_MARKER_DRAG,\n          onMove: (m: InvocationCtx) => { grab.moveTo(m.drag?.current ?? m.world); },\n        };\n      },\n    },\n  };\n}\n\n/**\n * The always-on entry (id `'view-marker'`) that binds a drag on any marker to {@link VIEW_MARKER_DRAG}.\n * A `<SceneCanvas>` installs it unless `actions={null}` or a `tools` takeover leaves it out; to turn marker\n * dragging back on there, pass it in `ambient`, or in the takeover's own `useTools` ambient list.\n */\nexport function createViewMarkerContribution(): SurfaceContribution {\n  return {\n    id: VIEW_MARKER_ENTRY_ID,\n    eligibility: { always: true },\n    actions: [viewMarkerDragAction()],\n    bindings: [{\n      spec: {\n        kind: 'drag',\n        target: { kindOf: hitPredicate((hit) => (hit as { kind?: string } | null | undefined)?.kind?.startsWith(MARKER_KIND_PREFIX) ?? false) },\n      },\n      actionId: VIEW_MARKER_DRAG,\n      opts: { id: 'view-marker.drag' },\n    }],\n  };\n}\n"],"mappings":";;;;AAMA,IAAa,mBAAmB;;AAGhC,IAAa,uBAAuB;AAEpC,IAAM,qBAAqB;AAE3B,SAAS,OAAO,YAA4C;CAC1D,OAAQ,YAAgE,WAAW;AACrF;;AAGA,SAAgB,uBAA+B;CAC7C,OAAO;EACL,IAAI;EACJ,OAAO;EACP,SAAS;GACP,QAAQ;GACR,QAAQ,QAAuB;IAC7B,MAAM,OAAO,OAAO,IAAI,MAAM,UAAU;IACxC,IAAI,CAAC,MAAM,OAAO,CAAC;IACnB,OAAO;KACL,MAAM;KACN,SAAS,MAAqB;MAAE,KAAK,OAAO,EAAE,MAAM,WAAW,EAAE,KAAK;KAAG;IAC3E;GACF;EACF;CACF;AACF;;;;;;AAOA,SAAgB,+BAAoD;CAClE,OAAO;EACL,IAAI;EACJ,aAAa,EAAE,QAAQ,KAAK;EAC5B,SAAS,CAAC,qBAAqB,CAAC;EAChC,UAAU,CAAC;GACT,MAAM;IACJ,MAAM;IACN,QAAQ,EAAE,QAAQ,cAAc,QAAS,KAA8C,MAAM,WAAW,kBAAkB,KAAK,KAAK,EAAE;GACxI;GACA,UAAU;GACV,MAAM,EAAE,IAAI,mBAAmB;EACjC,CAAC;CACH;AACF"}