@react-x11/components 0.8.0 → 0.9.0

package/dist/maps/controller.js

@@ -0,0 +1,743 @@
+import { markerAt, markerRect } from './overlay.js';
+import { DEFAULT_TILE_SIZE, boundsOf, cameraForBounds, projectLngLat, transformFor, unprojectPoint, visibleBounds, } from './proj.js';
+/** Where a map with no camera given starts. */
+export const DEFAULT_CAMERA = {
+    center: { lon: 0, lat: 20 },
+    zoom: 2,
+};
+/** Logical pixels the pointer may travel before a press becomes a drag. */
+export const DRAG_THRESHOLD = 3;
+/**
+ * How long after the last camera change the map counts as moving.
+ *
+ * One window for both renderers, and both ask it the same question — is this
+ * a gesture? The retained renderer rasterizes nothing inside it, so a drag or
+ * a wheel is composites only; the GL renderer draws at reduced detail inside
+ * it when adaptive quality asks, and admits no new labels. `onMoveEnd` fires
+ * when it closes. Long enough that a wheel zoom's many notches count as one
+ * gesture, short enough that the map sharpens before the user has finished
+ * looking. (The retained renderer had 140 ms and the GL proof of concept
+ * 180; the retained number was the one its tests had pinned.)
+ */
+export const SETTLE_MS = 140;
+/**
+ * Zoom is quantized to this, for the reason react-x11's docs/scale.md gives
+ * about a gesture-driven `scale`: every distinct value is a distinct set of
+ * font sizes to shape, and a wheel feeding a raw accumulator makes a new set
+ * per frame. A sixteenth of a level is finer than the eye reads as stepping.
+ */
+const ZOOM_STEP = 1 / 16;
+/** A zoom on the {@link ZOOM_STEP} grid — also what a label placement is
+ *  keyed on, so a placement and the zooms a wheel produces agree. */
+export function quantizeZoom(zoom) {
+    return Math.round(zoom / ZOOM_STEP) * ZOOM_STEP;
+}
+/** A wheel notch is this much zoom. */
+const WHEEL_ZOOM = 1 / 2.5;
+/**
+ * How fast a wheel's zoom closes on where the notches asked it to go — the
+ * time constant of the exponential the glide follows, so it is all but over
+ * after three of these.
+ *
+ * A notch is 0.384 of a level, which is six of {@link ZOOM_STEP}, and
+ * applying it the moment it arrives is a jump: the map is one size, and a
+ * frame later it is another. The device cannot help with that. A wheel
+ * *clicks* — the core protocol reports it as a button, and even over XI2 a
+ * mouse reports one notch at a time — so the smoothness has to come from
+ * the map spreading a notch over the frames after it, which is what every
+ * map client does with one. `ev.smooth` tells that device from the one that
+ * measured the scroll; see {@link MapController.wheel}.
+ */
+const WHEEL_EASE_MS = 55;
+/** What the wheel event's own step is worth, in the absence of a frame to
+ *  measure: one at 60Hz. The gesture has to move *now* — a wheel that waits
+ *  for the next frame to do anything reads as lag — and this is the distance
+ *  a frame would have moved it. */
+const EASE_FIRST_MS = 16;
+/**
+ * How often a glide steps: a 60Hz frame.
+ *
+ * A timer rather than the frame the step is drawn in, because a step *is* a
+ * camera move and the views already know what to do with one — the retained
+ * renderer claims the pane, the GL one asks for a frame — and that is the
+ * path a drag's every pointer step takes. Claiming from inside a frame is
+ * not: the claim lands on the frame being painted and brings nothing after
+ * it, which left a notch delivering its first step and then waiting for the
+ * settle timer to wake the map up.
+ *
+ * Nothing here outruns the display. The step is exponential in the *time*
+ * since the last one, so a view that paints at half this rate sees every
+ * other step and the same glide; what the timer decides is the finest the
+ * map can move, not how fast it gets there.
+ */
+const GLIDE_TICK_MS = 16;
+const timers = globalThis;
+/**
+ * The clock a glide is measured on.
+ *
+ * `performance.now()` rather than the `Date.now()` the settle window uses:
+ * this one is compared across two frames of a 60Hz display, and `Date.now()`
+ * counts whole milliseconds, so a sixth of the step would be error. Reached
+ * through `globalThis` because `src/` compiles with `types: []`.
+ */
+function now() {
+    return timers.performance?.now() ?? Date.now();
+}
+/**
+ * The settle timer, unref'd where the runtime allows it.
+ *
+ * A map that has just been panned holds a timer, and an unref'd one does not
+ * keep a process alive on its own — which matters for a script or a test that
+ * renders a map and expects to exit, and is the call core's caret blink makes
+ * for the same reason.
+ */
+function arm(tick, ms) {
+    const handle = timers.setTimeout?.(tick, ms) ?? null;
+    handle?.unref?.();
+    return handle;
+}
+function clamp(value, low, high) {
+    return value < low ? low : value > high ? high : value;
+}
+const EMPTY_PANE = { x: 0, y: 0, width: 0, height: 0 };
+export class MapController {
+    /**
+     * What `<Map>`'s ref hands out. Made once, so it is the **same object**
+     * for the life of the mount — across a renderer switch too, which is
+     * what lets an application hold it in a ref and never look again.
+     */
+    handle;
+    /**
+     * Set by the view for the length of a frame. A camera change made inside
+     * one — the fit that a `fitBounds` asked for before layout, applied at
+     * the first frame with a size — is already what the frame draws, so it
+     * claims nothing and starts no gesture.
+     */
+    painting = false;
+    _props = {};
+    /** The camera, when the application does not control it. */
+    _camera;
+    _view = null;
+    _gesture = null;
+    _hover = null;
+    /** Wall-clock time the settle window closes at. */
+    _settleAt = 0;
+    _settleTimer = null;
+    _glide = null;
+    _glideTimer = null;
+    _pendingFit = null;
+    constructor(seed = DEFAULT_CAMERA) {
+        this._camera = { center: { ...seed.center }, zoom: seed.zoom };
+        this.handle = {
+            getCamera: () => this.getCamera(),
+            setCamera: (camera) => this.setCamera(camera),
+            panBy: (dx, dy) => this.panBy(dx, dy),
+            zoomIn: (step) => this.zoomIn(step),
+            zoomOut: (step) => this.zoomOut(step),
+            zoomTo: (zoom) => this.zoomTo(zoom),
+            fitBounds: (bounds, options) => this.fitBounds(bounds, options),
+            fitMarkers: (ids, options) => this.fitMarkers(ids, options),
+            getBounds: () => this.getBounds(),
+            project: (position) => this.project(position),
+            unproject: (x, y) => this.unproject(x, y),
+            markerAt: (x, y) => this.markerAt(x, y),
+            refresh: () => this._view?.refresh(),
+            stats: () => this._view?.stats() ?? null,
+        };
+    }
+    // --- props and views --------------------------------------------------------
+    /** The props to read from here on. Read lazily, at event and frame time,
+     *  so a new object per render costs an assignment. */
+    setProps(props) {
+        this._props = props;
+    }
+    get props() {
+        return this._props;
+    }
+    /** The renderer drawing the map from now on. */
+    attach(view) {
+        this._view = view;
+    }
+    /** …and letting go, if it still is: during a renderer switch the new
+     *  view can attach before the old one is torn down. */
+    detach(view) {
+        if (this._view === view)
+            this._view = null;
+    }
+    get view() {
+        return this._view;
+    }
+    /**
+     * Stop the timers — the settle window's, and a wheel glide in flight.
+     * They are the only things held that outlive a frame. The camera and the
+     * view stay, so a mount that React only pretends to tear down (a
+     * strict-mode double effect) comes back to a working controller; the next
+     * camera move arms the settle timer again, and the next notch a glide.
+     */
+    dispose() {
+        if (this._settleTimer !== null)
+            timers.clearTimeout?.(this._settleTimer);
+        this._settleTimer = null;
+        if (this._glideTimer !== null)
+            timers.clearTimeout?.(this._glideTimer);
+        this._glideTimer = null;
+        this._glide = null;
+    }
+    _minZoom() {
+        return this._props.minZoom ?? 0;
+    }
+    _maxZoom() {
+        return this._props.maxZoom ?? 22;
+    }
+    _interactive() {
+        return this._props.interactive !== false;
+    }
+    _markers() {
+        return this._props.markers ?? [];
+    }
+    // --- the camera ----------------------------------------------------------
+    /** The camera in effect: the application's when it controls one. */
+    camera() {
+        return this._props.camera ?? this._camera;
+    }
+    /** The camera this controller keeps for itself — the one in effect
+     *  whenever the application is not controlling it. */
+    ownCamera() {
+        return this._camera;
+    }
+    /** The pane, in the window's logical pixels — empty with no view. */
+    pane() {
+        return this._view?.pane() ?? EMPTY_PANE;
+    }
+    /** A camera resolved against the pane. */
+    transform(camera = this.camera()) {
+        const pane = this.pane();
+        return transformFor(camera, { width: pane.width, height: pane.height }, DEFAULT_TILE_SIZE);
+    }
+    /**
+     * Move the camera — the one place it changes.
+     *
+     * Clamped (the zoom to the range, the latitude to what Web Mercator can
+     * represent; the longitude is not, because the map wraps and a camera just
+     * past the antimeridian is a camera in the next copy of the world),
+     * reported, and the settle window restarted: every camera move is a
+     * gesture, not only a pointer one, because an application animating the
+     * camera with `panBy` in a loop wants what a drag wants.
+     *
+     * A camera the application controls is only *asked* to move:
+     * `onCameraChange` is the request, and the view hears about the move when
+     * the new `camera` prop arrives. Telling it here as well was a double
+     * shift — the retained renderer blitted the pane for the request and then
+     * again for the prop, and `scrollContents` adds two shifts in a frame
+     * together.
+     */
+    apply(next, blit) {
+        const previous = this.camera();
+        const camera = {
+            center: { lon: next.center.lon, lat: clamp(next.center.lat, -85, 85) },
+            zoom: clamp(next.zoom, this._minZoom(), this._maxZoom()),
+        };
+        if (camera.zoom === previous.zoom &&
+            camera.center.lon === previous.center.lon &&
+            camera.center.lat === previous.center.lat) {
+            return;
+        }
+        const controlled = this._props.camera !== undefined;
+        if (!controlled)
+            this._camera = camera;
+        this._props.onCameraChange?.(camera);
+        if (this.painting)
+            return;
+        this.touch();
+        if (!controlled)
+            this._view?.moved(previous, camera, blit);
+    }
+    getCamera() {
+        const camera = this.camera();
+        return { center: { ...camera.center }, zoom: camera.zoom };
+    }
+    setCamera(camera) {
+        const current = this.camera();
+        this.apply({
+            center: camera.center ?? current.center,
+            zoom: camera.zoom ?? current.zoom,
+        }, false);
+    }
+    /** Move by a distance in pane-local logical pixels. */
+    panBy(dx, dy) {
+        const t = this.transform();
+        this.apply({
+            zoom: t.zoom,
+            center: unprojectPoint(t, t.paneX + dx, t.paneY + dy),
+        }, true);
+    }
+    zoomIn(step = 1) {
+        const pane = this.pane();
+        this.zoomAbout(step, pane.width / 2, pane.height / 2);
+    }
+    zoomOut(step = 1) {
+        this.zoomIn(-step);
+    }
+    zoomTo(zoom) {
+        this.setCamera({ zoom });
+    }
+    /**
+     * Zoom by `delta` levels about a pane-local point that must not move —
+     * the pointer under a wheel, the pane's centre for a key.
+     */
+    zoomAbout(delta, x, y) {
+        const camera = this.camera();
+        const zoom = clamp(quantizeZoom(camera.zoom + delta), this._minZoom(), this._maxZoom());
+        if (zoom === camera.zoom)
+            return;
+        const before = this.transform(camera);
+        const anchor = unprojectPoint(before, x, y);
+        const after = this.transform({ center: camera.center, zoom });
+        // Where the anchor would land at the new zoom, and how far the centre
+        // has to move so it lands where it already is.
+        const moved = projectLngLat(after, anchor);
+        const dx = (moved.x - x) / after.world;
+        const dy = (moved.y - y) / after.world;
+        this.apply({
+            zoom,
+            center: unprojectPoint({
+                ...after,
+                centerX: after.centerX + dx,
+                centerY: after.centerY + dy,
+            }, after.paneX, after.paneY),
+        }, false);
+    }
+    /**
+     * A scroll, as a zoom: where the wheel wants the camera, and how the
+     * frames after it get there.
+     *
+     * **Two devices arrive here and they want opposite things.** A wheel
+     * *clicks*: one event carrying a whole notch, with nothing in between, so
+     * the notch becomes a target the frames after it glide towards. A touchpad
+     * *measures*: a stream of fractions that is already as smooth as the hand
+     * making it, which wants applying the moment it arrives and only needs
+     * keeping from rounding away. `ev.smooth` is core's word for which device
+     * this is — "a whole notch is worth easing towards, a stream of measured
+     * pixels is not" (react-x11's docs/events.md).
+     *
+     * Either way the *target* accumulates. A second notch arriving mid-glide
+     * lengthens the one gesture instead of starting another, and a fraction
+     * too small to move the quantized camera is still on the books when the
+     * next one arrives.
+     */
+    _wheelZoom(delta, x, y, smooth) {
+        const at = now();
+        const camera = this.camera();
+        const glide = this._glide;
+        // Where this delta counts from: the target the wheel has already asked
+        // for, or the camera when there is nothing outstanding. A record whose
+        // `applied` is not where the camera is belongs to a camera something
+        // else has since moved, and is not this gesture's to add to.
+        //
+        // Nothing expires it by age. A glide that is still owed frames is still
+        // owed them however long the frames take, and what is left of a
+        // touchpad's is under half a step of zoom — too little to be a jump
+        // whenever it is spent.
+        const from = glide && glide.applied === camera.zoom ? glide.target : camera.zoom;
+        // Clamped here as well as in `apply`: an accumulator allowed past the
+        // limit records notches the map cannot answer, and the scroll back out
+        // then does nothing until they are spent.
+        this._glide = {
+            target: clamp(from + delta, this._minZoom(), this._maxZoom()),
+            applied: camera.zoom,
+            x,
+            y,
+            at,
+            easing: !smooth,
+        };
+        // The event's own step, so the map moves under the notch that asked
+        // rather than on the frame after it — and then the rest, a frame at a
+        // time, until the target is reached.
+        this.stepZoom(at, EASE_FIRST_MS);
+        this._armGlide();
+    }
+    /** Keep stepping a glide until it arrives. Idempotent: a notch arriving
+     *  mid-glide moves the target and finds the timer already running. */
+    _armGlide() {
+        if (this._glideTimer !== null || this._glide?.easing !== true)
+            return;
+        const tick = () => {
+            this._glideTimer = null;
+            const glide = this._glide;
+            if (glide?.easing !== true)
+                return;
+            const at = now();
+            // `stepZoom` clears the record when the target is reached or the
+            // camera refuses a step, and this re-arms only while one is left.
+            this.stepZoom(at, at - glide.at);
+            this._armGlide();
+        };
+        this._glideTimer = arm(tick, GLIDE_TICK_MS);
+    }
+    /**
+     * One step of a glide: how far the camera moves this frame.
+     *
+     * Exponential rather than a curve with a duration, because the distance is
+     * not known when it starts — a second notch moves the target while the
+     * first is still being delivered — and because `elapsed` being the real
+     * gap between two frames is what makes the glide the same speed on a
+     * display that paints 120 frames a second and one that manages 30.
+     *
+     * Returns whether the camera moved. The move itself is what brings the
+     * frame that shows it: `apply` tells the view, exactly as a drag's every
+     * pointer step does.
+     */
+    stepZoom(at, elapsed) {
+        const glide = this._glide;
+        if (!glide)
+            return false;
+        const camera = this.camera();
+        if (glide.applied !== camera.zoom) {
+            // The camera moved without this gesture: an application that owns it
+            // answering a wheel with something of its own, a `setCamera`, a fit.
+            // Whatever it was is more current than a notch from before it.
+            this._glide = null;
+            return false;
+        }
+        const remaining = glide.target - camera.zoom;
+        let step = glide.easing
+            ? remaining * (1 - Math.exp(-elapsed / WHEEL_EASE_MS))
+            : remaining;
+        // Never a step the quantized camera cannot show. The tail of an
+        // exponential is arbitrarily small, and a step that rounds to nothing
+        // would leave the glide asking for frames it has no use for — so the
+        // tail is walked a grid step at a time, and "the camera did not move" is
+        // left meaning what it says below.
+        if (Math.abs(step) < ZOOM_STEP) {
+            step =
+                Math.abs(remaining) < ZOOM_STEP
+                    ? remaining
+                    : Math.sign(remaining) * ZOOM_STEP;
+        }
+        const before = camera.zoom;
+        this.zoomAbout(step, glide.x, glide.y);
+        const zoom = this.camera().zoom;
+        glide.applied = zoom;
+        glide.at = at;
+        if (zoom === before) {
+            // The camera refused a step it cannot have rounded away — an
+            // application owns it and did not answer, or it is against its limit.
+            // A wheel's glide has nothing further to deliver; a touchpad's record
+            // stays behind as the accumulator, and the next fraction moves it on.
+            if (glide.easing)
+                this._glide = null;
+            return false;
+        }
+        return true;
+    }
+    fitBounds(bounds, options) {
+        const pane = this.pane();
+        if (pane.width <= 0 || pane.height <= 0) {
+            // Asked before layout has run — which `fitBounds` in an effect always
+            // is. Remembered, and applied at the first frame that has a size.
+            this._pendingFit = { bounds, options };
+            return;
+        }
+        this._pendingFit = null;
+        this.apply(cameraForBounds(bounds, { width: pane.width, height: pane.height }, {
+            padding: options?.padding ?? 24,
+            tileSize: DEFAULT_TILE_SIZE,
+            minZoom: this._minZoom(),
+            maxZoom: options?.maxZoom ?? this._maxZoom(),
+        }), false);
+    }
+    fitMarkers(ids, options) {
+        const wanted = ids ? new Set(ids) : null;
+        const positions = [];
+        for (const marker of this._markers()) {
+            if (wanted && !wanted.has(marker.id))
+                continue;
+            positions.push(marker.position);
+        }
+        const bounds = boundsOf(positions);
+        if (bounds)
+            this.fitBounds(bounds, options);
+    }
+    /** What the pane can see — the whole world before it has a size. */
+    getBounds() {
+        const pane = this.pane();
+        if (pane.width <= 0 || pane.height <= 0) {
+            return { west: -180, south: -85, east: 180, north: 85 };
+        }
+        return visibleBounds(this.transform());
+    }
+    project(position) {
+        return projectLngLat(this.transform(), position);
+    }
+    unproject(x, y) {
+        return unprojectPoint(this.transform(), x, y);
+    }
+    markerAt(x, y) {
+        return markerAt(this._markers(), this.transform(), x, y);
+    }
+    /**
+     * A view is about to draw a frame: a `fitBounds` that arrived before the
+     * pane had a size is applied now, so the frame draws it.
+     */
+    beginFrame() {
+        const fit = this._pendingFit;
+        if (!fit)
+            return;
+        const pane = this.pane();
+        if (pane.width <= 0 || pane.height <= 0)
+            return;
+        this.fitBounds(fit.bounds, fit.options);
+    }
+    // --- the settle window ---------------------------------------------------
+    /** Whether the camera moved within the settle window. */
+    get moving() {
+        return Date.now() < this._settleAt;
+    }
+    /** …or a press is still down: what the retained renderer holds
+     *  rasterization off for. */
+    get gesturing() {
+        return this._gesture !== null || this.moving;
+    }
+    /** Whether a pan gesture is under way — a press that may yet drag. */
+    get dragging() {
+        return this._gesture?.kind === 'pan';
+    }
+    /**
+     * Restart the settle window. When it closes the camera has held still for
+     * {@link SETTLE_MS}: `onMoveEnd` fires — the moment an application fetches
+     * what is now on screen — and the view is told it may sharpen.
+     *
+     * Wall-clock time rather than a frame clock: this is a window a hundred
+     * and forty milliseconds long compared inside a timer callback, and a
+     * timer is the one thing that runs when no frame does.
+     */
+    touch() {
+        this._settleAt = Date.now() + SETTLE_MS;
+        if (this._settleTimer !== null)
+            return;
+        const tick = () => {
+            this._settleTimer = null;
+            const left = this._settleAt - Date.now();
+            if (left > 0) {
+                this._settleTimer = arm(tick, left);
+                return;
+            }
+            this._props.onMoveEnd?.(this.camera());
+            this._view?.settled();
+        };
+        this._settleTimer = arm(tick, SETTLE_MS);
+    }
+    // --- input ---------------------------------------------------------------
+    /**
+     * A press. Answers what it began, for the view to capture the pointer — and
+     * for a pan, to take the focus — or null when nothing is.
+     *
+     * A press on a marker is a marker gesture: its release is a marker click.
+     * A press anywhere else is a pan, or on a map that does not move a
+     * `'frozen'` press, which pans nothing and is still a click when it is
+     * released — an application listening for clicks on a frozen map gets
+     * them.
+     */
+    pointerDown(input) {
+        const marker = markerAt(this._markers(), this.transform(), input.x, input.y);
+        if (marker) {
+            this._gesture = {
+                kind: 'marker',
+                id: marker.id,
+                startX: input.x,
+                startY: input.y,
+            };
+            return 'marker';
+        }
+        this._gesture = {
+            kind: 'pan',
+            startX: input.x,
+            startY: input.y,
+            lastX: input.x,
+            lastY: input.y,
+            moved: false,
+        };
+        return this._interactive() ? 'pan' : 'frozen';
+    }
+    /** The pointer moved with the press still down. */
+    pointerDrag(input) {
+        const gesture = this._gesture;
+        if (!gesture || gesture.kind !== 'pan')
+            return;
+        if (!this._interactive())
+            return;
+        if (!gesture.moved &&
+            Math.abs(input.x - gesture.startX) < DRAG_THRESHOLD &&
+            Math.abs(input.y - gesture.startY) < DRAG_THRESHOLD) {
+            return;
+        }
+        gesture.moved = true;
+        // Whole device pixels, because that is what the retained renderer's
+        // blit can shift — a fractional pan would decline it every frame and
+        // repaint the pane. Invisible on the GL renderer, which draws any shift.
+        const scale = this._view?.scale() ?? 1;
+        const dx = Math.round((input.x - gesture.lastX) * scale) / scale;
+        const dy = Math.round((input.y - gesture.lastY) * scale) / scale;
+        if (dx === 0 && dy === 0)
+            return;
+        gesture.lastX += dx;
+        gesture.lastY += dy;
+        this.touch();
+        this.panBy(-dx, -dy);
+    }
+    /**
+     * The press let go. A release within the drag threshold of a marker press
+     * is that marker's click, then the map's; one that ended no drag is the
+     * map's click. And the second release of a double click zooms in about the
+     * pointer, Shift for out — the convention every map client has.
+     */
+    pointerUp(input) {
+        const gesture = this._gesture;
+        this._gesture = null;
+        if (!gesture)
+            return;
+        if (gesture.kind === 'marker') {
+            const marker = this._markers().find((m) => m.id === gesture.id);
+            if (marker &&
+                Math.abs(input.x - gesture.startX) < DRAG_THRESHOLD &&
+                Math.abs(input.y - gesture.startY) < DRAG_THRESHOLD) {
+                const event = this.pointerEvent(input, marker);
+                this._props.onMarkerClick?.(marker, event);
+                this._props.onMapClick?.(event);
+            }
+            return;
+        }
+        if (gesture.moved) {
+            this.touch();
+            return;
+        }
+        this._props.onMapClick?.(this.pointerEvent(input, null));
+        if (input.detail === 2 && this._interactive()) {
+            this.zoomAbout(input.shiftKey ? -1 : 1, input.x, input.y);
+        }
+    }
+    /** The pointer moved with nothing pressed: the marker under it, if that
+     *  changed, is `onMarkerHover`'s. */
+    pointerMove(input) {
+        const notify = this._props.onMarkerHover;
+        if (!notify)
+            return;
+        const marker = markerAt(this._markers(), this.transform(), input.x, input.y);
+        const id = marker?.id ?? null;
+        if (id === this._hover)
+            return;
+        this._hover = id;
+        notify(marker, this.pointerEvent(input, marker));
+    }
+    /**
+     * The pointer left the map. No event: there is no position on the map to
+     * report, and inventing one would be worse than saying so.
+     */
+    pointerLeave() {
+        if (this._hover === null)
+            return;
+        this._hover = null;
+        this._props.onMarkerHover?.(null, null);
+    }
+    /**
+     * The wheel, which is a zoom about the pointer. True when it was consumed
+     * — always, on a map that moves: a wheel over a map is never meant for
+     * whatever is behind it.
+     */
+    wheel(input, deltaY, smooth = false) {
+        if (!this._interactive())
+            return false;
+        this.touch();
+        this._wheelZoom(-deltaY * WHEEL_ZOOM * 0.02, input.x, input.y, smooth);
+        return true;
+    }
+    /** A key: the arrows pan, +/− zoom about the centre. True when it was one
+     *  of those, on a map that moves. */
+    keyDown(keysym, shiftKey) {
+        if (!this._interactive())
+            return false;
+        const pane = this.pane();
+        const step = shiftKey ? 200 : 60;
+        switch (keysym) {
+            case 0xff51: // XK_Left
+                this.panBy(-step, 0);
+                return true;
+            case 0xff53: // XK_Right
+                this.panBy(step, 0);
+                return true;
+            case 0xff52: // XK_Up
+                this.panBy(0, -step);
+                return true;
+            case 0xff54: // XK_Down
+                this.panBy(0, step);
+                return true;
+            case 0x002b: // XK_plus
+            case 0x003d: // XK_equal
+            case 0xffab: // XK_KP_Add
+                this.zoomAbout(1, pane.width / 2, pane.height / 2);
+                return true;
+            case 0x002d: // XK_minus
+            case 0xffad: // XK_KP_Subtract
+                this.zoomAbout(-1, pane.width / 2, pane.height / 2);
+                return true;
+            default:
+                return false;
+        }
+    }
+    /** Where a pointer event happened, in every space that could be wanted. */
+    pointerEvent(input, marker) {
+        return {
+            lngLat: unprojectPoint(this.transform(), input.x, input.y),
+            x: input.x,
+            y: input.y,
+            marker,
+            shiftKey: input.shiftKey ?? false,
+            ctrlKey: input.ctrlKey ?? false,
+            altKey: input.altKey ?? false,
+            metaKey: input.metaKey ?? false,
+            button: input.button ?? 1,
+        };
+    }
+    /**
+     * What a screen reader meets: the markers in view, as buttons.
+     *
+     * A map is one painted rectangle to an assistive technology, and its
+     * markers are the only things in it that are *objects* rather than
+     * cartography — so those are the scene. Announcing every road would be
+     * worse than announcing none. The same whichever renderer draws.
+     */
+    markerScene() {
+        const pane = this.pane();
+        if (pane.width <= 0 || pane.height <= 0)
+            return [];
+        const transform = this.transform();
+        const scale = this._view?.scale() ?? 1;
+        const items = [];
+        for (const marker of this._markers()) {
+            const rect = markerRect(marker, transform);
+            if (rect.x + rect.width < 0 ||
+                rect.y + rect.height < 0 ||
+                rect.x > pane.width ||
+                rect.y > pane.height) {
+                continue;
+            }
+            items.push({
+                id: `marker:${marker.id}`,
+                // Device pixels in the owning window's coordinates, which is what
+                // an a11y scene rect is — the same space as `abs`.
+                rect: {
+                    x: (pane.x + rect.x) * scale,
+                    y: (pane.y + rect.y) * scale,
+                    width: rect.width * scale,
+                    height: rect.height * scale,
+                },
+                role: 'button',
+                name: marker.title ??
+                    `${marker.position.lat.toFixed(4)}, ${marker.position.lon.toFixed(4)}`,
+                states: { selected: marker.selected ?? false },
+            });
+        }
+        return items;
+    }
+}
+//# sourceMappingURL=controller.js.map