@fundar/data-chart-telling 0.0.36 → 0.0.37

package/dist/index.d.ts

@@ -51,6 +51,7 @@ export type { MarkerProps } from './types/markers/props';
 export type { GeoFeature, GeoJsonInput, GeoDataProps, Topology } from './types/plots/data/geo';
 export type { ScatterDataProps } from './types/plots/data/scatter';
 export type { GeoProjectionName, GeoProjectionConfig, GeoCustomProjection, GeoCustomProjectionFactory, GeoScalesConfig, GeoZoomConfig, CoordinatesConfig } from './types/layout/coordinates';
+export type { GeoCameraTarget, GeoCameraConfig, GeoCameraTransition } from './types/plots/camera';
 export type { GeoMarkersConfig, GeoInsetMarkerConfig, GeoInsetTooltipConfig, GeoInsetLocation, GeoInsetProjectionName, GeoInsetProjectionConfig } from './types/markers/geo';
 export type { ChartPlotContext, ChartPlotSnippet } from './types/charts/common';
 export type { TimeValue, Orientation, TimelineConfig } from './types/layout/timeline';

package/dist/layout/coordinates/CameraFit.svelte

@@ -0,0 +1,111 @@
+<script lang="ts">
+	import { geoBounds, type GeoPermissibleObjects } from 'd3-geo';
+	import { usePlot } from 'svelteplot';
+	import {
+		toProjectionLike,
+		type StreamingProjection,
+		type ProjectionLike
+	} from '../../plots/utils/tiles';
+	import { parseInsetLocation } from '../../markers/inset/insetLayout';
+	import type { ResolvedGeoCameraTarget } from './resolveCameraTarget';
+	import type { GeoZoomTransform } from './zoom.svelte';
+	import type { GeoInsetLocation } from '../../types/markers/geo';
+
+	/**
+	 * Mounted inside `<Plot>` to reach `usePlot()` for the live fitted
+	 * projection (see `TileLayer` for the same pattern). Computes the pixel
+	 * `{x,y,k}` that fits/anchors `target` within `width`×`height`, reporting
+	 * it reactively via `onFit`.
+	 */
+	let {
+		target,
+		anchor,
+		padding = 24,
+		zoom = 1,
+		width,
+		height,
+		onFit
+	}: {
+		target: ResolvedGeoCameraTarget;
+		anchor?: GeoInsetLocation;
+		padding?: number;
+		zoom?: number;
+		width: number;
+		height: number;
+		onFit: (fit: GeoZoomTransform) => void;
+	} = $props();
+
+	const plot = usePlot();
+
+	// Runtime shape verified against svelteplot's own projection helper — see TileLayer.svelte.
+	const rawProjection = $derived(
+		plot.scales.projection as unknown as StreamingProjection | undefined
+	);
+	const projection = $derived(rawProjection ? toProjectionLike(rawProjection) : undefined);
+
+	/** A grid of lon/lat samples approximating `target`'s extent, antimeridian-safe. */
+	function sampleLonLat(t: ResolvedGeoCameraTarget): [number, number][] {
+		if (t.kind === 'point') return [[t.lon, t.lat]];
+		const [[w, s], [e, n]] = geoBounds(t.geometry as GeoPermissibleObjects);
+		const east = e < w ? e + 360 : e;
+		const lons = [w, (w + east) / 2, east].map((lon) => ((((lon + 180) % 360) + 360) % 360) - 180);
+		const lats = [s, (s + n) / 2, n];
+		const points: [number, number][] = [];
+		for (const lon of lons) for (const lat of lats) points.push([lon, lat]);
+		return points;
+	}
+
+	function project(proj: ProjectionLike, points: [number, number][]): [number, number][] {
+		const out: [number, number][] = [];
+		for (const p of points) {
+			const projected = proj(p);
+			if (projected) out.push(projected);
+		}
+		return out;
+	}
+
+	$effect(() => {
+		if (!projection) return;
+		const projected = project(projection, sampleLonLat(target));
+		if (!projected.length) return;
+
+		let minX = Infinity;
+		let maxX = -Infinity;
+		let minY = Infinity;
+		let maxY = -Infinity;
+		for (const [x, y] of projected) {
+			if (x < minX) minX = x;
+			if (x > maxX) maxX = x;
+			if (y < minY) minY = y;
+			if (y > maxY) maxY = y;
+		}
+		const bboxW = maxX - minX;
+		const bboxH = maxY - minY;
+
+		// No extent to fit for a plain point — `zoom` is used directly as the scale.
+		const availW = Math.max(1, width - padding * 2);
+		const availH = Math.max(1, height - padding * 2);
+		const fitScale =
+			bboxW > 0 && bboxH > 0
+				? Math.min(availW / bboxW, availH / bboxH)
+				: bboxW > 0
+					? availW / bboxW
+					: bboxH > 0
+						? availH / bboxH
+						: 1;
+		const k = fitScale * zoom;
+
+		const centerX = (minX + maxX) / 2;
+		const centerY = (minY + maxY) / 2;
+
+		const { h, v } = parseInsetLocation(anchor ?? 'middle-middle');
+		const halfW = (bboxW * k) / 2;
+		const halfH = (bboxH * k) / 2;
+		const targetX =
+			h === 'left' ? padding + halfW : h === 'right' ? width - padding - halfW : width / 2;
+		const targetY =
+			v === 'top' ? padding + halfH : v === 'bottom' ? height - padding - halfH : height / 2;
+
+		onFit({ x: targetX - centerX * k, y: targetY - centerY * k, k });
+	});
+</script>

package/dist/layout/coordinates/CameraFit.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedGeoCameraTarget } from './resolveCameraTarget';
+import type { GeoZoomTransform } from './zoom.svelte';
+import type { GeoInsetLocation } from '../../types/markers/geo';
+type $$ComponentProps = {
+    target: ResolvedGeoCameraTarget;
+    anchor?: GeoInsetLocation;
+    padding?: number;
+    zoom?: number;
+    width: number;
+    height: number;
+    onFit: (fit: GeoZoomTransform) => void;
+};
+declare const CameraFit: import("svelte").Component<$$ComponentProps, {}, "">;
+type CameraFit = ReturnType<typeof CameraFit>;
+export default CameraFit;

package/dist/layout/coordinates/CoordinatesLayout.svelte

@@ -1,100 +1,174 @@
 <script lang="ts" generics="TData extends Record<string, unknown>">
-  import type { ComponentProps, Snippet } from 'svelte';
-  import { Plot } from 'svelteplot';
-  import { resolveProjection } from './resolveProjection';
-  import { createGeoZoom } from './zoom.svelte';
-  import { createGeoRotate, type GeoRotate } from './rotate.svelte';
-  import type { CoordinatesConfig } from '../../types/layout/coordinates';
-
-  type SveltePlotProps = ComponentProps<typeof Plot>;
-
-  /**
-   * The Coordinates layer, rendered — resolves the active coordinate system
-   * (today, only a `d3-geo` projection; svelteplot has no other coordinate
-   * abstraction, cartesian is implicit elsewhere) and owns `<Plot>` itself,
-   * since `<Plot projection>` must be known before `<Plot>` mounts — nothing
-   * nested inside it could supply that prop after the fact. Also owns the
-   * pan/zoom/rotate gesture state and applies the resulting transform as a
-   * `<g>` wrapper around `children`. A no-op identity transform, no
-   * projection, for every plot kind but `GeoPlot`.
-   */
-  let {
-    width,
-    height,
-    margin,
-    x,
-    y,
-    coordinates = undefined,
-    data,
-    containerEl,
-    remountKey = undefined,
-    children,
-  }: {
-    width: number;
-    height: number;
-    margin: SveltePlotProps['margin'];
-    x: SveltePlotProps['x'];
-    y: SveltePlotProps['y'];
-    coordinates?: CoordinatesConfig;
-    /** Fed to `resolveProjection`'s `domain: 'data'` sentinel — the same rows `BasePlotLayout` uses for hover matching. */
-    data: TData[];
-    containerEl?: HTMLDivElement;
-    /** See `BasePlotLayout`'s own `remountKey` doc comment — forwarded verbatim to key svelteplot's `<Plot>` itself. */
-    remountKey?: string | number;
-    children: Snippet;
-  } = $props();
-
-  const resolvedProjection = $derived(
-    coordinates ? resolveProjection(coordinates.projection, data) : undefined,
-  );
-
-  const zoomEnabled = $derived(coordinates?.zoom !== false && coordinates?.zoom != null);
-  const zoomConfig = $derived(typeof coordinates?.zoom === 'object' ? coordinates.zoom : undefined);
-
-  /**
-   * Orthographic (and other azimuthal, hemisphere-style) projections don't
-   * gain anything from drag-to-*pan* — panning just slides the same globe a
-   * few pixels within the frame — so when zoom is enabled on one, drag
-   * instead rotates the globe (`createGeoRotate`) and wheel/pinch keeps
-   * scaling it (`createGeoZoom`, with its own drag disabled below so the two
-   * gestures don't fight over the same pointer events).
-   */
-  const projectionType = $derived(
-    typeof resolvedProjection === 'string' ? resolvedProjection : resolvedProjection?.type,
-  );
-  const rotateEnabled = $derived(zoomEnabled && projectionType === 'orthographic');
-  const baseRotate = $derived.by((): GeoRotate => {
-    const configured = typeof resolvedProjection === 'object' ? resolvedProjection?.rotate : undefined;
-    return [configured?.[0] ?? 0, configured?.[1] ?? 0, configured?.[2] ?? 0];
-  });
-
-  const geoZoom = createGeoZoom({
-    enabled: () => zoomEnabled,
-    config: () => zoomConfig,
-    node: () => containerEl ?? null,
-    disableDrag: () => rotateEnabled,
-  });
-
-  const geoRotate = createGeoRotate({
-    enabled: () => rotateEnabled,
-    baseRotate: () => baseRotate,
-    scale: () => geoZoom.transform.k,
-    node: () => containerEl ?? null,
-  });
-
-  const finalProjection = $derived.by(() => {
-    if (!rotateEnabled) return resolvedProjection;
-    return {
-      ...(typeof resolvedProjection === 'string' ? { type: resolvedProjection } : resolvedProjection),
-      rotate: geoRotate.rotate,
-    };
-  });
+	import type { ComponentProps, Snippet } from 'svelte';
+	import { geoCentroid, type GeoPermissibleObjects } from 'd3-geo';
+	import { Plot } from 'svelteplot';
+	import { resolveProjection } from './resolveProjection';
+	import { resolveCameraTarget } from './resolveCameraTarget';
+	import { createGeoZoom, type GeoZoomTransform } from './zoom.svelte';
+	import { createGeoRotate, type GeoRotate } from './rotate.svelte';
+	import {
+		createCameraTransformTween,
+		createCameraRotateTween
+	} from './camera.svelte';
+	import CameraFit from './CameraFit.svelte';
+	import type { CoordinatesConfig } from '../../types/layout/coordinates';
+
+	type SveltePlotProps = ComponentProps<typeof Plot>;
+
+	/**
+	 * Resolves the active coordinate system (a `d3-geo` projection) and owns
+	 * `<Plot>` itself, since `projection` must be known before it mounts.
+	 * Also owns pan/zoom/rotate gesture state and the declarative `camera`,
+	 * composed into the `<g>` transform wrapper (and, for `camera`/`rotate`
+	 * on `orthographic`, into the projection's own `rotate`). A no-op for
+	 * every plot kind but `GeoPlot`.
+	 */
+	let {
+		width,
+		height,
+		margin,
+		x,
+		y,
+		coordinates = undefined,
+		data,
+		containerEl,
+		remountKey = undefined,
+		children
+	}: {
+		width: number;
+		height: number;
+		margin: SveltePlotProps['margin'];
+		x: SveltePlotProps['x'];
+		y: SveltePlotProps['y'];
+		coordinates?: CoordinatesConfig;
+		/** Fed to `resolveProjection`'s `domain: 'data'` sentinel and to `coordinates.camera`'s `{features}` target resolution. */
+		data: TData[];
+		containerEl?: HTMLDivElement;
+		/** See `BasePlotLayout`'s own `remountKey` doc comment — forwarded verbatim to key svelteplot's `<Plot>` itself. */
+		remountKey?: string | number;
+		children: Snippet;
+	} = $props();
+
+	const resolvedProjection = $derived(
+		coordinates ? resolveProjection(coordinates.projection, data) : undefined
+	);
+
+	const zoomEnabled = $derived(coordinates?.zoom !== false && coordinates?.zoom != null);
+	const zoomConfig = $derived(typeof coordinates?.zoom === 'object' ? coordinates.zoom : undefined);
+	const panEnabled = $derived(coordinates?.pan ?? false);
+
+	const projectionType = $derived(
+		typeof resolvedProjection === 'string' ? resolvedProjection : resolvedProjection?.type
+	);
+
+	/** `rotate` claims the drag gesture from `pan` on `orthographic` (spins the globe instead of panning it). `zoom`'s wheel/pinch scaling is unaffected. */
+	const rotateEnabled = $derived(
+		(coordinates?.rotate ?? false) && projectionType === 'orthographic'
+	);
+	const baseRotate = $derived.by((): GeoRotate => {
+		const configured =
+			typeof resolvedProjection === 'object' ? resolvedProjection?.rotate : undefined;
+		return [configured?.[0] ?? 0, configured?.[1] ?? 0, configured?.[2] ?? 0];
+	});
+
+	const geoZoom = createGeoZoom({
+		panEnabled: () => panEnabled && !rotateEnabled,
+		zoomEnabled: () => zoomEnabled,
+		config: () => zoomConfig,
+		node: () => containerEl ?? null,
+		disableDrag: () => rotateEnabled
+	});
+
+	const geoRotate = createGeoRotate({
+		enabled: () => rotateEnabled,
+		baseRotate: () => baseRotate,
+		scale: () => geoZoom.transform.k,
+		node: () => containerEl ?? null
+	});
+
+	// ── Declarative camera ────────────────────────────────────────────────────
+	const cameraConfig = $derived(coordinates?.camera);
+	const resolvedCameraTarget = $derived(
+		cameraConfig
+			? resolveCameraTarget(
+					cameraConfig.target,
+					data as unknown as { __id: string; geometry: GeoJSON.Geometry }[]
+				)
+			: undefined
+	);
+	const cameraActive = $derived(resolvedCameraTarget != null);
+
+	/** `[-lon, -lat, gamma]` faces the target toward the viewer — only applied on `orthographic`, see `activeRotate`. */
+	const cameraRotateTarget = $derived.by((): GeoRotate | undefined => {
+		if (!resolvedCameraTarget) return undefined;
+		if (resolvedCameraTarget.kind === 'point') {
+			return [-resolvedCameraTarget.lon, -resolvedCameraTarget.lat, baseRotate[2]];
+		}
+		const [lon, lat] = geoCentroid(resolvedCameraTarget.geometry as GeoPermissibleObjects);
+		return [-lon, -lat, baseRotate[2]];
+	});
+
+	const cameraRotateTween = createCameraRotateTween({
+		target: () => (projectionType === 'orthographic' ? cameraRotateTarget : undefined),
+		transition: () => cameraConfig?.transition
+	});
+
+	/** `camera` claims `rotate` outright on `orthographic` (only one `rotate` value exists at a time) — interactive `rotate` takes back over once `camera` is unset. */
+	const cameraOrthoRotate = $derived(
+		cameraActive && projectionType === 'orthographic' ? cameraRotateTween.current : undefined
+	);
+	const activeRotate = $derived(
+		cameraOrthoRotate ?? (rotateEnabled ? geoRotate.rotate : baseRotate)
+	);
+	const rotateOverrideActive = $derived(cameraOrthoRotate != null || rotateEnabled);
+
+	const finalProjection = $derived.by(() => {
+		if (!rotateOverrideActive) return resolvedProjection;
+		return {
+			...(typeof resolvedProjection === 'string'
+				? { type: resolvedProjection }
+				: resolvedProjection),
+			rotate: activeRotate
+		};
+	});
+
+	// `CameraFit` (mounted inside `<Plot>`, below) reports the pixel `{x,y,k}` fitting `resolvedCameraTarget` against the live projection.
+	let cameraFit = $state<GeoZoomTransform | undefined>(undefined);
+
+	const cameraTransformTween = createCameraTransformTween({
+		target: () => cameraFit,
+		transition: () => cameraConfig?.transition
+	});
+	const cameraTransform = $derived(cameraTransformTween.current ?? { x: 0, y: 0, k: 1 });
 </script>
 
 {#key remountKey}
-  <Plot {width} {height} {margin} {x} {y} projection={finalProjection as SveltePlotProps['projection']}>
-    <g transform="translate({geoZoom.transform.x}, {geoZoom.transform.y}) scale({geoZoom.transform.k})">
-      {@render children()}
-    </g>
-  </Plot>
+	<Plot
+		{width}
+		{height}
+		{margin}
+		{x}
+		{y}
+		projection={finalProjection as SveltePlotProps['projection']}
+	>
+		{#if cameraActive && resolvedCameraTarget}
+			<CameraFit
+				target={resolvedCameraTarget}
+				anchor={cameraConfig?.anchor}
+				padding={cameraConfig?.padding}
+				zoom={cameraConfig?.zoom}
+				{width}
+				{height}
+				onFit={(fit) => (cameraFit = fit)}
+			/>
+		{/if}
+		<g transform="translate({cameraTransform.x}, {cameraTransform.y}) scale({cameraTransform.k})">
+			<g
+				transform="translate({geoZoom.transform.x}, {geoZoom.transform.y}) scale({geoZoom.transform
+					.k})"
+			>
+				{@render children()}
+			</g>
+		</g>
+	</Plot>
 {/key}

package/dist/layout/coordinates/CoordinatesLayout.svelte.d.ts

@@ -8,7 +8,7 @@ declare function $$render<TData extends Record<string, unknown>>(): {
         x: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").XScaleOptions> | undefined;
         y: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").YScaleOptions> | undefined;
         coordinates?: CoordinatesConfig;
-        /** Fed to `resolveProjection`'s `domain: 'data'` sentinel — the same rows `BasePlotLayout` uses for hover matching. */
+        /** Fed to `resolveProjection`'s `domain: 'data'` sentinel and to `coordinates.camera`'s `{features}` target resolution. */
         data: TData[];
         containerEl?: HTMLDivElement;
         /** See `BasePlotLayout`'s own `remountKey` doc comment — forwarded verbatim to key svelteplot's `<Plot>` itself. */

package/dist/layout/coordinates/camera.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { GeoCameraTransition } from '../../types/plots/camera';
+import type { GeoRotate } from './rotate.svelte';
+import type { GeoZoomTransform } from './zoom.svelte';
+/** Tweens the camera's pixel-space `{x,y,k}` transform toward `target()` — see `tweenState`'s doc comment for the two transition modes. */
+export declare function createCameraTransformTween(args: {
+    target: () => GeoZoomTransform | undefined;
+    transition: () => GeoCameraTransition | undefined;
+}): {
+    readonly current: GeoZoomTransform | undefined;
+};
+/** Tweens the camera's `[lambda, phi, gamma]` rotate toward `target()`, honoring `transition().direction`. */
+export declare function createCameraRotateTween(args: {
+    target: () => GeoRotate | undefined;
+    transition: () => GeoCameraTransition | undefined;
+}): {
+    readonly current: GeoRotate | undefined;
+};

package/dist/layout/coordinates/camera.svelte.js

@@ -0,0 +1,106 @@
+import { resolveEasing } from '../../utils/interpolate';
+function clamp01(t) {
+    return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+/**
+ * Tweens `T` toward `target()`, either auto-playing over `transition().duration`
+ * or, when `transition().progress` is set, as a pure function of it.
+ * Interrupting mid-flight continues from the current value. Shared by
+ * `createCameraTransformTween`/`createCameraRotateTween`.
+ */
+function tweenState(args) {
+    let current = $state(undefined);
+    // Mirrors `current` without being reactive — read this, not `current`,
+    // inside the effect below, or the async `tick()` write to `current` would
+    // re-trigger this very effect (see `rotate.svelte.ts`'s own warning).
+    let lastValue;
+    let from;
+    let to;
+    let raf;
+    function setCurrent(value) {
+        current = value;
+        lastValue = value;
+    }
+    $effect(() => {
+        const target = args.target();
+        if (target === undefined)
+            return;
+        const transition = args.transition();
+        const progress = transition?.progress;
+        const direction = transition?.direction ?? 'shortest';
+        const changed = to === undefined || !args.equals(to, target);
+        if (changed) {
+            // At progress 0 every easing resolves to `from`, so a target
+            // correction while idle there must re-snapshot `from` too, or it
+            // stays pinned to a stale value.
+            const atStart = progress != null && clamp01(progress) <= 0;
+            from = atStart ? target : (lastValue ?? target);
+            to = target;
+        }
+        if (raf != null) {
+            cancelAnimationFrame(raf);
+            raf = undefined;
+        }
+        if (progress != null) {
+            setCurrent(args.lerp(from, to, resolveEasing(transition?.easing)(clamp01(progress)), direction));
+            return;
+        }
+        if (!changed)
+            return;
+        const duration = Math.max(0, transition?.duration ?? 750);
+        const easing = resolveEasing(transition?.easing);
+        const startFrom = from;
+        const endTo = to;
+        const start = performance.now();
+        function tick(now) {
+            const t = duration === 0 ? 1 : Math.min(1, (now - start) / duration);
+            setCurrent(args.lerp(startFrom, endTo, easing(t), direction));
+            raf = t < 1 ? requestAnimationFrame(tick) : undefined;
+        }
+        raf = requestAnimationFrame(tick);
+        return () => {
+            if (raf != null)
+                cancelAnimationFrame(raf);
+        };
+    });
+    return {
+        get current() {
+            return current;
+        }
+    };
+}
+function lerpTransform(from, to, t) {
+    return {
+        x: from.x + (to.x - from.x) * t,
+        y: from.y + (to.y - from.y) * t,
+        k: from.k + (to.k - from.k) * t
+    };
+}
+function transformEquals(a, b) {
+    return a.x === b.x && a.y === b.y && a.k === b.k;
+}
+/** Signed angular delta from `a` to `b` in degrees — the smaller one for `'shortest'`, the way around it for `'longest'`. */
+function angleDelta(a, b, direction) {
+    const shortest = ((((b - a + 180) % 360) + 360) % 360) - 180;
+    if (direction === 'shortest')
+        return shortest;
+    return shortest > 0 ? shortest - 360 : shortest + 360;
+}
+function lerpRotate(from, to, t, direction) {
+    return [
+        from[0] + angleDelta(from[0], to[0], direction) * t,
+        from[1] + (to[1] - from[1]) * t,
+        from[2] + (to[2] - from[2]) * t
+    ];
+}
+function rotateEquals(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+/** Tweens the camera's pixel-space `{x,y,k}` transform toward `target()` — see `tweenState`'s doc comment for the two transition modes. */
+export function createCameraTransformTween(args) {
+    return tweenState({ ...args, lerp: lerpTransform, equals: transformEquals });
+}
+/** Tweens the camera's `[lambda, phi, gamma]` rotate toward `target()`, honoring `transition().direction`. */
+export function createCameraRotateTween(args) {
+    return tweenState({ ...args, lerp: lerpRotate, equals: rotateEquals });
+}

package/dist/layout/coordinates/resolveCameraTarget.d.ts

@@ -0,0 +1,14 @@
+import type { GeoCameraTarget } from '../../types/plots/camera';
+/** `GeoCameraTarget` resolved to actual geometry — `features` looked up by `__id` and unioned into one `FeatureCollection`; `undefined` if none match. */
+export type ResolvedGeoCameraTarget = {
+    kind: 'point';
+    lon: number;
+    lat: number;
+} | {
+    kind: 'bounds';
+    geometry: GeoJSON.GeoJsonObject;
+};
+export declare function resolveCameraTarget(target: GeoCameraTarget | undefined, features: {
+    __id: string;
+    geometry: GeoJSON.Geometry;
+}[]): ResolvedGeoCameraTarget | undefined;

package/dist/layout/coordinates/resolveCameraTarget.js

@@ -0,0 +1,19 @@
+export function resolveCameraTarget(target, features) {
+    if (!target)
+        return undefined;
+    if ('center' in target)
+        return { kind: 'point', lon: target.center[0], lat: target.center[1] };
+    if ('bounds' in target)
+        return { kind: 'bounds', geometry: target.bounds };
+    const wanted = new Set(target.features);
+    const matched = features.filter((f) => wanted.has(f.__id));
+    if (!matched.length)
+        return undefined;
+    return {
+        kind: 'bounds',
+        geometry: {
+            type: 'FeatureCollection',
+            features: matched.map((f) => ({ type: 'Feature', properties: null, geometry: f.geometry }))
+        }
+    };
+}

package/dist/layout/coordinates/zoom.svelte.d.ts

@@ -6,26 +6,22 @@ export type GeoZoomTransform = {
 };
 /**
  * Wires drag-pan + scroll-zoom onto a DOM node via d3-zoom, exposing the
- * resulting transform as reactive Svelte state. The caller applies it as an
- * SVG `<g transform="translate(x,y) scale(k)">` wrapper — cheap, since the
- * underlying `d3-geo` projection is computed once by svelteplot and never
- * recomputed per zoom tick.
+ * resulting transform as reactive Svelte state, applied by the caller as an
+ * SVG `<g transform="translate(x,y) scale(k)">` wrapper.
  *
- * Known v1 limitation: svelteplot's own `<Pointer>` hit-tests in the plot's
- * pre-zoom projected coordinate space, so hover/tooltip matching does not
- * compensate for an active pan/zoom transform — it still works, but targets
- * a shape's un-zoomed position rather than its currently-visible one.
+ * `panEnabled`/`zoomEnabled` gate drag-translate and wheel/pinch-scale
+ * independently, as separate `.filter()`s on the same underlying instance.
+ *
+ * Limitations: hover/tooltip hit-testing doesn't compensate for an active
+ * transform. Touch pinch-to-zoom is gated by `panEnabled`, not `zoomEnabled`
+ * (d3-zoom can't distinguish a pinch from a one-finger drag until underway).
  */
 export declare function createGeoZoom(args: {
-    enabled: () => boolean;
+    panEnabled: () => boolean;
+    zoomEnabled: () => boolean;
     config: () => GeoZoomConfig | undefined;
     node: () => HTMLElement | null;
-    /**
-     * When true, drag/touch gestures are left for something else to handle
-     * (see `createGeoRotate`) — only wheel/pinch scaling stays wired to this
-     * behavior. Checked per-event, so toggling it doesn't need to tear down
-     * and recreate the underlying d3-zoom behavior.
-     */
+    /** When true, drag/touch is left for something else (e.g. `createGeoRotate`) — only wheel/pinch scaling stays wired here. */
     disableDrag?: () => boolean;
 }): {
     readonly transform: GeoZoomTransform;