@nulib/clover 4.2.0 → 4.3.0

package/dist/index.d.mts

@@ -721,6 +721,15 @@ export interface GestureOptions {
 	 * or sound, always fitted to the Body).
 	 */
 	navigable: boolean;
+	/**
+	 * A mouse or pen drag tracks the pointer 1:1 and glides on after a fast release. Off,
+	 * the drag is eased instead and stops where the pointer does. A finger always tracks 1:1 and flicks.
+	 */
+	flickEnabled: boolean;
+	/** Release speed, px/s, below which a drag does not flick. */
+	flickMinSpeed: number;
+	/** Seconds of release velocity the flick travels. */
+	flickMomentum: number;
 }
 export type BackendPreference = "auto" | BackendKind;
 export type CanvasRendererEvent = 
@@ -793,6 +802,9 @@ export interface RegionShare {
  *   nor than its limits, at level 0 only a size it lists (Mat, 2026-10-24: "be
  *   responsible when making IIIF image server requests"). What a manifest says of a
  *   service is not trusted to say what its server does.
+ * - A `thumbnail` whose own `width` and `height` already fit the size (`resolveThumbnail`)
+ *   is used as the manifest gives it, with no `info.json` read: the publisher's own URL,
+ *   not one built from what a service says.
  * - Without a service, the image itself is used.
  */
 export interface ThumbnailSource {
@@ -807,6 +819,11 @@ export interface ThumbnailSource {
 	region?: RegionShare | string;
 	/** Used if the service cannot answer. */
 	fallback?: string;
+	/** The pixels `fallback` is, as its own `width` and `height` say (a `thumbnail`'s). */
+	fallbackSize?: {
+		width: number;
+		height: number;
+	};
 }
 /**
  * Where a resource's thumbnail comes from, to be sized by `resolveThumbnail`. Null if it
@@ -823,6 +840,9 @@ export declare function stillSource(resource: unknown): ThumbnailSource | null;
 /**
  * A source's URL at about `size` pixels on its longer side: a service's, made from its own
  * `info.json` (`sizedImageUrl`), else the fallback, as where the service cannot answer.
+ * The fallback itself, with no `info.json` read, when it is all of the image and its
+ * longer side is from `size` to twice it: no blurrier than the service would be asked
+ * for, and not much heavier.
  */
 export declare function resolveThumbnail(source: ThumbnailSource, size?: number, request?: CloverRequest): Promise<string | undefined>;
 /**
@@ -919,7 +939,14 @@ export type ControlButtonProps = {
 		lang?: string;
 		/** The key the Canvas answers to for this control, when it has one. */
 		"aria-keyshortcuts"?: string;
+		/** Absent while the control would do nothing, as at the greatest zoom. */
 		onClick?: React.MouseEventHandler<HTMLButtonElement>;
+		/**
+		 * `true` while the control would do nothing: zoom in at the greatest zoom, zoom out at
+		 * the least, reset at home. Spread it with the rest, never as `disabled`, which would
+		 * take the button from the keyboard (WCAG 2.4.3), and dim it.
+		 */
+		"aria-disabled"?: true;
 		/** On a control that opens a menu (the Choice control): its state and target. */
 		"aria-expanded"?: boolean;
 		"aria-controls"?: string;
@@ -987,6 +1014,15 @@ export interface CloverCanvasOptions {
 	minZoomImageRatio?: number;
 	/** Seconds for an animation to close most of its distance. 0 disables easing. */
 	animationTime?: number;
+	/**
+	 * Seconds each animation (zoom, glide, home) takes, on a fixed-length spring. Unset,
+	 * the camera eases by `animationTime` instead.
+	 */
+	animationDuration?: number;
+	/** With `animationDuration`, how much of the movement comes early: higher starts faster. Default 6.5. */
+	springStiffness?: number;
+	/** Hold the image inside its bounds while dragging. Default true; false lets it spring back on release. */
+	constrainDuringPan?: boolean;
 	/**
 	 * Milliseconds the controls and navigator stay after a mouse (or a pen that hovers)
 	 * stops moving, or a finger lifts, as the Player's `hideDelay`. Default 3000; `Infinity`
@@ -1991,6 +2027,167 @@ export declare function search(service: SearchService, query: string, { request,
 	request?: CloverRequest;
 	signal?: AbortSignal;
 }): Promise<SearchResults>;
+/**
+ * Whether a Manifest has anything to put on a map: navPlace on the Collection, Manifest,
+ * a Canvas or an annotation, a GeoJSON annotation body, or a georeferencing annotation.
+ * Only a look, never a read: the panel asks it to offer a Map tab, and the reading
+ * (`core/geo.ts`) belongs to the map entry, so an app without a map carries none of it.
+ */
+export declare function hasMapData(manifest: Manifest | null, collection?: Presentation4Collection | null): boolean;
+/**
+ * Where a IIIF resource is, read for a map: navPlace (on a Collection, Manifest, Canvas
+ * or Annotation, and annotation bodies that are GeoJSON), and Georeference Extension
+ * annotations, reduced to what a basic overlay needs. Framework-free and small: the map
+ * itself, and MapLibre, load only when a `Map` is shown.
+ *
+ * - navPlace: https://iiif.io/api/extension/navplace/
+ * - Georeference: https://iiif.io/api/extension/georef/
+ */
+export type Position = [
+	number,
+	number
+];
+export interface GeoGeometry {
+	type: string;
+	coordinates?: unknown;
+	geometries?: GeoGeometry[];
+}
+export interface MapFeature {
+	type: "Feature";
+	id?: string | number;
+	geometry: GeoGeometry;
+	/**
+	 * Flat, for MapLibre (which turns nested objects into strings): the text to show and
+	 * its language, the Canvas it belongs to, and any simplestyle keys it carried (`fill`,
+	 * `stroke`, …).
+	 */
+	properties: Record<string, string | number | boolean> & {
+		title?: string;
+		titleLang?: string;
+		canvasId?: string;
+		/** The annotation it is a body of (Cookbook 0139), which a press on it selects. */
+		annotationId?: string;
+		/** The Collection's member it locates (Cookbook 0318), which a press on it opens. */
+		manifestId?: string;
+		/** Its owner's `navDate`, as written, shown with its name (Cookbook 0318). */
+		navDate?: string;
+	};
+}
+export interface MapFeatureCollection {
+	type: "FeatureCollection";
+	features: MapFeature[];
+}
+/** A georeferenced image, reduced to an affine overlay. */
+export interface Georeference {
+	id: string;
+	/** The Canvas it georeferences, when it targets one. */
+	canvasId?: string;
+	/** Ground control points: image pixel [x, y] ↔ [longitude, latitude]. */
+	points: Array<{
+		resource: Position;
+		geo: Position;
+	}>;
+	/** The extent the points are measured in: the Canvas, or the image service. */
+	width: number;
+	height: number;
+	/** The part of the image that is map (an SvgSelector polygon), in the same units. */
+	mask?: Position[];
+	/** Its name: the annotation's label, or the Canvas's. */
+	label?: LanguageMapLike;
+	/** What to draw: an image body (or a bare image service), sized by `overlayImageUrl`. */
+	image: Record<string, unknown>;
+}
+/**
+ * Every navPlace feature of the Root's resource: the Collection's, each of its members'
+ * (Cookbook 0318: a Collection of Manifests, each where it is), the Manifest's, each
+ * Canvas's, and each loaded annotation's (its `navPlace`, or a GeoJSON body as Cookbook
+ * 0139 has). A feature from a member names that member, the open one's place its own
+ * Manifest's where it gives one, in the member's place in the Collection's order; one
+ * from a Canvas or annotation names that Canvas. Memoized on the Manifest (and the
+ * Collection), so the same collection comes back while nothing changes.
+ */
+export declare function navPlaceOf(manifest: Manifest | null, collection?: Presentation4Collection | null, language?: string): MapFeatureCollection;
+/**
+ * One Georeference Extension annotation as an overlay: its control points, the extent
+ * they are measured in, its mask, and the image to draw (the Canvas's painted image, or
+ * the image service it targets directly). Null when it cannot be drawn: fewer than three
+ * points, no extent, or nothing to draw.
+ */
+export declare function readGeoreference(annotation: Json, canvas?: Json): Georeference | null;
+/**
+ * The georeferenced images of the Manifest's Canvases, from their loaded annotation pages.
+ * Memoized on the Manifest: embedding a fetched page makes a new one.
+ */
+export declare function georeferencesOf(manifest: Manifest | null): Georeference[];
+/**
+ * The first-order polynomial (affine) transform that best fits the control points, image
+ * pixels to [longitude, latitude], by least squares in Web Mercator. Exact for three
+ * points. Null when the points are collinear.
+ */
+export declare function affineTransform(points: Georeference["points"]): ((pixel: Position) => Position) | null;
+/**
+ * Where the image's corners land, in the order MapLibre's image and canvas sources take
+ * them: top left, top right, bottom right, bottom left. Null when the points do not fix
+ * a transform.
+ */
+export declare function cornersOf(georeference: Georeference): [
+	Position,
+	Position,
+	Position,
+	Position
+] | null;
+/** The [[west, south], [east, north]] that holds the features and the overlays. */
+export declare function boundsOf(features: MapFeature[], overlays?: Georeference[]): [
+	Position,
+	Position
+] | null;
+export interface MapProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+	/**
+	 * Standalone: a IIIF resource (URL or object) to map: its navPlace, and its Canvases'
+	 * georeferenced images. Inside a `Root`, leave it out to map the Root's.
+	 */
+	iiifContent?: IIIFContent;
+	/** GeoJSON to draw (a FeatureCollection, Feature or geometry), as navPlace is. */
+	navPlace?: unknown;
+	/** Georeference Extension annotations to overlay, on a Canvas or an image service. */
+	georeferences?: unknown[];
+	/** Draw georeferenced images over the basemap. Default true. */
+	overlay?: boolean;
+	/** The overlays' opacity, 0 to 1. Default 0.75. */
+	overlayOpacity?: number;
+	/** A MapLibre style URL, used as it is. Default: Clover's relief basemap (OpenFreeMap). */
+	styleUrl?: string;
+	/**
+	 * Where MapLibre's worker is served from, to serve your own (see the Map docs). By
+	 * default Clover brings it, from a `blob:` URL.
+	 */
+	workerUrl?: string;
+	/** Zoom with the wheel or trackpad. Default false, so an embedded map never traps page scroll. */
+	scrollZoom?: boolean;
+	/**
+	 * A place was chosen, on the map or in its list. Inside a `Root`, choosing one on a
+	 * Canvas also goes there.
+	 */
+	onSelect?: (feature: MapFeature) => void;
+	/** Standalone: credentials, headers and `fetch`. */
+	request?: CloverRequest;
+	/** Standalone: the language to read IIIF text in. */
+	language?: string;
+	/**
+	 * Clover's higher-contrast mode: the accent kept to rings, outlines and marks, and never
+	 * under words or a glyph, where the controls' dark fill takes its place, edged in the
+	 * accent. Inside a `Root`, the Root's too; on wherever the reader's system asks for more
+	 * contrast. Default `false`.
+	 */
+	highContrast?: boolean;
+	/**
+	 * The basemap's credits, behind an ⓘ in the map's lower corner. Default true. A basemap's license
+	 * may ask for its credits: give them on the page yourself before setting this false.
+	 */
+	credits?: boolean;
+	as?: React.ElementType;
+}
+declare const CloverMap: React.ForwardRefExoticComponent<MapProps & React.RefAttributes<HTMLElement>>;
 /** Serve MapLibre's worker from `url` for every map Clover draws (a Viewer's Map tab included). */
 export declare function setMapWorkerUrl(url: string | undefined): void;
 export interface CollectionProps extends React.HTMLAttributes<HTMLElement> {
@@ -2637,8 +2834,10 @@ export type DefaultProps = Omit<RootProps, "children"> & {
 	 * The Body's `collapseControls`.
 	 */
 	collapseControls?: "auto" | "always";
+	/** The Body's Canvas `options`: its gestures, zoom limits and motion. */
+	canvasOptions?: CloverCanvasOptions;
 };
-declare function Default({ className, header, headingLevel, panel, defaultPanelOpen, panelLayout, panelSections, panelLabels, download, languages, items, singleItem, storageKey, fill, collapseControls, ...root }: DefaultProps): React.JSX.Element;
+declare function Default({ className, header, headingLevel, panel, defaultPanelOpen, panelLayout, panelSections, panelLabels, download, languages, items, singleItem, storageKey, fill, collapseControls, canvasOptions, ...root }: DefaultProps): React.JSX.Element;
 /**
  * A layout the Viewer draws: one from `@nulib/clover/templates`, or a component of your
  * own that takes the `Clover.Root` props.

package/dist/index.mjs

@@ -21,6 +21,9 @@ import { Split, SplitHandle, SplitPane } from "./components/Split/Split.mjs";
 import { Search } from "./components/Search/Search.mjs";
 import { search } from "./core/search.mjs";
 import { SEARCH_SET_ID, searchServiceOf } from "./core/search-service.mjs";
+import { CloverMap } from "./components/Map/Map.mjs";
+import { affineTransform, boundsOf, cornersOf, georeferencesOf, navPlaceOf, readGeoreference } from "./core/geo.mjs";
+import { hasMapData } from "./core/geo-detect.mjs";
 import { setMapWorkerUrl } from "./core/map-config.mjs";
 import { Collection } from "./components/Collection/Collection.mjs";
 import { CollectionSelect } from "./components/CollectionSelect/CollectionSelect.mjs";
@@ -64,6 +67,7 @@ export {
   Items,
   Label,
   Logo,
+  CloverMap as Map,
   Metadata,
   Next,
   Panel,
@@ -93,18 +97,25 @@ export {
   Transcript,
   Value,
   Viewer,
+  affineTransform,
+  boundsOf,
   buildContentState,
   chaptersOf,
+  cornersOf,
   cueAt,
   currentContents,
   decodeContentState,
   Viewer2 as default,
   encodeContentState,
+  georeferencesOf,
   groupViews,
+  hasMapData,
   initCloverI18n,
   localize,
+  navPlaceOf,
   parseVtt,
   readAs,
+  readGeoreference,
   regionSource,
   resolveBehavior,
   resolveDirection,

package/dist/lib/renderer/CanvasRenderer.mjs

@@ -4,7 +4,7 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { claimContext, returnContext } from "./backends/contexts.mjs";
 import { WebGL2Backend } from "./backends/webgl2/WebGL2Backend.mjs";
-import { fitCamera, anchoredCenter, visibleWorldRect, screenPointToWorld, worldPointToScreen, sameCamera } from "./camera/Camera.mjs";
+import { fitCamera, anchoredCenter, visibleWorldRect, screenPointToWorld, sameCamera, worldPointToScreen } from "./camera/Camera.mjs";
 import { CameraAnimator } from "./camera/CameraAnimator.mjs";
 import { GestureController, DEFAULT_GESTURES } from "./input/GestureController.mjs";
 import { TileCache } from "./io/TileCache.mjs";
@@ -19,6 +19,9 @@ const DEFAULTS = {
   maxZoomPixelRatio: 1.1,
   minZoomImageRatio: 0.9,
   animationTime: 0.09,
+  animationDuration: void 0,
+  springStiffness: 6.5,
+  constrainDuringPan: true,
   request: void 0,
   byteBudget: 192 * 1024 * 1024,
   maxInFlight: 6,
@@ -95,6 +98,8 @@ class CanvasRenderer {
     __publicField(this, "opened", false);
     /** True until the reader moves the camera; a resize then refits rather than crops. */
     __publicField(this, "atHome", true);
+    /** A pointer is down. Without `constrainDuringPan`, the center may leave the world. */
+    __publicField(this, "interacting", false);
     __publicField(this, "lastEmitted", null);
     __publicField(this, "generation", 0);
     __publicField(this, "listeners", /* @__PURE__ */ new Map());
@@ -172,13 +177,21 @@ class CanvasRenderer {
       ...DEFAULTS,
       ...stripUndefined(options)
     };
-    if (prefersReducedMotion()) this.options.animationTime = 0;
+    if (prefersReducedMotion()) {
+      this.options.animationTime = 0;
+      if (this.options.animationDuration !== void 0) {
+        this.options.animationDuration = 0;
+      }
+    }
+    const { animationDuration, springStiffness } = this.options;
     this.camera = new CameraAnimator(
       { x: 0, y: 0, zoom: 1, rotation: 0 },
-      this.options.animationTime
+      this.options.animationTime,
+      animationDuration === void 0 ? void 0 : { duration: animationDuration, stiffness: springStiffness }
     );
     this.loop = new FrameLoop(this.tick);
     this.gestureOptions = stripUndefined(options.gestures ?? {});
+    if (prefersReducedMotion()) this.gestureOptions.flickMomentum = 0;
     this.gestures = new GestureController(host, this, {
       ...DEFAULT_GESTURES,
       ...this.gestureOptions
@@ -412,13 +425,32 @@ class CanvasRenderer {
   home(immediate = false) {
     const home = this.homeCamera();
     if (!home) return;
+    const was = this.atHome;
     this.atHome = true;
     this.animateTo(home, immediate);
+    if (!was && this.opened) this.emit("viewport");
   }
   /** Zoomed in as far as it goes, or on the way there. */
   atMaxZoom() {
     return this.camera.destination.zoom >= this.getZoomLimits().max * (1 - ZOOM_EPSILON);
   }
+  /**
+   * Which of zoom in, zoom out and home would change nothing, judged where the camera is
+   * heading, as `atMaxZoom` is. Home is `isAtHome` and the same zoom, center and turn, to
+   * within half a screen pixel and a thousandth of the zoom: after a zoom in and out by
+   * hand the reader is not home, so reset stays, as the Document's sheets (`atHome`)
+   * and a resize's refit need it to.
+   */
+  viewLimits() {
+    const { zoom, x, y, rotation } = this.camera.destination;
+    const { min, max } = this.getZoomLimits();
+    const home = this.atHome ? this.homeCamera() : null;
+    return {
+      atMax: zoom >= max * (1 - ZOOM_EPSILON),
+      atMin: zoom <= min * (1 + ZOOM_EPSILON),
+      atHome: this.atHome && (!home || Math.abs(zoom / home.zoom - 1) < 1e-3 && Math.hypot(x - home.x, y - home.y) * zoom < 0.5 && Math.abs(rotation - home.rotation) < 1e-3)
+    };
+  }
   zoomBy(factor, at, animate = true) {
     const base = animate ? this.camera.destination : this.camera.current;
     const screen = at ?? {
@@ -469,9 +501,6 @@ class CanvasRenderer {
     this.atHome = false;
     this.animateTo(this.constrain({ ...base, ...point }), immediate);
   }
-  flick(vx, vy) {
-    this.panBy(vx * 0.25, vy * 0.25, true);
-  }
   rotateBy(degrees) {
     const base = this.camera.destination;
     this.setRotation(base.rotation * 180 / Math.PI + degrees);
@@ -508,7 +537,15 @@ class CanvasRenderer {
     });
   }
   setInteracting(interacting) {
-    if (interacting) this.camera.stop();
+    this.interacting = interacting;
+    if (interacting) {
+      this.camera.stop();
+      return;
+    }
+    if (this.options.constrainDuringPan) return;
+    const destination = this.camera.destination;
+    const settled = this.constrain(destination);
+    if (!sameCamera(destination, settled)) this.animateTo(settled, false);
   }
   worldToScreenPoint(point) {
     return worldPointToScreen(this.camera.current, this.viewport, point);
@@ -697,6 +734,9 @@ class CanvasRenderer {
     if (!bounds) return state;
     const { min, max } = this.getZoomLimits();
     const zoom = allowBeyondLimits ? clamp(state.zoom, min, Math.max(max, state.zoom)) : clamp(state.zoom, min, max);
+    if (this.interacting && !this.options.constrainDuringPan) {
+      return { ...state, zoom };
+    }
     return {
       ...state,
       zoom,
@@ -846,6 +886,7 @@ class CanvasRenderer {
           this.constrain({ ...current, zoom: current.zoom * ratio })
         );
       }
+      this.emit("viewport");
     }
     if (now2) this.loop.drawNow();
     else this.invalidate();

package/dist/lib/renderer/camera/CameraAnimator.mjs

@@ -8,24 +8,30 @@ const ZOOM_EPSILON = 1e-4;
 const PIXEL_EPSILON = 0.05;
 const ROTATION_EPSILON = 1e-4;
 class CameraAnimator {
-  constructor(initial, timeConstant = DEFAULT_TIME_CONSTANT) {
+  constructor(initial, timeConstant = DEFAULT_TIME_CONSTANT, spring) {
     __publicField(this, "current");
     __publicField(this, "target", null);
     __publicField(this, "timeConstant");
+    __publicField(this, "spring");
+    __publicField(this, "start");
+    __publicField(this, "elapsed", 0);
     this.current = { ...initial };
+    this.start = { ...initial };
     this.timeConstant = timeConstant;
+    this.spring = spring;
   }
   /** The state the camera is heading to (or at, when idle). */
   get destination() {
     return this.target ? { ...this.target.state } : { ...this.current };
   }
-  /** Jump, canceling any animation. Used by drags, which must track the pointer 1:1. */
+  /** Jump, canceling any animation. Used by drags that track the pointer 1:1. */
   set(state) {
     this.current = { ...state };
     this.target = null;
   }
   animateTo(target, viewport, immediate = false) {
-    if (immediate || this.timeConstant === 0) {
+    const off = this.spring ? this.spring.duration <= 0 : this.timeConstant === 0;
+    if (immediate || off) {
       this.set(target.state);
       return;
     }
@@ -41,6 +47,8 @@ class CameraAnimator {
       const miss = Math.hypot(landing.x - target.state.x, landing.y - target.state.y) * target.state.zoom;
       if (miss > PIXEL_EPSILON) anchor = void 0;
     }
+    this.start = { ...this.current };
+    this.elapsed = 0;
     this.target = { state: { ...target.state }, anchor };
   }
   stop() {
@@ -53,29 +61,40 @@ class CameraAnimator {
   step(dt, viewport) {
     const target = this.target;
     if (!target) return false;
-    const k = 1 - Math.exp(-Math.max(dt, 0) / this.timeConstant);
-    const from = this.current;
     const to = target.state;
+    let from;
+    let k;
+    if (this.spring) {
+      this.elapsed += Math.max(dt, 0);
+      const t = this.elapsed / this.spring.duration;
+      if (t >= 1) {
+        this.current = { ...to };
+        this.target = null;
+        return false;
+      }
+      const s = this.spring.stiffness;
+      from = this.start;
+      k = (1 - Math.exp(-s * t)) / (1 - Math.exp(-s));
+    } else {
+      from = this.current;
+      k = 1 - Math.exp(-Math.max(dt, 0) / this.timeConstant);
+    }
     const zoom = Math.exp(
       Math.log(from.zoom) + (Math.log(to.zoom) - Math.log(from.zoom)) * k
     );
     const rotation = from.rotation + (to.rotation - from.rotation) * k;
-    let center;
-    if (target.anchor) {
-      center = anchoredCenter(
-        target.anchor.world,
-        target.anchor.screen,
-        zoom,
-        rotation,
-        viewport
-      );
-    } else {
-      center = {
-        x: from.x + (to.x - from.x) * k,
-        y: from.y + (to.y - from.y) * k
-      };
-    }
+    const center = target.anchor ? anchoredCenter(
+      target.anchor.world,
+      target.anchor.screen,
+      zoom,
+      rotation,
+      viewport
+    ) : {
+      x: from.x + (to.x - from.x) * k,
+      y: from.y + (to.y - from.y) * k
+    };
     this.current = { x: center.x, y: center.y, zoom, rotation };
+    if (this.spring) return true;
     const settled = Math.abs(Math.log(to.zoom / zoom)) < ZOOM_EPSILON && Math.abs(to.rotation - rotation) < ROTATION_EPSILON && Math.hypot(to.x - center.x, to.y - center.y) * zoom < PIXEL_EPSILON;
     if (settled) {
       this.current = { ...to };

package/dist/lib/renderer/input/GestureController.mjs

@@ -8,13 +8,15 @@ const DEFAULT_GESTURES = {
   dblClickToZoom: true,
   pinchToZoom: true,
   scrollToZoom: false,
-  navigable: true
+  navigable: true,
+  flickEnabled: true,
+  flickMinSpeed: 200,
+  flickMomentum: 0.25
 };
 const CLICK_ZOOM = 2;
 const KEY_ZOOM = 1.5;
 const KEY_PAN_FRACTION = 0.1;
 const VELOCITY_WINDOW_MS = 100;
-const MIN_FLICK_SPEED = 200;
 const WHEEL_ZOOM_RATE = 2e-3;
 const PINCH_WHEEL_ZOOM_RATE = 0.01;
 class GestureController {
@@ -58,7 +60,7 @@ class GestureController {
           this.down.moved = true;
         }
         if (((_a = this.down) == null ? void 0 : _a.moved) && this.options.navigable) {
-          this.target.panBy(dx, dy, false);
+          this.target.panBy(dx, dy, !this.tracksPointer(event.pointerType));
         }
         this.samples.push({ x: p.x, y: p.y, t: event.timeStamp });
         const cutoff = event.timeStamp - VELOCITY_WINDOW_MS;
@@ -124,14 +126,18 @@ class GestureController {
         }
         return;
       }
-      if (!this.options.navigable) return;
+      if (!this.options.navigable || !this.tracksPointer(event.pointerType)) {
+        return;
+      }
       const first = this.samples[0];
       const last = this.samples[this.samples.length - 1];
       const span = ((last == null ? void 0 : last.t) ?? 0) - ((first == null ? void 0 : first.t) ?? 0);
       if (first && last && span > 0 && event.timeStamp - last.t < 50) {
         const vx = (last.x - first.x) / span * 1e3;
         const vy = (last.y - first.y) / span * 1e3;
-        if (Math.hypot(vx, vy) > MIN_FLICK_SPEED) this.target.flick(vx, vy);
+        const momentum = this.options.flickMomentum;
+        if (momentum > 0 && Math.hypot(vx, vy) > this.options.flickMinSpeed)
+          this.target.panBy(vx * momentum, vy * momentum, true);
       }
     });
     __publicField(this, "onDoubleClick", (event) => {
@@ -233,6 +239,10 @@ class GestureController {
     if ((_b = (_a = this.target).atMaxZoom) == null ? void 0 : _b.call(_a)) this.target.home();
     else this.target.zoomBy(CLICK_ZOOM, at, true);
   }
+  /** A drag that follows the pointer exactly, and so may flick on release. */
+  tracksPointer(pointerType) {
+    return pointerType === "touch" || this.options.flickEnabled;
+  }
   pinchState() {
     const [a, b] = [...this.pointers.values()];
     return {

package/dist/map/index.d.mts

@@ -19,6 +19,12 @@ export type Presentation4Collection = P4.Collection;
  * tag, so the text can carry a `lang` attribute.
  */
 export type LanguageMapLike = string | Record<string, string[] | string | undefined> | null | undefined;
+/**
+ * A IIIF resource as JSON, read loosely. One declaration for the modules whose `Json`
+ * reaches Clover's types: the bundled declarations (`build:types`) would hold one per
+ * module, under the one name, which TypeScript rejects.
+ */
+export type Json = Record<string, any>;
 /**
  * Whether a Manifest has anything to put on a map: navPlace on the Collection, Manifest,
  * a Canvas or an annotation, a GeoJSON annotation body, or a georeferencing annotation.
@@ -89,7 +95,6 @@ export interface Georeference {
 	/** What to draw: an image body (or a bare image service), sized by `overlayImageUrl`. */
 	image: Record<string, unknown>;
 }
-export type Json = Record<string, any>;
 /**
  * Every navPlace feature of the Root's resource: the Collection's, each of its members'
  * (Cookbook 0318: a Collection of Manifests, each where it is), the Manifest's, each

package/dist/styles/collection-select.css

@@ -0,0 +1 @@
+@layer clover{.clover-collection-select{display:flex;flex-wrap:wrap;align-items:center;gap:var(--clover-space-xs)}.clover-collection-select-label{color:var(--clover-color-primary-muted, #26292b);font-size:var(--clover-text-s);font-weight:600}.clover-collection-select-control{min-width:0;max-width:100%;padding-inline-end:var(--clover-space-xl)}}