maplibre-gl 2.1.0 → 2.1.4

package/src/source/source.ts

@@ -33,47 +33,47 @@ import {CanonicalTileID} from './tile_id';
  * if they are floor-ed to the nearest integer.
  */
 export interface Source {
-  readonly type: string;
-  id: string;
-  minzoom: number;
-  maxzoom: number;
-  tileSize: number;
-  attribution?: string;
-  roundZoom?: boolean;
-  isTileClipped?: boolean;
-  maplibreLogo?: boolean;
-  tileID?: CanonicalTileID;
-  reparseOverscaled?: boolean;
-  vectorLayerIds?: Array<string>;
-  hasTransition(): boolean;
-  loaded(): boolean;
-  fire(event: Event): unknown;
-  readonly onAdd?: (map: Map) => void;
-  readonly onRemove?: (map: Map) => void;
-  loadTile(tile: Tile, callback: Callback<void>): void;
-  readonly hasTile?: (tileID: OverscaledTileID) => boolean;
-  readonly abortTile?: (tile: Tile, callback: Callback<void>) => void;
-  readonly unloadTile?: (tile: Tile, callback: Callback<void>) => void;
-  /**
+    readonly type: string;
+    id: string;
+    minzoom: number;
+    maxzoom: number;
+    tileSize: number;
+    attribution?: string;
+    roundZoom?: boolean;
+    isTileClipped?: boolean;
+    maplibreLogo?: boolean;
+    tileID?: CanonicalTileID;
+    reparseOverscaled?: boolean;
+    vectorLayerIds?: Array<string>;
+    hasTransition(): boolean;
+    loaded(): boolean;
+    fire(event: Event): unknown;
+    readonly onAdd?: (map: Map) => void;
+    readonly onRemove?: (map: Map) => void;
+    loadTile(tile: Tile, callback: Callback<void>): void;
+    readonly hasTile?: (tileID: OverscaledTileID) => boolean;
+    readonly abortTile?: (tile: Tile, callback: Callback<void>) => void;
+    readonly unloadTile?: (tile: Tile, callback: Callback<void>) => void;
+    /**
      * @returns A plain (stringifiable) JS object representing the current state of the source.
      * Creating a source using the returned object as the `options` should result in a Source that is
      * equivalent to this one.
      * @private
      */
-  serialize(): any;
-  readonly prepare?: () => void;
+    serialize(): any;
+    readonly prepare?: () => void;
 }
 
 type SourceStatics = {
-  /*
+    /*
      * An optional URL to a script which, when run by a Worker, registers a {@link WorkerSource}
      * implementation for this Source type by calling `self.registerWorkerSource(workerSource: WorkerSource)`.
      */
-  workerSourceURL?: URL;
+    workerSourceURL?: URL;
 };
 
 export type SourceClass = {
-  new (...args: any): Source;
+    new (...args: any): Source;
 } & SourceStatics;
 
 import vector from '../source/vector_tile_source';
@@ -122,11 +122,11 @@ export const getSourceType = function (name: string) {
 };
 
 export const setSourceType = function (name: string, type: {
-  new (...args: any): Source;
+    new (...args: any): Source;
 }) {
     sourceTypes[name] = type;
 };
 
 export interface Actor {
-  send(type: string, data: any, callback: Callback<any>): void;
+    send(type: string, data: any, callback: Callback<any>): void;
 }

package/src/source/source_cache.test.ts

@@ -336,6 +336,38 @@ describe('SourceCache#removeTile', () => {
         sourceCache._addTile(tileID);
     });
 
+    test('fires dataabort event', done => {
+        const sourceCache = createSourceCache({
+            loadTile() {
+                // Do not call back in order to make sure the tile is removed before it is loaded.
+            }
+        });
+        const tileID = new OverscaledTileID(0, 0, 0, 0, 0);
+        const tile = sourceCache._addTile(tileID);
+        sourceCache.once('dataabort', event => {
+            expect(event.dataType).toBe('source');
+            expect(event.tile).toBe(tile);
+            expect(event.coord).toBe(tileID);
+            done();
+        });
+        sourceCache._removeTile(tileID.key);
+    });
+
+    test('does not fire dataabort event when the tile has already been loaded', () => {
+        const sourceCache = createSourceCache({
+            loadTile(tile, callback) {
+                tile.state = 'loaded';
+                callback();
+            }
+        });
+        const tileID = new OverscaledTileID(0, 0, 0, 0, 0);
+        sourceCache._addTile(tileID);
+        const onAbort = jest.fn();
+        sourceCache.once('dataabort', onAbort);
+        sourceCache._removeTile(tileID.key);
+        expect(onAbort).toHaveBeenCalledTimes(0);
+    });
+
 });
 
 describe('SourceCache / Source lifecycle', () => {

package/src/source/source_cache.ts

@@ -46,10 +46,10 @@ class SourceCache extends Evented {
     _prevLng: number;
     _cache: TileCache;
     _timers: {
-      [_ in any]: ReturnType<typeof setTimeout>;
+        [_ in any]: ReturnType<typeof setTimeout>;
     };
     _cacheTimers: {
-      [_ in any]: ReturnType<typeof setTimeout>;
+        [_ in any]: ReturnType<typeof setTimeout>;
     };
     _maxTileCacheSize: number;
     _paused: boolean;
@@ -160,7 +160,9 @@ class SourceCache extends Evented {
 
     _abortTile(tile: Tile) {
         if (this._source.abortTile)
-            return this._source.abortTile(tile, () => {});
+            this._source.abortTile(tile, () => {});
+
+        this._source.fire(new Event('dataabort', {tile, coord: tile.tileID, dataType: 'source'}));
     }
 
     serialize() {
@@ -331,12 +333,12 @@ class SourceCache extends Evented {
      */
     _retainLoadedChildren(
         idealTiles: {
-          [_ in any]: OverscaledTileID;
+            [_ in any]: OverscaledTileID;
         },
         zoom: number,
         maxCoveringZoom: number,
         retain: {
-          [_ in any]: OverscaledTileID;
+            [_ in any]: OverscaledTileID;
         }
     ) {
         for (const id in this._tiles) {

package/src/source/source_state.ts

@@ -102,7 +102,7 @@ class SourceFeatureState {
     }
 
     coalesceChanges(tiles: {
-      [_ in any]: Tile;
+        [_ in any]: Tile;
     }, painter: any) {
         //track changes with full state objects, but only for features that got modified
         const featuresChanged: LayerFeatureStates = {};

package/src/source/tile.test.ts

@@ -1,4 +1,4 @@
-import {createSymbolBucket} from '../../test/util/create_symbol_layer';
+import {createSymbolBucket} from '../../test/unit/lib/create_symbol_layer';
 import Tile from '../source/tile';
 import GeoJSONWrapper, {Feature} from '../source/geojson_wrapper';
 import {OverscaledTileID} from '../source/tile_id';
@@ -6,7 +6,7 @@ import fs from 'fs';
 import path from 'path';
 import vtpbf from 'vt-pbf';
 import FeatureIndex from '../data/feature_index';
-import {CollisionBoxArray} from '../data/array_types';
+import {CollisionBoxArray} from '../data/array_types.g';
 import {extend} from '../util/util';
 import {serialize, deserialize} from '../util/web_worker_transfer';
 
@@ -273,7 +273,7 @@ describe('rtl text detection', () => {
 });
 
 function createRawTileData() {
-    return fs.readFileSync(path.join(__dirname, '../../test/fixtures/mbsv5-6-18-23.vector.pbf'));
+    return fs.readFileSync(path.join(__dirname, '../../test/unit/assets/mbsv5-6-18-23.vector.pbf'));
 }
 
 function createVectorData(options?) {

package/src/source/tile.ts

@@ -5,7 +5,7 @@ import type FeatureIndex from '../data/feature_index';
 import GeoJSONFeature from '../util/vectortile_to_geojson';
 import featureFilter from '../style-spec/feature_filter';
 import SymbolBucket from '../data/bucket/symbol_bucket';
-import {CollisionBoxArray} from '../data/array_types';
+import {CollisionBoxArray} from '../data/array_types.g';
 import Texture from '../render/texture';
 import browser from '../util/browser';
 import toEvaluationFeature from '../data/evaluation_feature';
@@ -268,20 +268,20 @@ class Tile {
     // Queries non-symbol features rendered for this tile.
     // Symbol features are queried globally
     queryRenderedFeatures(
-      layers: {[_: string]: StyleLayer},
-      serializedLayers: {[_: string]: any},
-      sourceFeatureState: SourceFeatureState,
-      queryGeometry: Array<Point>,
-      cameraQueryGeometry: Array<Point>,
-      scale: number,
-      params: {
-        filter: FilterSpecification;
-        layers: Array<string>;
-        availableImages: Array<string>;
-      },
-      transform: Transform,
-      maxPitchScaleFactor: number,
-      pixelPosMatrix: mat4
+        layers: {[_: string]: StyleLayer},
+        serializedLayers: {[_: string]: any},
+        sourceFeatureState: SourceFeatureState,
+        queryGeometry: Array<Point>,
+        cameraQueryGeometry: Array<Point>,
+        scale: number,
+        params: {
+            filter: FilterSpecification;
+            layers: Array<string>;
+            availableImages: Array<string>;
+        },
+        transform: Transform,
+        maxPitchScaleFactor: number,
+        pixelPosMatrix: mat4
     ): {[_: string]: Array<{featureIndex: number; feature: GeoJSONFeature}>} {
         if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData)
             return {};

package/src/source/tile_cache.test.ts

@@ -30,19 +30,20 @@ describe('TileCache', () => {
         keysExpected(cache, []);
     });
 
-    test('get without removing', () => {
+    test('get without removing', done => {
         const cache = new TileCache(10, () => {
-            fail();
+            done('test "get without removing" failed');
         });
         expect(cache.add(idA, tileA)).toBe(cache);
         expect(cache.get(idA)).toBe(tileA);
         keysExpected(cache, [idA]);
         expect(cache.get(idA)).toBe(tileA);
+        done();
     });
 
-    test('duplicate add', () => {
+    test('duplicate add', done => {
         const cache = new TileCache(10, () => {
-            fail();
+            done('test "duplicate add" failed');
         });
 
         cache.add(idA, tileA);
@@ -53,6 +54,7 @@ describe('TileCache', () => {
         expect(cache.getAndRemove(idA)).toBe(tileA);
         expect(cache.has(idA)).toBeTruthy();
         expect(cache.getAndRemove(idA)).toBe(tileA2);
+        done();
     });
 
     test('expiry', () => {

package/src/source/tile_cache.ts

@@ -11,10 +11,10 @@ import type Tile from './tile';
 class TileCache {
     max: number;
     data: {
-      [key: string]: Array<{
-        value: Tile;
-        timeout: ReturnType<typeof setTimeout>;
-      }>;
+        [key: string]: Array<{
+            value: Tile;
+            timeout: ReturnType<typeof setTimeout>;
+        }>;
     };
     order: Array<string>;
     onRemove: (element: Tile) => void;
@@ -157,8 +157,8 @@ class TileCache {
      * @private
      */
     remove(tileID: OverscaledTileID, value?: {
-      value: Tile;
-      timeout: ReturnType<typeof setTimeout>;
+        value: Tile;
+        timeout: ReturnType<typeof setTimeout>;
     }) {
         if (!this.has(tileID)) { return this; }
         const key = tileID.wrapped().key;

package/src/source/tile_id.test.ts

@@ -43,7 +43,6 @@ describe('CanonicalTileID', () => {
         expect(new CanonicalTileID(17, 22914, 52870).url(['quadkey={quadkey}'], 1)).toBe('quadkey=02301322130000230');
 
         // Test case confirmed by quadkeytools package
-        // https://bitbucket.org/steele/quadkeytools/rollup/build/tsc/src/master/test/quadkey.js?fileviewer=file-view-default#quadkey.js-57
         expect(new CanonicalTileID(6, 29, 3).url(['quadkey={quadkey}'], 1)).toBe('quadkey=011123');
 
     });

package/src/source/vector_tile_source.test.ts

@@ -1,21 +1,21 @@
-import {fakeServer, SinonFakeServer} from 'sinon';
+import {fakeServer, FakeServer} from 'nise';
 import {Source} from './source';
 import VectorTileSource from './vector_tile_source';
 import Tile from './tile';
 import {OverscaledTileID} from './tile_id';
 import {Evented} from '../util/evented';
 import {RequestManager} from '../util/request_manager';
-import fixturesSource from '../../test/fixtures/source.json';
+import fixturesSource from '../../test/unit/assets/source.json';
 import {getMockDispatcher, getWrapDispatcher} from '../util/test/util';
 import Map from '../ui/map';
 
-function createSource(options, transformCallback?) {
+function createSource(options, transformCallback?, clearTiles = () => {}) {
     const source = new VectorTileSource('id', options, getMockDispatcher(), options.eventedParent);
     source.onAdd({
         transform: {showCollisionBoxes: false},
         _getMapId: () => 1,
         _requestManager: new RequestManager(transformCallback),
-        style: {sourceCaches: {id: {clearTiles: () => {}}}},
+        style: {sourceCaches: {id: {clearTiles}}},
         getPixelRatio() { return 1; }
     } as any as Map);
 
@@ -27,7 +27,7 @@ function createSource(options, transformCallback?) {
 }
 
 describe('VectorTileSource', () => {
-    let server: SinonFakeServer;
+    let server: FakeServer;
     beforeEach(() => {
         global.fetch = null;
         server = fakeServer.create();
@@ -343,4 +343,15 @@ describe('VectorTileSource', () => {
             tiles: ['http://example2.com/{z}/{x}/{y}.png']
         });
     });
+
+    test('setTiles only clears the cache once the TileJSON has reloaded', done => {
+        const clearTiles = jest.fn();
+        const source = createSource({tiles: ['http://example.com/{z}/{x}/{y}.pbf']}, undefined, clearTiles);
+        source.setTiles(['http://example2.com/{z}/{x}/{y}.pbf']);
+        expect(clearTiles.mock.calls).toHaveLength(0);
+        source.once('data', () => {
+            expect(clearTiles.mock.calls).toHaveLength(1);
+            done();
+        });
+    });
 });

package/src/source/vector_tile_source.ts

@@ -64,7 +64,7 @@ class VectorTileSource extends Evented implements Source {
     _loaded: boolean;
 
     constructor(id: string, options: VectorSourceSpecification & {
-      collectResourceTiming: boolean;
+        collectResourceTiming: boolean;
     }, dispatcher: Dispatcher, eventedParent: Evented) {
         super();
         this.id = id;
@@ -97,6 +97,7 @@ class VectorTileSource extends Evented implements Source {
         this._tileJSONRequest = loadTileJSON(this._options, this.map._requestManager, (err, tileJSON) => {
             this._tileJSONRequest = null;
             this._loaded = true;
+            this.map.style.sourceCaches[this.id].clearTiles();
             if (err) {
                 this.fire(new ErrorEvent(err));
             } else if (tileJSON) {
@@ -132,8 +133,6 @@ class VectorTileSource extends Evented implements Source {
 
         callback();
 
-        const sourceCache = this.map.style.sourceCaches[this.id];
-        sourceCache.clearTiles();
         this.load();
     }
 

package/src/source/vector_tile_worker_source.test.ts

@@ -4,7 +4,7 @@ import vt from '@mapbox/vector-tile';
 import Protobuf from 'pbf';
 import VectorTileWorkerSource from '../source/vector_tile_worker_source';
 import StyleLayerIndex from '../style/style_layer_index';
-import {fakeServer, SinonFakeServer} from 'sinon';
+import {fakeServer, FakeServer} from 'nise';
 import Actor from '../util/actor';
 import {TileParameters, WorkerTileParameters} from './worker_source';
 import WorkerTile from './worker_tile';
@@ -12,7 +12,7 @@ import {setPerformance} from '../util/test/util';
 
 describe('vector tile worker source', () => {
     const actor = {send: () => {}} as any as Actor;
-    let server: SinonFakeServer;
+    let server: FakeServer;
     let originalGetEntriesByName;
     let originalMeasure;
     let originalMark;
@@ -195,7 +195,7 @@ describe('vector tile worker source', () => {
     });
 
     test('VectorTileWorkerSource provides resource timing information', done => {
-        const rawTileData = fs.readFileSync(path.join(__dirname, '/../../test/fixtures/mbsv5-6-18-23.vector.pbf'));
+        const rawTileData = fs.readFileSync(path.join(__dirname, '/../../test/unit/assets/mbsv5-6-18-23.vector.pbf'));
 
         function loadVectorData(params, callback) {
             return callback(null, {
@@ -251,7 +251,7 @@ describe('vector tile worker source', () => {
     });
 
     test('VectorTileWorkerSource provides resource timing information (fallback method)', done => {
-        const rawTileData = fs.readFileSync(path.join(__dirname, '/../../test/fixtures/mbsv5-6-18-23.vector.pbf'));
+        const rawTileData = fs.readFileSync(path.join(__dirname, '/../../test/unit/assets/mbsv5-6-18-23.vector.pbf'));
 
         function loadVectorData(params, callback) {
             return callback(null, {

package/src/source/vector_tile_worker_source.ts

@@ -19,11 +19,11 @@ import type {Callback} from '../types/callback';
 import type {VectorTile} from '@mapbox/vector-tile';
 
 export type LoadVectorTileResult = {
-  vectorTile: VectorTile;
-  rawData: ArrayBuffer;
-  expires?: any;
-  cacheControl?: any;
-  resourceTiming?: Array<PerformanceResourceTiming>;
+    vectorTile: VectorTile;
+    rawData: ArrayBuffer;
+    expires?: any;
+    cacheControl?: any;
+    resourceTiming?: Array<PerformanceResourceTiming>;
 };
 
 /**

package/src/source/worker.test.ts

@@ -1,4 +1,4 @@
-import {fakeServer} from 'sinon';
+import {fakeServer} from 'nise';
 import Worker from './worker';
 import {LayerSpecification} from '../style-spec/types';
 import {Cancelable} from '../types/cancelable';

package/src/source/worker.ts

@@ -31,21 +31,21 @@ export default class Worker {
     layerIndexes: {[_: string]: StyleLayerIndex};
     availableImages: {[_: string]: Array<string>};
     workerSourceTypes: {
-      [_: string]: {
-        new (...args: any): WorkerSource;
-      };
+        [_: string]: {
+            new (...args: any): WorkerSource;
+        };
     };
     workerSources: {
-      [_: string]: {
         [_: string]: {
-          [_: string]: WorkerSource;
+            [_: string]: {
+                [_: string]: WorkerSource;
+            };
         };
-      };
     };
     demWorkerSources: {
-      [_: string]: {
-        [_: string]: RasterDEMTileWorkerSource;
-      };
+        [_: string]: {
+            [_: string]: RasterDEMTileWorkerSource;
+        };
     };
     referrer: string;
 
@@ -66,7 +66,7 @@ export default class Worker {
         this.demWorkerSources = {};
 
         this.self.registerWorkerSource = (name: string, WorkerSource: {
-          new (...args: any): WorkerSource;
+            new (...args: any): WorkerSource;
         }) => {
             if (this.workerSourceTypes[name]) {
                 throw new Error(`Worker source with name "${name}" already registered.`);
@@ -76,9 +76,9 @@ export default class Worker {
 
         // This is invoked by the RTL text plugin when the download via the `importScripts` call has finished, and the code has been parsed.
         this.self.registerRTLTextPlugin = (rtlTextPlugin: {
-          applyArabicShaping: Function;
-          processBidirectionalText: ((b: string, a: Array<number>) => Array<string>);
-          processStyledBidirectionalText?: ((c: string, b: Array<number>, a: Array<number>) => Array<[string, Array<number>]>);
+            applyArabicShaping: Function;
+            processBidirectionalText: ((b: string, a: Array<number>) => Array<string>);
+            processStyledBidirectionalText?: ((c: string, b: Array<number>, a: Array<number>) => Array<[string, Array<number>]>);
         }) => {
             if (globalRTLTextPlugin.isParsed()) {
                 throw new Error('RTL text plugin already registered.');
@@ -110,15 +110,15 @@ export default class Worker {
     }
 
     updateLayers(mapId: string, params: {
-      layers: Array<LayerSpecification>;
-      removedIds: Array<string>;
+        layers: Array<LayerSpecification>;
+        removedIds: Array<string>;
     }, callback: WorkerTileCallback) {
         this.getLayerIndex(mapId).update(params.layers, params.removedIds);
         callback();
     }
 
     loadTile(mapId: string, params: WorkerTileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).loadTile(params, callback);
@@ -129,21 +129,21 @@ export default class Worker {
     }
 
     reloadTile(mapId: string, params: WorkerTileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).reloadTile(params, callback);
     }
 
     abortTile(mapId: string, params: TileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).abortTile(params, callback);
     }
 
     removeTile(mapId: string, params: TileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).removeTile(params, callback);
@@ -154,9 +154,9 @@ export default class Worker {
     }
 
     removeSource(mapId: string, params: {
-      source: string;
+        source: string;
     } & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         assert(params.source);
@@ -184,7 +184,7 @@ export default class Worker {
      *  @private
      */
     loadWorkerSource(map: string, params: {
-      url: string;
+        url: string;
     }, callback: Callback<void>) {
         try {
             this.self.importScripts(params.url);