maplibre-gl 2.3.0 → 2.4.0

package/src/symbol/path_interpolator.ts

@@ -1,6 +1,5 @@
 import {clamp} from '../util/util';
 import Point from '@mapbox/point-geometry';
-import assert from 'assert';
 
 class PathInterpolator {
     points: Array<Point>;
@@ -30,7 +29,6 @@ class PathInterpolator {
     }
 
     lerp(t: number): Point {
-        assert(this.points.length > 0);
         if (this.points.length === 1) {
             return this.points[0];
         }

package/src/symbol/placement.ts

@@ -6,7 +6,6 @@ import * as projection from './projection';
 import {getAnchorJustification, evaluateVariableOffset} from './symbol_layout';
 import {getAnchorAlignment, WritingMode} from './shaping';
 import {mat4} from 'gl-matrix';
-import assert from 'assert';
 import pixelsToTileUnits from '../source/pixels_to_tile_units';
 import Point from '@mapbox/point-geometry';
 import type Transform from '../geo/transform';
@@ -23,6 +22,7 @@ import type FeatureIndex from '../data/feature_index';
 import type {OverscaledTileID} from '../source/tile_id';
 import type {TextAnchor} from './symbol_layout';
 import Terrain from '../render/terrain';
+import {warnOnce} from '../util/util';
 
 class OpacityState {
     opacity: number;
@@ -391,7 +391,7 @@ export class Placement {
                 this.prevPlacement.placements[symbolInstance.crossTileID].text) {
                 prevAnchor = this.prevPlacement.variableOffsets[symbolInstance.crossTileID].anchor;
             }
-            assert(symbolInstance.crossTileID !== 0);
+            if (symbolInstance.crossTileID === 0) throw new Error('symbolInstance.crossTileID can\'t be 0');
             this.variableOffsets[symbolInstance.crossTileID] = {
                 textOffset,
                 width,
@@ -676,7 +676,10 @@ export class Placement {
                     getElevation
                 );
 
-                assert(!placedGlyphCircles.circles.length || (!placedGlyphCircles.collisionDetected || showCollisionBoxes));
+                if (placedGlyphCircles.circles.length && placedGlyphCircles.collisionDetected && !showCollisionBoxes) {
+                    warnOnce('Collisions detected, but collision boxes are not shown');
+                }
+
                 // If text-overlap is set to 'always', force "placedCircles" to true
                 // In theory there should always be at least one circle placed
                 // in this case, but for now quirks in text-anchor
@@ -781,15 +784,15 @@ export class Placement {
                 }
             }
 
-            assert(symbolInstance.crossTileID !== 0);
-            assert(bucket.bucketInstanceId !== 0);
+            if (symbolInstance.crossTileID === 0) throw new Error('symbolInstance.crossTileID can\'t be 0');
+            if (bucket.bucketInstanceId === 0) throw new Error('bucket.bucketInstanceId can\'t be 0');
 
             this.placements[symbolInstance.crossTileID] = new JointPlacement(placeText || alwaysShowText, placeIcon || alwaysShowIcon, offscreen || bucket.justReloaded);
             seenCrossTileIDs[symbolInstance.crossTileID] = true;
         };
 
         if (zOrderByViewportY) {
-            assert(bucketPart.symbolInstanceStart === 0);
+            if (bucketPart.symbolInstanceStart !== 0) throw new Error('bucket.bucketInstanceId should be 0');
             const symbolIndexes = bucket.getSortedSymbolIndexes(this.transform.angle);
             for (let i = symbolIndexes.length - 1; i >= 0; --i) {
                 const symbolIndex = symbolIndexes[i];
@@ -920,7 +923,9 @@ export class Placement {
         // this.lastPlacementChangeTime is the time of the last commit() that
         // resulted in a placement change -- in other words, the start time of
         // the last symbol fade animation
-        assert(!prevPlacement || prevPlacement.lastPlacementChangeTime !== undefined);
+        if (prevPlacement && prevPlacement.lastPlacementChangeTime === undefined) {
+            throw new Error('Last placement time for previous placement is not defined');
+        }
         if (placementChanged) {
             this.lastPlacementChangeTime = now;
         } else if (typeof this.lastPlacementChangeTime !== 'number') {
@@ -1133,8 +1138,8 @@ export class Placement {
             bucket.textCollisionBox.collisionVertexBuffer.updateData(bucket.textCollisionBox.collisionVertexArray);
         }
 
-        assert(bucket.text.opacityVertexArray.length === bucket.text.layoutVertexArray.length / 4);
-        assert(bucket.icon.opacityVertexArray.length === bucket.icon.layoutVertexArray.length / 4);
+        if (bucket.text.opacityVertexArray.length !== bucket.text.layoutVertexArray.length / 4) throw new Error(`bucket.text.opacityVertexArray.length (= ${bucket.text.opacityVertexArray.length}) !== bucket.text.layoutVertexArray.length (= ${bucket.text.layoutVertexArray.length}) / 4`);
+        if (bucket.icon.opacityVertexArray.length !== bucket.icon.layoutVertexArray.length / 4) throw new Error(`bucket.icon.opacityVertexArray.length (= ${bucket.icon.opacityVertexArray.length}) !== bucket.icon.layoutVertexArray.length (= ${bucket.icon.layoutVertexArray.length}) / 4`);
 
         // Push generated collision circles to the bucket for debug rendering
         if (bucket.bucketInstanceId in this.collisionCircleArrays) {

package/src/symbol/shaping.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import {
     charHasUprightVerticalOrientation,
     charAllowsIdeographicBreaking,
@@ -811,9 +810,6 @@ function fitIconToText(
     iconOffset: [number, number],
     fontScale: number
 ): PositionedIcon {
-    assert(textFit !== 'none');
-    assert(Array.isArray(padding) && padding.length === 4);
-    assert(Array.isArray(iconOffset) && iconOffset.length === 2);
 
     const image = shapedIcon.image;
 

package/src/ui/camera.test.ts

@@ -1,9 +1,10 @@
-import Camera from '../ui/camera';
+import Camera, {CameraOptions} from '../ui/camera';
 import Transform from '../geo/transform';
 import TaskQueue, {TaskID} from '../util/task_queue';
 import browser from '../util/browser';
 import {fixedLngLat, fixedNum} from '../../test/unit/lib/fixed';
 import {setMatchMedia} from '../util/test/util';
+import {mercatorZfromAltitude} from '../geo/mercator_coordinate';
 
 beforeEach(() => {
     setMatchMedia();
@@ -55,6 +56,68 @@ function assertTransitionTime(done, camera, min, max) {
         });
 }
 
+describe('#calculateCameraOptionsFromTo', () => {
+    // Choose initial zoom to avoid center being constrained by mercator latitude limits.
+    const camera = createCamera({zoom: 1});
+
+    test('look at north', () => {
+        const cameraOptions: CameraOptions = camera.calculateCameraOptionsFromTo({lng: 1, lat: 0}, 0, {lng: 1, lat: 1});
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.center).toBeDefined();
+        expect(cameraOptions.bearing).toBeCloseTo(0);
+    });
+
+    test('look at west', () => {
+        const cameraOptions = camera.calculateCameraOptionsFromTo({lng: 1, lat: 0}, 0, {lng: 0, lat: 0});
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.bearing).toBeCloseTo(-90);
+    });
+
+    test('pitch 45', () => {
+        // altitude same as grounddistance => 45°
+        // distance between lng x and lng x+1 is 111.2km at same lat
+        const cameraOptions: CameraOptions = camera.calculateCameraOptionsFromTo({lng: 1, lat: 0}, 111200, {lng: 0, lat: 0});
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.pitch).toBeCloseTo(45);
+    });
+
+    test('pitch 90', () => {
+        const cameraOptions = camera.calculateCameraOptionsFromTo({lng: 1, lat: 0}, 0, {lng: 0, lat: 0});
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.pitch).toBeCloseTo(90);
+    });
+
+    test('pitch 153.435', () => {
+
+        // distance between lng x and lng x+1 is 111.2km at same lat
+        // (elevation difference of cam and center) / 2 = grounddistance =>
+        // acos(111.2 / sqrt(111.2² + (111.2 * 2)²)) = acos(1/sqrt(5)) => 63.435 + 90 (looking up) = 153.435
+        const cameraOptions: CameraOptions = camera.calculateCameraOptionsFromTo({lng: 1, lat: 0}, 111200, {lng: 0, lat: 0}, 111200 * 3);
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.pitch).toBeCloseTo(153.435);
+    });
+
+    test('zoom distance 1000', () => {
+        const expectedZoom = Math.log2(camera.transform.cameraToCenterDistance / mercatorZfromAltitude(1000, 0) / camera.transform.tileSize);
+        const cameraOptions = camera.calculateCameraOptionsFromTo({lng: 0, lat: 0}, 0, {lng: 0, lat: 0}, 1000);
+
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.zoom).toBeCloseTo(expectedZoom);
+    });
+
+    test('zoom distance 1 lng (111.2km), 111.2km altitude away', () => {
+        const expectedZoom = Math.log2(camera.transform.cameraToCenterDistance / mercatorZfromAltitude(Math.hypot(111200, 111200), 0) / camera.transform.tileSize);
+        const cameraOptions = camera.calculateCameraOptionsFromTo({lng: 0, lat: 0}, 0, {lng: 1, lat: 0}, 111200);
+
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.zoom).toBeCloseTo(expectedZoom);
+    });
+
+    test('same To as From error', () => {
+        expect(() => { camera.calculateCameraOptionsFromTo({lng: 0, lat: 0}, 0, {lng: 0, lat: 0}, 0); }).toThrow();
+    });
+});
+
 describe('#jumpTo', () => {
     // Choose initial zoom to avoid center being constrained by mercator latitude limits.
     const camera = createCamera({zoom: 1});

package/src/ui/camera.ts

@@ -5,7 +5,6 @@ import LngLat from '../geo/lng_lat';
 import LngLatBounds from '../geo/lng_lat_bounds';
 import Point from '@mapbox/point-geometry';
 import {Event, Evented} from '../util/evented';
-import assert from 'assert';
 import {Debug} from '../util/debug';
 
 import type Transform from '../geo/transform';
@@ -13,6 +12,7 @@ import type {LngLatLike} from '../geo/lng_lat';
 import type {LngLatBoundsLike} from '../geo/lng_lat_bounds';
 import type {TaskID} from '../util/task_queue';
 import type {PaddingOptions} from '../geo/edge_insets';
+import MercatorCoordinate from '../geo/mercator_coordinate';
 
 /**
  * A [Point](https://github.com/mapbox/point-geometry) or an array of two numbers representing `x` and `y` screen coordinates in pixels.
@@ -775,6 +775,41 @@ abstract class Camera extends Evented {
         return this.fire(new Event('moveend', eventData));
     }
 
+    /**
+     * Calculates pitch, zoom and bearing for looking at @param newCenter with the camera position being @param newCenter
+     * and returns them as Cameraoptions.
+     * @memberof Map#
+     * @param from The camera to look from
+     * @param altitudeFrom The altitude of the camera to look from
+     * @param to The center to look at
+     * @param altitudeTo Optional altitude of the center to look at. If none given the ground height will be used.
+     * @returns {CameraOptions} the calculated camera options
+     */
+    calculateCameraOptionsFromTo(from: LngLat, altitudeFrom: number, to: LngLat, altitudeTo: number = 0) : CameraOptions {
+        const fromMerc = MercatorCoordinate.fromLngLat(from, altitudeFrom);
+        const toMerc = MercatorCoordinate.fromLngLat(to, altitudeTo);
+        const dx = toMerc.x - fromMerc.x;
+        const dy = toMerc.y - fromMerc.y;
+        const dz = toMerc.z - fromMerc.z;
+
+        const distance3D = Math.hypot(dx, dy, dz);
+        if (distance3D === 0) throw new Error('Can\'t calculate camera options with same From and To');
+
+        const groundDistance = Math.hypot(dx, dy);
+
+        const zoom = this.transform.scaleZoom(this.transform.cameraToCenterDistance / distance3D / this.transform.tileSize);
+        const bearing = (Math.atan2(dx, -dy) * 180) / Math.PI;
+        let pitch = (Math.acos(groundDistance / distance3D) * 180) / Math.PI;
+        pitch = dz < 0 ? 90 - pitch : 90 + pitch;
+
+        return {
+            center: toMerc.toLngLat(),
+            zoom,
+            pitch,
+            bearing
+        };
+    }
+
     /**
      * Changes any combination of `center`, `zoom`, `bearing`, `pitch`, and `padding` with an animated transition
      * between old and new values. The map will retain its current values for any
@@ -1273,19 +1308,10 @@ function addAssertions(camera: Camera) { //eslint-disable-line
             inProgress[name] = false;
 
             camera.on(`${name}start`, () => {
-                assert(!inProgress[name], `"${name}start" fired twice without a "${name}end"`);
                 inProgress[name] = true;
-                assert(inProgress.move);
-            });
-
-            camera.on(name, () => {
-                assert(inProgress[name]);
-                assert(inProgress.move);
             });
 
             camera.on(`${name}end`, () => {
-                assert(inProgress.move);
-                assert(inProgress[name]);
                 inProgress[name] = false;
             });
         });

package/src/ui/control/attribution_control.test.ts

@@ -1,6 +1,7 @@
 import AttributionControl from './attribution_control';
 import {createMap as globalCreateMap, setWebGlContext, setPerformance, setMatchMedia} from '../../util/test/util';
 import simulate from '../../../test/unit/lib/simulate_interaction';
+import {fakeServer} from 'nise';
 
 function createMap() {
 
@@ -272,6 +273,67 @@ describe('AttributionControl', () => {
         });
     });
 
+    test('does not show attributions for sources that are used for terrain when they are not in use', done => {
+        global.fetch = null;
+        const server = fakeServer.create();
+        server.respondWith('/source.json', JSON.stringify({
+            minzoom: 5,
+            maxzoom: 12,
+            attribution: 'Terrain',
+            tiles: ['http://example.com/{z}/{x}/{y}.pngraw'],
+            bounds: [-47, -7, -45, -5]
+        }));
+
+        const attribution = new AttributionControl();
+        map.addControl(attribution);
+
+        map.on('load', () => {
+            map.addSource('1', {type: 'raster-dem', url: '/source.json'});
+            server.respond();
+        });
+
+        let times = 0;
+        map.on('data', (e) => {
+            if (e.dataType === 'source' && e.sourceDataType === 'visibility') {
+                if (++times === 1) {
+                    expect(attribution._innerContainer.innerHTML).toBe('');
+                    done();
+                }
+            }
+        });
+    });
+
+    test('shows attributions for sources that are used for terrain', done => {
+        global.fetch = null;
+        const server = fakeServer.create();
+        server.respondWith('/source.json', JSON.stringify({
+            minzoom: 5,
+            maxzoom: 12,
+            attribution: 'Terrain',
+            tiles: ['http://example.com/{z}/{x}/{y}.pngraw'],
+            bounds: [-47, -7, -45, -5]
+        }));
+
+        const attribution = new AttributionControl();
+        map.addControl(attribution);
+
+        map.on('load', () => {
+            map.addSource('1', {type: 'raster-dem', url: '/source.json'});
+            server.respond();
+            map.setTerrain({source: '1'});
+        });
+
+        let times = 0;
+        map.on('data', (e) => {
+            if (e.dataType === 'source' && e.sourceDataType === 'visibility') {
+                if (++times === 1) {
+                    expect(attribution._innerContainer.innerHTML).toBe('Terrain');
+                    done();
+                }
+            }
+        });
+    });
+
     test('toggles attributions for sources whose visibility changes when zooming', done => {
         const attribution = new AttributionControl();
         map.addControl(attribution);

package/src/ui/control/attribution_control.ts

@@ -63,6 +63,7 @@ class AttributionControl implements IControl {
 
         this._map.on('styledata', this._updateData);
         this._map.on('sourcedata', this._updateData);
+        this._map.on('terrain', this._updateData);
         this._map.on('resize', this._updateCompact);
         this._map.on('drag', this._updateCompactMinimize);
 
@@ -74,6 +75,7 @@ class AttributionControl implements IControl {
 
         this._map.off('styledata', this._updateData);
         this._map.off('sourcedata', this._updateData);
+        this._map.off('terrain', this._updateData);
         this._map.off('resize', this._updateCompact);
         this._map.off('drag', this._updateCompactMinimize);
 
@@ -101,7 +103,7 @@ class AttributionControl implements IControl {
     }
 
     _updateData(e: any) {
-        if (e && (e.sourceDataType === 'metadata' || e.sourceDataType === 'visibility' || e.dataType === 'style')) {
+        if (e && (e.sourceDataType === 'metadata' || e.sourceDataType === 'visibility' || e.dataType === 'style' || e.type === 'terrain')) {
             this._updateAttributions();
         }
     }
@@ -131,7 +133,7 @@ class AttributionControl implements IControl {
         const sourceCaches = this._map.style.sourceCaches;
         for (const id in sourceCaches) {
             const sourceCache = sourceCaches[id];
-            if (sourceCache.used) {
+            if (sourceCache.used || sourceCache.usedForTerrain) {
                 const source = sourceCache.getSource();
                 if (source.attribution && attributions.indexOf(source.attribution) < 0) {
                     attributions.push(source.attribution);

package/src/ui/control/geolocate_control.ts

@@ -1,7 +1,6 @@
 import {Event, Evented} from '../../util/evented';
 import DOM from '../../util/dom';
 import {extend, bindAll, warnOnce} from '../../util/util';
-import assert from 'assert';
 import LngLat from '../../geo/lng_lat';
 import Marker from '../marker';
 
@@ -195,7 +194,7 @@ class GeolocateControl extends Evented implements IControl {
             case 'ACTIVE_ERROR':
                 break;
             default:
-                assert(false, `Unexpected watchState ${this._watchState}`);
+                throw new Error(`Unexpected watchState ${this._watchState}`);
         }
     }
 
@@ -244,7 +243,7 @@ class GeolocateControl extends Evented implements IControl {
                     this._geolocateButton.classList.add('maplibregl-ctrl-geolocate-background', 'mapboxgl-ctrl-geolocate-background');
                     break;
                 default:
-                    assert(false, `Unexpected watchState ${this._watchState}`);
+                    throw new Error(`Unexpected watchState ${this._watchState}`);
             }
         }
 
@@ -306,7 +305,6 @@ class GeolocateControl extends Evented implements IControl {
     }
 
     _updateCircleRadius() {
-        assert(this._circleElement);
         const y = this._map._container.clientHeight / 2;
         const a = this._map.unproject([0, y]);
         const b = this._map.unproject([1, y]);
@@ -485,7 +483,7 @@ class GeolocateControl extends Evented implements IControl {
                     this.fire(new Event('trackuserlocationstart'));
                     break;
                 default:
-                    assert(false, `Unexpected watchState ${this._watchState}`);
+                    throw new Error(`Unexpected watchState ${this._watchState}`);
             }
 
             // incoming state setup
@@ -500,7 +498,7 @@ class GeolocateControl extends Evented implements IControl {
                 case 'OFF':
                     break;
                 default:
-                    assert(false, `Unexpected watchState ${this._watchState}`);
+                    throw new Error(`Unexpected watchState ${this._watchState}`);
             }
 
             // manage geolocation.watchPosition / geolocation.clearWatch

package/src/ui/control/terrain_control.test.ts

@@ -0,0 +1,60 @@
+import TerrainControl from './terrain_control';
+import {createMap as globalCreateMap, setWebGlContext, setPerformance, setMatchMedia} from '../../util/test/util';
+
+function createMap() {
+
+    return globalCreateMap({
+        attributionControl: false,
+        style: {
+            version: 8,
+            sources: {
+                terrain: {
+                    minzoom: 5,
+                    maxzoom: 12,
+                    attribution: 'MapLibre',
+                    tiles: ['http://example.com/{z}/{x}/{y}.pngraw'],
+                    bounds: [-47, -7, -45, -5]
+                },
+            },
+            layers: [],
+            owner: 'mapblibre',
+            id: 'demotiles',
+        },
+        hash: true
+    }, undefined);
+}
+
+let map;
+
+beforeEach(() => {
+    setWebGlContext();
+    setPerformance();
+    setMatchMedia();
+    map = createMap();
+});
+
+afterEach(() => {
+    map.remove();
+});
+
+describe('TerrainControl', () => {
+    test('appears in top-right by default', () => {
+        map.addControl(new TerrainControl({source: 'terrain'}));
+
+        expect(
+            map.getContainer().querySelectorAll('.maplibregl-ctrl-top-right .maplibregl-ctrl-terrain')
+        ).toHaveLength(1);
+    });
+
+    test('appears in the position specified by the position option', () => {
+        map.addControl(new TerrainControl({source: 'terrain'}), 'bottom-right');
+
+        expect(
+            map.getContainer().querySelectorAll('.maplibregl-ctrl-bottom-right .maplibregl-ctrl-terrain')
+        ).toHaveLength(1);
+
+        expect(
+            map.getContainer().querySelectorAll('.maplibregl-ctrl-top-right .maplibregl-ctrl-terrain')
+        ).toHaveLength(0);
+    });
+});

package/src/ui/handler/handler_util.ts

@@ -1,8 +1,7 @@
-import assert from 'assert';
 import Point from '@mapbox/point-geometry';
 
 export function indexTouches(touches: Array<Touch>, points: Array<Point>) {
-    assert(touches.length === points.length);
+    if (touches.length !== points.length) throw new Error(`The number of touches and points are not equal - touches ${touches.length}, points ${points.length}`);
     const obj = {};
     for (let i = 0; i < touches.length; i++) {
         obj[touches[i].identifier] = points[i];

package/src/ui/handler/map_event.test.ts

@@ -4,7 +4,7 @@ import simulate from '../../../test/unit/lib/simulate_interaction';
 import {setMatchMedia, setPerformance, setWebGlContext} from '../../util/test/util';
 
 function createMap() {
-    return new Map({interactive: false, container: DOM.create('div', '', window.document.body)} as any as MapOptions);
+    return new Map({interactive: true, container: DOM.create('div', '', window.document.body)} as any as MapOptions);
 }
 
 beforeEach(() => {
@@ -93,4 +93,68 @@ describe('map events', () => {
 
         map.remove();
     });
+
+    test('MapEvent handler fires contextmenu on MacOS/Linux, but only at mouseup', () => {
+        const map = createMap();
+        const target = map.getCanvas();
+        map.dragPan.enable();
+
+        const contextmenu = jest.fn();
+
+        map.on('contextmenu', contextmenu);
+
+        simulate.mousedown(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10});
+        simulate.contextmenu(map.getCanvas(), {target}); // triggered immediately after mousedown
+        expect(contextmenu).toHaveBeenCalledTimes(0);
+        simulate.mouseup(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10});
+        expect(contextmenu).toHaveBeenCalledTimes(1);
+    });
+
+    test('MapEvent handler does not fire contextmenu on MacOS/Linux, when moved', () => {
+        const map = createMap();
+        const target = map.getCanvas();
+        map.dragPan.enable();
+
+        const contextmenu = jest.fn();
+
+        map.on('contextmenu', contextmenu);
+
+        simulate.mousedown(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10});
+        simulate.contextmenu(map.getCanvas(), {target}); // triggered immediately after mousedown
+        simulate.mousemove(map.getCanvas(), {target, buttons: 2, clientX: 50, clientY: 10});
+        simulate.mouseup(map.getCanvas(), {target, button: 2, clientX: 70, clientY: 10});
+        expect(contextmenu).toHaveBeenCalledTimes(0);
+    });
+
+    test('MapEvent handler fires contextmenu on Windows', () => {
+        const map = createMap();
+        const target = map.getCanvas();
+        map.dragPan.enable();
+
+        const contextmenu = jest.fn();
+
+        map.on('contextmenu', contextmenu);
+
+        simulate.mousedown(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10});
+        simulate.mouseup(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10});
+        expect(contextmenu).toHaveBeenCalledTimes(0);
+        simulate.contextmenu(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10}); // triggered only after mouseup
+        expect(contextmenu).toHaveBeenCalledTimes(1);
+    });
+
+    test('MapEvent handler does not fire contextmenu on Windows, when moved', () => {
+        const map = createMap();
+        const target = map.getCanvas();
+        map.dragPan.enable();
+
+        const contextmenu = jest.fn();
+
+        map.on('contextmenu', contextmenu);
+
+        simulate.mousedown(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10});
+        simulate.mousemove(map.getCanvas(), {target, buttons: 2, clientX: 50, clientY: 10});
+        simulate.mouseup(map.getCanvas(), {target, button: 2, clientX: 50, clientY: 10});
+        simulate.contextmenu(map.getCanvas(), {target, button: 2, clientX: 10, clientY: 10}); // triggered only after mouseup
+        expect(contextmenu).toHaveBeenCalledTimes(0);
+    });
 });

package/src/ui/handler/map_event.ts

@@ -104,6 +104,7 @@ export class MapEventHandler implements Handler {
 export class BlockableMapEventHandler {
     _map: Map;
     _delayContextMenu: boolean;
+    _ignoreContextMenu: boolean;
     _contextMenuEvent: MouseEvent;
 
     constructor(map: Map) {
@@ -112,6 +113,7 @@ export class BlockableMapEventHandler {
 
     reset() {
         this._delayContextMenu = false;
+        this._ignoreContextMenu = true;
         delete this._contextMenuEvent;
     }
 
@@ -122,6 +124,7 @@ export class BlockableMapEventHandler {
 
     mousedown() {
         this._delayContextMenu = true;
+        this._ignoreContextMenu = false;
     }
 
     mouseup() {
@@ -135,7 +138,7 @@ export class BlockableMapEventHandler {
         if (this._delayContextMenu) {
             // Mac: contextmenu fired on mousedown; we save it until mouseup for consistency's sake
             this._contextMenuEvent = e;
-        } else {
+        } else if (!this._ignoreContextMenu) {
             // Windows: contextmenu fired on mouseup, so fire event now
             this._map.fire(new MapMouseEvent(e.type, this._map, e));
         }

package/src/ui/handler/scroll_zoom.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import DOM from '../../util/dom';
 
 import {ease as _ease, bindAll, bezier} from '../../util/util';
@@ -282,7 +281,6 @@ class ScrollZoomHandler {
         let finished = false;
         let zoom;
         if (this._type === 'wheel' && startZoom && easing) {
-            assert(easing && typeof startZoom === 'number');
 
             const t = Math.min((browser.now() - this._lastWheelEventTime) / 200, 1);
             const k = easing(t);

package/src/ui/handler_manager.ts

@@ -19,7 +19,6 @@ import TouchZoomRotateHandler from './handler/shim/touch_zoom_rotate';
 import {bindAll, extend} from '../util/util';
 import Point from '@mapbox/point-geometry';
 import LngLat from '../geo/lng_lat';
-import assert from 'assert';
 
 export type InputEvent = MouseEvent | TouchEvent | KeyboardEvent | WheelEvent;
 
@@ -299,7 +298,6 @@ class HandlerManager {
         }
 
         this._updatingCamera = true;
-        assert(e.timeStamp !== undefined);
 
         const inputEvent = e.type === 'renderFrame' ? undefined : (e as any as InputEvent);