maplibre-gl 6.0.0 → 6.2.0

package/src/ui/map_tests/map_options.test.ts

@@ -49,11 +49,7 @@ describe('mapOptions', () => {
         let idleTriggered = false;
         const fadeDuration = 100;
         const spy = vi.spyOn(Style.prototype, 'update').mockImplementation((parameters: EvaluationParameters) => {
-            if (!idleTriggered) {
-                expect(parameters.fadeDuration).toBe(0);
-            } else {
-                expect(parameters.fadeDuration).toBe(fadeDuration);
-            }
+            expect(parameters.fadeDuration).toBe(idleTriggered ? fadeDuration : 0);
         });
         const style = createStyle();
         const map = createMap({style, fadeDuration});

package/src/ui/map_tests/map_pitch.test.ts

@@ -31,7 +31,7 @@ test('ignore minPitchs over maxPitch', () => {
     const map = createMap({pitch: 0, maxPitch: 10});
     expect(() => {
         map.setMinPitch(20);
-    }).toThrow();
+    }).toThrow('minPitch must be between 0 and the current maxPitch, inclusive');
     map.setPitch(0);
     expect(map.getPitch()).toBe(0);
 });
@@ -89,7 +89,7 @@ test('ignore maxPitchs over minPitch', () => {
     const map = createMap({minPitch: 10});
     expect(() => {
         map.setMaxPitch(0);
-    }).toThrow();
+    }).toThrow('maxPitch must be greater than the current minPitch');
     map.setPitch(10);
     expect(map.getPitch()).toBe(10);
 });
@@ -140,8 +140,8 @@ test('fire move and pitch events when pitch is changed due to minPitch change',
     map.on('pitch', handleEvent);
     map.on('pitchend', handleEvent);
     map.setMinPitch(11);
-    expect(map.getPitch()).toEqual(11);
-    expect(map.getMinPitch()).toEqual(11);
+    expect(map.getPitch()).toBe(11);
+    expect(map.getMinPitch()).toBe(11);
     expect(handleEvent).toHaveBeenCalledTimes(6);
 });
 
@@ -155,7 +155,7 @@ test('fire move and pitch events when pitch is changed due to maxPitch change',
     map.on('pitch', handleEvent);
     map.on('pitchend', handleEvent);
     map.setMaxPitch(10);
-    expect(map.getPitch()).toEqual(10);
-    expect(map.getMaxPitch()).toEqual(10);
+    expect(map.getPitch()).toBe(10);
+    expect(map.getMaxPitch()).toBe(10);
     expect(handleEvent).toHaveBeenCalledTimes(6);
 });

package/src/ui/map_tests/map_refresh_tiles.test.ts

@@ -30,7 +30,7 @@ describe('Map::refreshTiles', () => {
         map.style.tileManagers['source-id1'].refreshTiles = spy;
 
         map.refreshTiles('source-id1', [{x: 1024, y: 1023, z: 11}]);
-        expect(spy).toHaveBeenCalledOnce();
+        expect(spy).toHaveBeenCalledTimes(1);
         expect(spy.mock.calls[0][0]).toEqual([new CanonicalTileID(11, 1024, 1023)]);
     });
 
@@ -43,7 +43,7 @@ describe('Map::refreshTiles', () => {
         map.style.tileManagers['source-id1'].reload = spy;
 
         map.refreshTiles('source-id1');
-        expect(spy).toHaveBeenCalledOnce();
+        expect(spy).toHaveBeenCalledTimes(1);
         expect(spy.mock.calls[0][0]).toBe(true);
     });
 });

package/src/ui/map_tests/map_render.test.ts

@@ -87,5 +87,5 @@ test('redraw', async () => {
     const renderPromise = map.once('render');
 
     map.redraw();
-    await renderPromise;
+    await expect(renderPromise).resolves.toBeDefined();
 });

package/src/ui/map_tests/map_set_lod_params.test.ts

@@ -42,7 +42,7 @@ test('set tile LOD params for a non-existent source', async () => {
 
     expect(map.getSource('source-id1').calculateTileZoom).toBeUndefined();
     expect(map.getSource('source-id2').calculateTileZoom).toBeUndefined();
-    expect(() => {map.setSourceTileLodParams(1, 1, 'non-existent-source-id');}).toThrowError();
+    expect(() => {map.setSourceTileLodParams(1, 1, 'non-existent-source-id');}).toThrow('There is no source with ID "non-existent-source-id", cannot set LOD parameters');
     expect(map.getSource('source-id1').calculateTileZoom).toBeUndefined();
     expect(map.getSource('source-id2').calculateTileZoom).toBeUndefined();
 });

package/src/ui/map_tests/map_style.test.ts

@@ -78,12 +78,14 @@ describe('setStyle', () => {
         ]);
     });
 
-    test('can be called more than once', () => {
+    test('can be called more than once', async () => {
         const map = createMap();
 
         map.setStyle({version: 8, sources: {}, layers: []}, {diff: false});
         map.setStyle({version: 8, sources: {}, layers: []}, {diff: false});
+        await map.once('style.load');
 
+        expect(map.getStyle()).toEqual({version: 8, sources: {}, layers: []});
     });
 
     test('setStyle back to the first style should work', async () => {
@@ -477,12 +479,16 @@ describe('getStyle', () => {
             type: 'background'
         } as LayerSpecification;
         map.addLayer(layer);
+
+        expect(map.getLayer('background')).toBeDefined();
     });
 
     test('a source can be added even if a map is created without a style', () => {
         const map = createMap({deleteStyle: true});
         const source = createStyleSource();
         map.addSource('fill', source);
+
+        expect(map.getSource('fill')).toBeDefined();
     });
 
     test('a layer can be added with an embedded source specification', () => {
@@ -496,6 +502,8 @@ describe('getStyle', () => {
             type: 'symbol',
             source
         });
+
+        expect(map.getLayer('foo')).toBeDefined();
     });
 
     test('returns the style with added source and layer', async () => {

package/src/ui/map_tests/map_terrain.test.ts

@@ -1,9 +1,10 @@
 import {describe, beforeEach, afterEach, test, expect, vi} from 'vitest';
-import {createMap, beforeMapTest} from '../../util/test/util.ts';
+import {createMap, beforeMapTest, waitForEvent} from '../../util/test/util.ts';
 import {LngLat} from '../../geo/lng_lat.ts';
 import {fakeServer, type FakeServer} from 'nise';
 import {type Terrain} from '../../render/terrain.ts';
 import {MercatorTransform} from '../../geo/projection/mercator_transform.ts';
+import {AttributionControl, defaultAttributionControlOptions} from '../control/attribution_control.ts';
 import {type Map} from '../map.ts';
 
 let server: FakeServer;
@@ -67,6 +68,45 @@ describe('setTerrain', () => {
         expect(errorSpy).not.toHaveBeenCalled();
         expect(map.getTerrain()).toEqual({source: 'dem', exaggeration: 2});
     });
+
+    test('drops the previous source attribution when switching terrain to a new source', async () => {
+        const attribution = new AttributionControl();
+        map.addControl(attribution);
+        await map.once('style.load');
+        const demALoaded = waitForEvent(map, 'sourcedata', (e) => e.sourceId === 'dem-a' && e.sourceDataType === 'metadata');
+        const demBLoaded = waitForEvent(map, 'sourcedata', (e) => e.sourceId === 'dem-b' && e.sourceDataType === 'metadata');
+        map.addSource('dem-a', {type: 'raster-dem', tiles: ['http://example.com/{z}/{x}/{y}.png'], tileSize: 256, attribution: 'DEM A'});
+        map.addSource('dem-b', {type: 'raster-dem', tiles: ['http://example.com/{z}/{x}/{y}.png'], tileSize: 256, attribution: 'DEM B'});
+        await Promise.all([demALoaded, demBLoaded]);
+
+        map.setTerrain({source: 'dem-a'});
+        const terrainEvent = map.once('terrain');
+        map.setTerrain({source: 'dem-b'});
+        await terrainEvent;
+
+        const innerContainer = map.getContainer().querySelector('.maplibregl-ctrl-attrib-inner');
+        expect(innerContainer.innerHTML).toBe(`DEM B | ${defaultAttributionControlOptions.customAttribution}`);
+    });
+
+    test('invalidates cached elevation when terrain source data changes without a tile', async () => {
+        await map.once('load');
+        map.addSource('terrainrgb', {
+            type: 'raster-dem',
+            tiles: ['http://example.com/{z}/{x}/{y}.png']
+        });
+        map.setTerrain({source: 'terrainrgb'});
+        if (!map.terrain) throw new Error('Expected terrain to be set');
+        const resetElevationCache = vi.spyOn(map.terrain, 'resetElevationCache');
+
+        map._terrainDataCallback({
+            dataType: 'source',
+            sourceId: 'terrainrgb',
+            sourceDataType: 'content',
+            source: {type: 'raster-dem'}
+        } as any);
+
+        expect(resetElevationCache).toHaveBeenCalledTimes(1);
+    });
 });
 
 describe('getTerrain', () => {

package/src/ui/map_tests/map_zoom.test.ts

@@ -32,7 +32,7 @@ test('ignore minZooms over maxZoom', () => {
     const map = createMap({zoom: 2, maxZoom: 5});
     expect(() => {
         map.setMinZoom(6);
-    }).toThrow();
+    }).toThrow('minZoom must be between -2 and the current maxZoom, inclusive');
     map.setZoom(0);
     expect(map.getZoom()).toBe(0);
 });
@@ -62,7 +62,7 @@ test('ignore maxZooms over minZoom', () => {
     const map = createMap({minZoom: 5});
     expect(() => {
         map.setMaxZoom(4);
-    }).toThrow();
+    }).toThrow('maxZoom must be greater than the current minZoom');
     map.setZoom(5);
     expect(map.getZoom()).toBe(5);
 });
@@ -102,16 +102,16 @@ test('transformCameraUpdate is called after changing min or max zoom', async ()
     map.setMaxZoom(18);
     map.setZoom(18);
     await map.once('style.load');
-    expect(map.getZoom()).toEqual(18);
-    expect(map.getMinZoom()).toEqual(5);
-    expect(map.getMaxZoom()).toEqual(18);
+    expect(map.getZoom()).toBe(18);
+    expect(map.getMinZoom()).toBe(5);
+    expect(map.getMaxZoom()).toBe(18);
     const transformCameraUpdate = vi.fn(t => t);
     map.setTransformCameraUpdate(transformCameraUpdate);
 
     map.setMaxZoom(16);
-    expect(map.getZoom()).toEqual(16);
-    expect(map.getMinZoom()).toEqual(5);
-    expect(map.getMaxZoom()).toEqual(16);
+    expect(map.getZoom()).toBe(16);
+    expect(map.getMinZoom()).toBe(5);
+    expect(map.getMaxZoom()).toBe(16);
     expect(transformCameraUpdate.mock.calls[0][0]).toMatchObject({
         zoom: 16,
         minZoom: 5,
@@ -127,9 +127,9 @@ test('transformCameraUpdate is called after changing min or max zoom', async ()
 
     map.setMinZoom(6);
     map.setTransformCameraUpdate(transformCameraUpdate);
-    expect(map.getZoom()).toEqual(6);
-    expect(map.getMinZoom()).toEqual(6);
-    expect(map.getMaxZoom()).toEqual(16);
+    expect(map.getZoom()).toBe(6);
+    expect(map.getMinZoom()).toBe(6);
+    expect(map.getMaxZoom()).toBe(16);
     expect(transformCameraUpdate.mock.calls[2][0]).toMatchObject({
         zoom: 6,
         minZoom: 6,
@@ -147,8 +147,8 @@ test('fire move and zoom events when zoom is changed due to minZoom change', ()
     map.on('zoom', handleEvent);
     map.on('zoomend', handleEvent);
     map.setMinZoom(11);
-    expect(map.getZoom()).toEqual(11);
-    expect(map.getMinZoom()).toEqual(11);
+    expect(map.getZoom()).toBe(11);
+    expect(map.getMinZoom()).toBe(11);
     expect(handleEvent).toHaveBeenCalledTimes(6);
 });
 
@@ -162,7 +162,7 @@ test('fire move and zoom events when zoom is changed due to maxZoom change', ()
     map.on('zoom', handleEvent);
     map.on('zoomend', handleEvent);
     map.setMaxZoom(10);
-    expect(map.getZoom()).toEqual(10);
-    expect(map.getMaxZoom()).toEqual(10);
+    expect(map.getZoom()).toBe(10);
+    expect(map.getMaxZoom()).toBe(10);
     expect(handleEvent).toHaveBeenCalledTimes(6);
 });

package/src/ui/marker.test.ts

@@ -35,7 +35,7 @@ describe('marker', () => {
 
     test('Marker uses a default marker element with custom color', () => {
         const marker = new Marker({color: '#123456'});
-        expect(marker.getElement().innerHTML.includes('#123456')).toBeTruthy();
+        expect(marker.getElement().innerHTML).toContain('#123456');
     });
 
     test('Marker uses a default marker element with custom scale', () => {
@@ -53,22 +53,16 @@ describe('marker', () => {
             .addTo(map);
 
         // initial dimensions of svg element
-        expect(
-            defaultMarker.getElement().children[0].getAttribute('height').includes('41')
-        ).toBeTruthy();
-        expect(defaultMarker.getElement().children[0].getAttribute('width').includes('27')).toBeTruthy();
+        expect(defaultMarker.getElement().children[0].getAttribute('height')).toContain('41');
+        expect(defaultMarker.getElement().children[0].getAttribute('width')).toContain('27');
 
         // (41 * 0.8) = 32.8, (27 * 0.8) = 21.6
-        expect(
-            smallerMarker.getElement().children[0].getAttribute('height').includes('32.8')
-        ).toBeTruthy();
-        expect(
-            smallerMarker.getElement().children[0].getAttribute('width').includes('21.6')
-        ).toBeTruthy();
+        expect(smallerMarker.getElement().children[0].getAttribute('height')).toContain('32.8');
+        expect(smallerMarker.getElement().children[0].getAttribute('width')).toContain('21.6');
 
         // (41 * 2) = 82, (27 * 2) = 54
-        expect(largerMarker.getElement().children[0].getAttribute('height').includes('82')).toBeTruthy();
-        expect(largerMarker.getElement().children[0].getAttribute('width').includes('54')).toBeTruthy();
+        expect(largerMarker.getElement().children[0].getAttribute('height')).toContain('82');
+        expect(largerMarker.getElement().children[0].getAttribute('width')).toContain('54');
 
     });
 
@@ -290,11 +284,57 @@ describe('marker', () => {
         expect(markerWithHtmlElement.getElement().getAttribute('aria-label')).toBe('custom aria label');
     });
 
-    test('Marker should have a role attribute to satisfy accessibility requirements for the aria-label', () => {
+    test('default non-interactive Marker uses role=img for the aria-label', () => {
         const map = createMap({locale: {'Marker.Title': 'alt title'}});
         const marker = new Marker().setLngLat([0, 0]).addTo(map);
 
+        expect(marker.getElement().getAttribute('role')).toBe('img');
+        map.remove();
+    });
+
+    test('default Marker uses role=button when interactive via popup', () => {
+        const map = createMap();
+        const marker = new Marker()
+            .setLngLat([0, 0])
+            .setPopup(new Popup().setText('popup'))
+            .addTo(map);
+
         expect(marker.getElement().getAttribute('role')).toBe('button');
+
+        marker.setPopup();
+        expect(marker.getElement().getAttribute('role')).toBe('img');
+        map.remove();
+    });
+
+    test('default Marker uses role=button when draggable', () => {
+        const map = createMap();
+        const marker = new Marker({draggable: true}).setLngLat([0, 0]).addTo(map);
+
+        expect(marker.getElement().getAttribute('role')).toBe('button');
+
+        marker.setDraggable(false);
+        expect(marker.getElement().getAttribute('role')).toBe('img');
+        map.remove();
+    });
+
+    test('custom Marker element does not get automatic accessibility attributes', () => {
+        const map = createMap();
+        const element = document.createElement('div');
+        const marker = new Marker({element}).setLngLat([0, 0]).addTo(map);
+
+        expect(marker.getElement().hasAttribute('aria-label')).toBe(false);
+        expect(marker.getElement().hasAttribute('role')).toBe(false);
+        map.remove();
+    });
+
+    test('explicit role on the default Marker element is preserved', () => {
+        const map = createMap();
+        const marker = new Marker().setLngLat([0, 0]);
+        marker.getElement().setAttribute('role', 'presentation');
+        marker.addTo(map);
+
+        expect(marker.getElement().getAttribute('role')).toBe('presentation');
+        map.remove();
     });
 
     test('Marker anchor defaults to center', () => {
@@ -491,6 +531,23 @@ describe('marker', () => {
         map.remove();
     });
 
+    test('Marker.setDraggable toggles the draggable cursor class', () => {
+        const map = createMap();
+        const marker = new Marker({draggable: true})
+            .setLngLat([0, 0])
+            .addTo(map);
+
+        expect(marker.getElement().classList).toContain('maplibregl-marker-draggable');
+
+        marker.setDraggable(false);
+        expect(marker.getElement().classList).not.toContain('maplibregl-marker-draggable');
+
+        marker.setDraggable(true);
+        expect(marker.getElement().classList).toContain('maplibregl-marker-draggable');
+
+        map.remove();
+    });
+
     test('Marker with draggable:true fires dragstart, drag, and dragend events at appropriate times in response to mouse-triggered drag with map-inherited clickTolerance', () => {
         const map = createMap();
         const marker = new Marker({draggable: true})

package/src/ui/marker.ts

@@ -227,6 +227,7 @@ export class Marker extends Evented<MarkerEventType> {
     _opacityWhenCovered: string;
     _opacityTimeout: ReturnType<typeof setTimeout>;
     _subpixelPositioning: boolean;
+    _roleManaged: boolean;
 
     /**
      * @param options - the options
@@ -241,6 +242,7 @@ export class Marker extends Evented<MarkerEventType> {
         this._clickTolerance = options?.clickTolerance || 0;
         this._subpixelPositioning = options?.subpixelPositioning || false;
         this._isDragging = false;
+        this._roleManaged = false;
         this._state = 'inactive';
         this._rotation = options?.rotation || 0;
         this._rotationAlignment = options?.rotationAlignment || 'auto';
@@ -393,15 +395,11 @@ export class Marker extends Evented<MarkerEventType> {
         this.remove();
         this._map = map;
 
-        if (!this._element.hasAttribute('aria-label')) {
+        if (this._defaultMarker && !this._element.hasAttribute('aria-label')) {
             this._element.setAttribute('aria-label', map._getUIString('Marker.Title'));
         }
 
-        // aria-label is set either by user or above default, so set role
-        // since div is interactive and cannot have aria-label without a role
-        if (!this._element.hasAttribute('role')) {
-            this._element.setAttribute('role', 'button');
-        }
+        this._updateAccessibilityRole();
 
         map.getCanvasContainer().appendChild(this._element);
         map.on('move', this._update);
@@ -553,6 +551,7 @@ export class Marker extends Evented<MarkerEventType> {
             this._element.addEventListener('keypress', this._onKeyPress);
         }
 
+        this._updateAccessibilityRole();
         return this;
     }
 
@@ -857,6 +856,7 @@ export class Marker extends Evented<MarkerEventType> {
      */
     setDraggable(shouldBeDraggable?: boolean): this {
         this._draggable = !!shouldBeDraggable; // convert possible undefined value to false
+        this._element.classList.toggle('maplibregl-marker-draggable', this._draggable);
 
         // handle case where map may not exist yet
         // e.g. when setDraggable is called before addTo
@@ -870,6 +870,7 @@ export class Marker extends Evented<MarkerEventType> {
             }
         }
 
+        this._updateAccessibilityRole();
         return this;
     }
 
@@ -881,6 +882,29 @@ export class Marker extends Evented<MarkerEventType> {
         return this._draggable;
     }
 
+    /**
+     * Keep the default marker role aligned with interactivity.
+     * Default markers need a role because `aria-label` is set in {@link Marker.addTo}.
+     * Non-interactive markers use `role=img`; interactive ones (draggable or with a popup) use `role=button`.
+     * Click listeners are application-owned and do not automatically change the role.
+     * Custom marker elements are left alone so applications own their a11y tree.
+     * Explicit roles set by the application are preserved.
+     */
+    _updateAccessibilityRole(): void {
+        if (!this._defaultMarker) {
+            return;
+        }
+
+        // Preserve an explicit role chosen by the application unless we previously managed it.
+        if (this._element.hasAttribute('role') && !this._roleManaged) {
+            return;
+        }
+
+        const role = (this._draggable || !!this._popup) ? 'button' : 'img';
+        this._element.setAttribute('role', role);
+        this._roleManaged = true;
+    }
+
     /**
      * Sets the `rotation` property of the marker.
      * @param rotation - The rotation angle of the marker (clockwise, in degrees), relative to its respective {@link Marker.setRotationAlignment} setting.

package/src/ui/popup.test.ts

@@ -333,7 +333,7 @@ describe('popup', () => {
         expect(popup._pos).toEqual(map.project([5, 0]));
     });
 
-    test('Popup wraps position after map move if it would otherwise go offscreen (right)', () => {
+    test('Popup wraps position after map move if it would otherwise go offscreen (left)', () => {
         const map = createMap({width: 1024}); // longitude bounds: [-360, 360]
 
         const popup = new Popup()
@@ -613,7 +613,7 @@ describe('popup', () => {
         ).toContain('maplibregl-popup-track-pointer');
     });
 
-    test('Pointer-tracked popup with content set later is tagged with right class ', () => {
+    test('Pointer-tracked popup with content set later is tagged with right class', () => {
         const map = createMap();
         const popup = new Popup()
             .trackPointer()
@@ -626,7 +626,7 @@ describe('popup', () => {
         ).toContain('maplibregl-popup-track-pointer');
     });
 
-    test('Pointer-tracked popup that is set afterwards is tagged with right class ', () => {
+    test('Pointer-tracked popup that is set afterwards is tagged with right class', () => {
         const map = createMap();
         const popup = new Popup()
             .addTo(map);

package/src/util/actor.test.ts

@@ -144,7 +144,7 @@ describe('Actor', () => {
         const worker = await workerFactory() as any as WorkerGlobalScopeInterface & ActorTarget;
         const actor = new Actor(worker, '1');
 
-        const spy = vi.fn().mockReturnValue(Promise.resolve({}));
+        const spy = vi.fn().mockResolvedValue({});
         worker.worker.actor.registerMessageHandler(MessageType.getClusterExpansionZoom, spy);
 
         worker.worker.actor.invoker.trigger = async () => {
@@ -209,7 +209,7 @@ describe('Actor', () => {
 
         worker.worker.actor.mapId = '2';
 
-        const spy = vi.fn().mockReturnValue(Promise.resolve({}));
+        const spy = vi.fn().mockResolvedValue({});
         worker.worker.actor.registerMessageHandler(MessageType.getClusterExpansionZoom, spy);
 
         actor.sendAsync({type: MessageType.getClusterExpansionZoom, data: {} as any, targetMapId: '1'});
@@ -223,7 +223,7 @@ describe('Actor', () => {
         const worker = await workerFactory() as any as WorkerGlobalScopeInterface & ActorTarget;
         const actor = new Actor(worker, '1');
 
-        const spy = vi.fn().mockReturnValue(Promise.resolve({}));
+        const spy = vi.fn().mockResolvedValue({});
         worker.worker.actor.registerMessageHandler(MessageType.getClusterExpansionZoom, spy);
 
         actor.target.postMessage({type: 'getClusterExpansionZoom', data: {} as any, origin: 'https://example.com'});
@@ -237,7 +237,7 @@ describe('Actor', () => {
         const worker = await workerFactory() as any as WorkerGlobalScopeInterface & ActorTarget;
         const actor = new Actor(worker, '1');
 
-        const spy = vi.fn().mockReturnValue(Promise.resolve({}));
+        const spy = vi.fn().mockResolvedValue({});
         worker.worker.actor.registerMessageHandler(MessageType.getClusterExpansionZoom, spy);
 
         actor.target.postMessage({type: MessageType.getClusterExpansionZoom, data: {} as any, origin: 'null'});
@@ -251,7 +251,7 @@ describe('Actor', () => {
         const worker = await workerFactory() as any as WorkerGlobalScopeInterface & ActorTarget;
         const actor = new Actor(worker, '1');
 
-        const spy = vi.fn().mockReturnValue(Promise.resolve({}));
+        const spy = vi.fn().mockResolvedValue({});
         worker.worker.actor.registerMessageHandler(MessageType.getClusterExpansionZoom, spy);
 
         actor.target.postMessage({type: MessageType.getClusterExpansionZoom, data: {} as any, origin: 'file://'});
@@ -265,7 +265,7 @@ describe('Actor', () => {
         const worker = await workerFactory() as any as WorkerGlobalScopeInterface & ActorTarget;
         const actor = new Actor(worker, '1');
 
-        const spy = vi.fn().mockReturnValue(Promise.resolve({}));
+        const spy = vi.fn().mockResolvedValue({});
         worker.worker.actor.registerMessageHandler(MessageType.getClusterExpansionZoom, spy);
 
         actor.target.postMessage({type: MessageType.getClusterExpansionZoom, data: {} as any, origin: 'resource://android'});

package/src/util/ajax.test.ts

@@ -20,6 +20,12 @@ function readAsText(blob) {
     });
 }
 
+async function expectRejection(promise: Promise<unknown>): Promise<AJAXError> {
+    const error = await promise.catch((e) => e);
+    expect(error).toBeInstanceOf(Error);
+    return error as AJAXError;
+}
+
 const originalFetch = global.fetch;
 
 describe('ajax', () => {
@@ -37,18 +43,14 @@ describe('ajax', () => {
             request.respond(404, undefined, '404 Not Found');
         });
 
-        try {
-            const promise =  getArrayBuffer({url: 'http://example.com/test.bin'}, new AbortController());
-            server.respond();
-            await promise;
-        } catch (error) {
-            const ajaxError = error as AJAXError;
-            const body = await readAsText(ajaxError.body);
-            expect(ajaxError.status).toBe(404);
-            expect(ajaxError.statusText).toBe('Not Found');
-            expect(ajaxError.url).toBe('http://example.com/test.bin');
-            expect(body).toBe('404 Not Found');
-        }
+        const promise = getArrayBuffer({url: 'http://example.com/test.bin'}, new AbortController());
+        server.respond();
+
+        const ajaxError = await expectRejection(promise);
+        expect(ajaxError.status).toBe(404);
+        expect(ajaxError.statusText).toBe('Not Found');
+        expect(ajaxError.url).toBe('http://example.com/test.bin');
+        await expect(readAsText(ajaxError.body)).resolves.toBe('404 Not Found');
     });
 
     test('getJSON', async () => {
@@ -68,11 +70,8 @@ describe('ajax', () => {
         });
         const promise = getJSON({url: ''}, new AbortController());
         server.respond();
-        try {
-            await promise;
-        } catch (error) {
-            expect(error).toBeTruthy();
-        }
+
+        await expect(promise).rejects.toThrow(SyntaxError);
     });
 
     test('getJSON, 404', async () => {
@@ -82,16 +81,11 @@ describe('ajax', () => {
         const promise = getJSON({url: 'http://example.com/test.json'}, new AbortController());
         server.respond();
 
-        try {
-            await promise;
-        } catch (error) {
-            const ajaxError = error as AJAXError;
-            const body = await readAsText(ajaxError.body);
-            expect(ajaxError.status).toBe(404);
-            expect(ajaxError.statusText).toBe('Not Found');
-            expect(ajaxError.url).toBe('http://example.com/test.json');
-            expect(body).toBe('404 Not Found');
-        }
+        const ajaxError = await expectRejection(promise);
+        expect(ajaxError.status).toBe(404);
+        expect(ajaxError.statusText).toBe('Not Found');
+        expect(ajaxError.url).toBe('http://example.com/test.json');
+        await expect(readAsText(ajaxError.body)).resolves.toBe('404 Not Found');
     });
 
     test('getJSON, aborted', async () => {
@@ -103,12 +97,9 @@ describe('ajax', () => {
         abortController.abort();
         server.respond();
 
-        try {
-            await promise;
-        } catch (error) {
-            expect(ensureError(error).name).toBe('AbortError');
-            expect(isAbortError(error)).toBe(true);
-        }
+        const error = await expectRejection(promise);
+        expect(ensureError(error).name).toBe('AbortError');
+        expect(isAbortError(error)).toBe(true);
     });
 
     test('getJSON with fetch, aborted', async () => {
@@ -126,12 +117,9 @@ describe('ajax', () => {
         abortController.abort();
         server.respond();
 
-        try {
-            await promise;
-        } catch (error) {
-            expect(ensureError(error).name).toBe('AbortError');
-            expect(isAbortError(error)).toBe(true);
-        }
+        const error = await expectRejection(promise);
+        expect(ensureError(error).name).toBe('AbortError');
+        expect(isAbortError(error)).toBe(true);
     });
 
     test('getReferrer method (outside Worker), same origin https URL', () => {