maplibre-gl 2.2.0-pre.2 → 2.2.0

package/src/render/program/debug_program.ts

@@ -16,7 +16,7 @@ const debugUniforms = (context: Context, locations: UniformLocations): DebugUnif
     'u_color': new UniformColor(context, locations.u_color),
     'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
     'u_overlay': new Uniform1i(context, locations.u_overlay),
-    'u_overlay_scale':  new Uniform1f(context, locations.u_overlay_scale)
+    'u_overlay_scale': new Uniform1f(context, locations.u_overlay_scale)
 });
 
 const debugUniformValues = (matrix: mat4, color: Color, scaleRatio: number = 1): UniformValues<DebugUniformsType> => ({

package/src/render/render_to_texture.ts

@@ -5,6 +5,9 @@ import {OverscaledTileID} from '../source/tile_id';
 import {prepareTerrain, drawTerrain} from './draw_terrain';
 import type StyleLayer from '../style/style_layer';
 
+/**
+ * RenderToTexture
+ */
 export default class RenderToTexture {
     painter: Painter;
     // this object holds a lookup table which layers should rendered to texture

package/src/render/terrain.test.ts

@@ -6,8 +6,11 @@ import {RGBAImage} from '../util/image';
 import Texture from './texture';
 import type Style from '../style/style';
 import type SourceCache from '../source/source_cache';
-import type TerrainSourceCache from '../source/terrain_source_cache';
+import {OverscaledTileID} from '../source/tile_id';
 import type {TerrainSpecification} from '../style-spec/types.g';
+import type DEMData from '../data/dem_data';
+import TileCache from '../source/tile_cache';
+import Tile from '../source/tile';
 
 describe('Terrain', () => {
     test('pointCoordiate should not return null', () => {
@@ -21,23 +24,24 @@ describe('Terrain', () => {
             }
         } as any as Style;
         const sourceCache = {
-            getTileByID: (tileID) => {
-                if (tileID !== 'abcd') {
-                    return null;
-                }
-                return {
-                    tileID: {
-                        canonical: {
-                            x: 0,
-                            y: 0,
-                            z: 0
-                        }
-                    }
-                };
+            _cache: {max: 100} as TileCache
+        } as SourceCache;
+        const getTileByID = (tileID) : Tile => {
+            if (tileID !== 'abcd') {
+                return null as any as Tile;
             }
-        } as any as TerrainSourceCache;
-        const terrain = new Terrain(style, {} as any as SourceCache, {} as any as TerrainSpecification);
-        terrain.sourceCache = sourceCache;
+            return {
+                tileID: {
+                    canonical: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                    }
+                }
+            } as any as Tile;
+        };
+        const terrain = new Terrain(style, sourceCache, {} as any as TerrainSpecification);
+        terrain.sourceCache.getTileByID = getTileByID;
         const context = style.map.painter.context as Context;
         const pixels = new Uint8Array([0, 0, 255, 255]);
         const image = new RGBAImage({width: 1, height: 1}, pixels);
@@ -50,4 +54,102 @@ describe('Terrain', () => {
 
         expect(coordinate).not.toBeNull();
     });
+
+    test('Calculate tile minimum and maximum elevation', () => {
+        const tileID = new OverscaledTileID(5, 0, 5, 17, 11);
+        const tile = new Tile(tileID, 256);
+        tile.dem = {
+            min: 0,
+            max: 100,
+            getPixels: () => new RGBAImage({width: 1, height: 1}, new Uint8Array(1 * 4)),
+            getUnpackVector: () => [6553.6, 25.6, 0.1, 10000.0],
+        } as any as DEMData;
+        const style = {
+            map: {
+                painter: {
+                    context: new Context(gl(1, 1)),
+                    width: 1,
+                    height: 1,
+                    getTileTexture: () => null
+                }
+            }
+        } as any as Style;
+        const sourceCache = {
+            _source: {maxzoom: 12},
+            _cache: {max: 10},
+            getTileByID: () => {
+                return tile;
+            },
+        } as any as SourceCache;
+        const terrain = new Terrain(
+            style,
+            sourceCache,
+            {exaggeration: 2, elevationOffset: 50} as any as TerrainSpecification,
+        );
+
+        terrain.sourceCache._tiles[tileID.key] = tile;
+        const {minElevation, maxElevation} = terrain.getMinMaxElevation(tileID);
+
+        expect(minElevation).toBe(100);
+        expect(maxElevation).toBe(300);
+    });
+
+    test('Return null elevation values when no tile', () => {
+        const tileID = new OverscaledTileID(5, 0, 5, 17, 11);
+        const style = {
+            map: {
+                painter: {
+                    context: new Context(gl(1, 1)),
+                    width: 1,
+                    height: 1,
+                }
+            }
+        } as any as Style;
+        const sourceCache = {
+            _source: {maxzoom: 12},
+            _cache: {max: 10},
+            getTileByID: () => null,
+        } as any as SourceCache;
+        const terrain = new Terrain(
+            style,
+            sourceCache,
+            {exaggeration: 2, elevationOffset: 50} as any as TerrainSpecification,
+        );
+
+        const minMaxNoTile = terrain.getMinMaxElevation(tileID);
+
+        expect(minMaxNoTile.minElevation).toBeNull();
+        expect(minMaxNoTile.maxElevation).toBeNull();
+    });
+
+    test('Return null elevation values when no DEM', () => {
+        const tileID = new OverscaledTileID(5, 0, 5, 17, 11);
+        const tile = new Tile(tileID, 256);
+        tile.dem = null as any as DEMData;
+        const style = {
+            map: {
+                painter: {
+                    context: new Context(gl(1, 1)),
+                    width: 1,
+                    height: 1,
+                }
+            }
+        } as any as Style;
+        const sourceCache = {
+            _source: {maxzoom: 12},
+            _cache: {max: 10},
+            getTileByID: () => {
+                return tile;
+            },
+        } as any as SourceCache;
+        const terrain = new Terrain(
+            style,
+            sourceCache,
+            {exaggeration: 2, elevationOffset: 50} as any as TerrainSpecification,
+        );
+        const minMaxNoDEM = terrain.getMinMaxElevation(tileID);
+
+        expect(minMaxNoDEM.minElevation).toBeNull();
+        expect(minMaxNoDEM.maxElevation).toBeNull();
+    });
 });

package/src/render/terrain.ts

@@ -20,6 +20,25 @@ import EXTENT from '../data/extent';
 import {number as mix} from '../style-spec/util/interpolate';
 import type {TerrainSpecification} from '../style-spec/types.g';
 
+export type TerrainData = {
+    'u_depth': number;
+    'u_terrain': number;
+    'u_terrain_dim': number;
+    'u_terrain_matrix': mat4;
+    'u_terrain_unpack': number[];
+    'u_terrain_offset': number;
+    'u_terrain_exaggeration': number;
+    texture: WebGLTexture;
+    depthTexture: WebGLTexture;
+    tile: Tile;
+}
+
+export type TerrainMesh = {
+    indexBuffer: IndexBuffer;
+    vertexBuffer: VertexBuffer;
+    segments: SegmentVector;
+}
+
 /**
  * This is the main class which handles most of the 3D Terrain logic. It has the follwing topics:
  *    1) loads raster-dem tiles via the internal sourceCache this.sourceCache
@@ -48,25 +67,6 @@ import type {TerrainSpecification} from '../style-spec/types.g';
  *
  */
 
-export type TerrainData = {
-    'u_depth': number;
-    'u_terrain': number;
-    'u_terrain_dim': number;
-    'u_terrain_matrix': mat4;
-    'u_terrain_unpack': number[];
-    'u_terrain_offset': number;
-    'u_terrain_exaggeration': number;
-    texture: WebGLTexture;
-    depthTexture: WebGLTexture;
-    tile: Tile;
-}
-
-export type TerrainMesh = {
-    indexBuffer: IndexBuffer;
-    vertexBuffer: VertexBuffer;
-    segments: SegmentVector;
-}
-
 export default class Terrain {
     // The style this terrain crresponds to
     style: Style;
@@ -143,8 +143,8 @@ export default class Terrain {
         const terrain = this.getTerrainData(tileID);
         if (terrain.tile && terrain.tile.dem) {
             const pos = vec2.transformMat4([] as any, [x / extent * EXTENT, y / extent * EXTENT], terrain.u_terrain_matrix);
-            const coord = [ pos[0] * terrain.tile.dem.dim, pos[1] * terrain.tile.dem.dim ];
-            const c = [ Math.floor(coord[0]), Math.floor(coord[1]) ];
+            const coord = [pos[0] * terrain.tile.dem.dim, pos[1] * terrain.tile.dem.dim];
+            const c = [Math.floor(coord[0]), Math.floor(coord[1])];
             const tl = terrain.tile.dem.get(c[0], c[1]);
             const tr = terrain.tile.dem.get(c[0], c[1] + 1);
             const bl = terrain.tile.dem.get(c[0] + 1, c[1]);
@@ -366,4 +366,22 @@ export default class Terrain {
         return this._mesh;
     }
 
+    /**
+     * Get the minimum and maximum elevation contained in a tile. This includes any elevation offset
+     * and exaggeration included in the terrain.
+     *
+     * @param tileID Id of the tile to be used as a source for the min/max elevation
+     * @returns {Object} Minimum and maximum elevation found in the tile, including the terrain's
+     * elevation offset and exaggeration
+     */
+    getMinMaxElevation(tileID: OverscaledTileID): {minElevation: number | null; maxElevation: number | null} {
+        const tile = this.getTerrainData(tileID).tile;
+        const minMax = {minElevation: null, maxElevation: null};
+        if (tile && tile.dem) {
+            minMax.minElevation = (tile.dem.min + this.elevationOffset) * this.exaggeration;
+            minMax.maxElevation = (tile.dem.max + this.elevationOffset) * this.exaggeration;
+        }
+        return minMax;
+    }
+
 }

package/src/shaders/README.md

@@ -1,6 +1,6 @@
-# Mapbox GL Shaders
+# MapLibre GL Shaders
 
-This repository contains GL shaders which are shared by [Mapbox GL JS](https://github.com/mapbox/mapbox-gl-js) and [Mapbox GL Native](https://github.com/mapbox/mapbox-gl-native).
+This repository contains GL shaders which are shared by [MapLibre GL JS](https://github.com/maplibre/maplibre-gl-js) and [MapLibre GL Native](https://github.com/maplibre/maplibre-gl-native).
 
 ## Pragmas
 

package/src/shaders/shaders.ts

@@ -58,7 +58,7 @@ import terrainCoordsFrag from './terrain_coords.fragment.glsl.g';
 import terrainFrag from './terrain.fragment.glsl.g';
 import terrainVert from './terrain.vertex.glsl.g';
 
-export default {
+const shaders = {
     prelude: compile(preludeFrag, preludeVert),
     background: compile(backgroundFrag, backgroundVert),
     backgroundPattern: compile(backgroundPatternFrag, backgroundPatternVert),
@@ -90,6 +90,8 @@ export default {
     terrainCoords: compile(terrainCoordsFrag, terrainVert)
 };
 
+export default shaders;
+
 // Expand #pragmas to #ifdefs.
 
 function compile(fragmentSource, vertexSource) {

package/src/source/geojson_worker_source.test.ts

@@ -130,7 +130,7 @@ describe('resourceTiming', () => {
             secureConnectionStart: 0
         } as any as PerformanceEntry;
 
-        window.performance.getEntriesByName = jest.fn().mockReturnValue([ exampleResourceTiming ]);
+        window.performance.getEntriesByName = jest.fn().mockReturnValue([exampleResourceTiming]);
 
         const layerIndex = new StyleLayerIndex(layers);
         const source = new GeoJSONWorkerSource(actor, layerIndex, [], (params, callback) => {
@@ -140,7 +140,7 @@ describe('resourceTiming', () => {
 
         source.loadData({source: 'testSource', request: {url: 'http://localhost/nonexistent', collectResourceTiming: true}} as LoadGeoJSONParameters, (err, result) => {
             expect(err).toBeNull();
-            expect(result.resourceTiming.testSource).toEqual([ exampleResourceTiming ]);
+            expect(result.resourceTiming.testSource).toEqual([exampleResourceTiming]);
             done();
         });
     });

package/src/source/geojson_wrapper.test.ts

@@ -14,7 +14,7 @@ describe('geojsonwrapper', () => {
         expect(feature).toBeTruthy();
         expect(feature.loadGeometry()).toEqual([[{x: 0, y: 0}, {x: 10, y: 10}]]);
         expect(feature.type).toBe(2);
-        expect(feature.properties).toEqual({hello:'world'});
+        expect(feature.properties).toEqual({hello: 'world'});
 
     });
 

package/src/source/image_source.test.ts

@@ -47,7 +47,7 @@ describe('ImageSource', () => {
     };
 
     test('constructor', () => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
 
         expect(source.minzoom).toBe(0);
         expect(source.maxzoom).toBe(22);
@@ -55,7 +55,7 @@ describe('ImageSource', () => {
     });
 
     test('fires dataloading event', () => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         source.on('dataloading', (e) => {
             expect(e.dataType).toBe('source');
         });
@@ -65,7 +65,7 @@ describe('ImageSource', () => {
     });
 
     test('transforms url request', () => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         const map = new StubMap() as any;
         const spy = jest.spyOn(map._requestManager, 'transformRequest');
         source.onAdd(map);
@@ -76,7 +76,7 @@ describe('ImageSource', () => {
     });
 
     test('updates url from updateImage', () => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         const map = new StubMap() as any;
         const spy = jest.spyOn(map._requestManager, 'transformRequest');
         source.onAdd(map);
@@ -92,7 +92,7 @@ describe('ImageSource', () => {
     });
 
     test('sets coordinates', () => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         const map = new StubMap() as any;
         source.onAdd(map);
         respond();
@@ -104,7 +104,7 @@ describe('ImageSource', () => {
     });
 
     test('sets coordinates via updateImage', () => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         const map = new StubMap() as any;
         source.onAdd(map);
         respond();
@@ -120,7 +120,7 @@ describe('ImageSource', () => {
     });
 
     test('fires data event when content is loaded', done => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         source.on('data', (e) => {
             if (e.dataType === 'source' && e.sourceDataType === 'content') {
                 expect(typeof source.tileID == 'object').toBeTruthy();
@@ -132,7 +132,7 @@ describe('ImageSource', () => {
     });
 
     test('fires data event when metadata is loaded', done => {
-        const source = createSource({url : '/image.png'});
+        const source = createSource({url: '/image.png'});
         source.on('data', (e) => {
             if (e.dataType === 'source' && e.sourceDataType === 'metadata') {
                 done();

package/src/source/image_source.ts

@@ -209,7 +209,7 @@ class ImageSource extends Evented implements Source {
             delete this.boundsBuffer;
         }
 
-        this.fire(new Event('data', {dataType:'source', sourceDataType: 'content'}));
+        this.fire(new Event('data', {dataType: 'source', sourceDataType: 'content'}));
         return this;
     }
 

package/src/source/load_tilejson.ts

@@ -7,8 +7,13 @@ import type {RequestManager} from '../util/request_manager';
 import type {Callback} from '../types/callback';
 import type {TileJSON} from '../types/tilejson';
 import type {Cancelable} from '../types/cancelable';
+import type {RasterDEMSourceSpecification, RasterSourceSpecification, VectorSourceSpecification} from '../style-spec/types.g';
 
-export default function(options: any, requestManager: RequestManager, callback: Callback<TileJSON>): Cancelable {
+export default function loadTileJson(
+    options: RasterSourceSpecification | RasterDEMSourceSpecification | VectorSourceSpecification,
+    requestManager: RequestManager,
+    callback: Callback<TileJSON>
+): Cancelable {
     const loaded = function(err: Error, tileJSON: any) {
         if (err) {
             return callback(err);

package/src/source/pixels_to_tile_units.ts

@@ -14,7 +14,7 @@ import type {OverscaledTileID} from './tile_id';
  * @returns value in tile units
  * @private
  */
-export default function(
+export default function pixelsToTileUnits(
     tile: {
         tileID: OverscaledTileID;
         tileSize: number;

package/src/source/raster_tile_source.test.ts

@@ -79,7 +79,7 @@ describe('RasterTileSource', () => {
 
         source.on('data', (e) => {
             if (e.sourceDataType === 'metadata') {
-                expect(source.tileBounds.bounds).toEqual({_sw:{lng: -47, lat: -7}, _ne:{lng: -45, lat: 90}});
+                expect(source.tileBounds.bounds).toEqual({_sw: {lng: -47, lat: -7}, _ne: {lng: -45, lat: 90}});
                 done();
             }
         });

package/src/source/source_cache.test.ts

@@ -485,7 +485,7 @@ describe('SourceCache / Source lifecycle', () => {
         transform.resize(511, 511);
         transform.zoom = 0;
 
-        const expected = [ new OverscaledTileID(0, 0, 0, 0, 0).key, new OverscaledTileID(0, 0, 0, 0, 0).key ];
+        const expected = [new OverscaledTileID(0, 0, 0, 0, 0).key, new OverscaledTileID(0, 0, 0, 0, 0).key];
         expect.assertions(expected.length);
 
         const sourceCache = createSourceCache({
@@ -1054,9 +1054,9 @@ describe('SourceCache#_updateRetainedTiles', () => {
 
         expect(retained).toEqual({
             // parent of ideal tile 0/0/0
-            '000' : new OverscaledTileID(0, 0, 0, 0, 0),
+            '000': new OverscaledTileID(0, 0, 0, 0, 0),
             // ideal tile id 1/0/1
-            '211' : new OverscaledTileID(1, 0, 1, 0, 1)
+            '211': new OverscaledTileID(1, 0, 1, 0, 1)
         });
 
         addTileSpy.mockClear();
@@ -1069,7 +1069,7 @@ describe('SourceCache#_updateRetainedTiles', () => {
         expect(getTileSpy).not.toHaveBeenCalled();
         expect(retainedLoaded).toEqual({
             // only ideal tile retained
-            '211' : new OverscaledTileID(1, 0, 1, 0, 1)
+            '211': new OverscaledTileID(1, 0, 1, 0, 1)
         });
     });
 
@@ -1119,9 +1119,9 @@ describe('SourceCache#_updateRetainedTiles', () => {
         expect(retained).toEqual({
             // parent of ideal tile (0, 0, 0) (only partially covered by loaded child
             // tiles, so we still need to load the parent)
-            '000' : new OverscaledTileID(0, 0, 0, 0, 0),
+            '000': new OverscaledTileID(0, 0, 0, 0, 0),
             // ideal tile id (1, 0, 0)
-            '011' : new OverscaledTileID(1, 0, 1, 0, 0),
+            '011': new OverscaledTileID(1, 0, 1, 0, 0),
             // loaded child tile (2, 0, 0)
             '022': new OverscaledTileID(2, 0, 2, 0, 0)
         });
@@ -1134,9 +1134,9 @@ describe('SourceCache#_updateRetainedTiles', () => {
         expect(retained).toEqual({
             // parent of ideal tile (0, 0, 0) (only partially covered by loaded child
             // tiles, so we still need to load the parent)
-            '000' : new OverscaledTileID(0, 0, 0, 0, 0),
+            '000': new OverscaledTileID(0, 0, 0, 0, 0),
             // ideal tile id (1, 0, 0)
-            '011' : new OverscaledTileID(1, 0, 1, 0, 0)
+            '011': new OverscaledTileID(1, 0, 1, 0, 0)
         });
 
     });
@@ -1163,7 +1163,7 @@ describe('SourceCache#_updateRetainedTiles', () => {
 
         expect(retained).toEqual({
             // ideal tile id (2, 0, 0)
-            '022' : new OverscaledTileID(2, 0, 2, 0, 0)
+            '022': new OverscaledTileID(2, 0, 2, 0, 0)
         });
 
     });
@@ -1191,7 +1191,7 @@ describe('SourceCache#_updateRetainedTiles', () => {
 
         expect(retained).toEqual({
             // ideal tile id (2, 0, 0)
-            '022' : new OverscaledTileID(2, 0, 2, 0, 0)
+            '022': new OverscaledTileID(2, 0, 2, 0, 0)
         });
 
     });
@@ -1352,7 +1352,7 @@ describe('SourceCache#tilesIn', () => {
                 expect(tiles[0].tile.tileID.key).toBe('011');
                 expect(tiles[0].tile.tileSize).toBe(512);
                 expect(tiles[0].scale).toBe(1);
-                expect(round(tiles[0].queryGeometry)).toEqual([{x: 4096, y: 4050}, {x:12288, y: 8146}]);
+                expect(round(tiles[0].queryGeometry)).toEqual([{x: 4096, y: 4050}, {x: 12288, y: 8146}]);
 
                 expect(tiles[1].tile.tileID.key).toBe('111');
                 expect(tiles[1].tile.tileSize).toBe(512);
@@ -1404,7 +1404,7 @@ describe('SourceCache#tilesIn', () => {
                 expect(tiles[0].tile.tileID.key).toBe('012');
                 expect(tiles[0].tile.tileSize).toBe(1024);
                 expect(tiles[0].scale).toBe(1);
-                expect(round(tiles[0].queryGeometry)).toEqual([{x: 4096, y: 4050}, {x:12288, y: 8146}]);
+                expect(round(tiles[0].queryGeometry)).toEqual([{x: 4096, y: 4050}, {x: 12288, y: 8146}]);
 
                 expect(tiles[1].tile.tileID.key).toBe('112');
                 expect(tiles[1].tile.tileSize).toBe(1024);

package/src/source/source_cache.ts

@@ -492,7 +492,7 @@ class SourceCache extends Evented {
      * are inside the viewport.
      * @private
      */
-    update(transform: Transform, terrain: Terrain) {
+    update(transform: Transform, terrain?: Terrain) {
         this.transform = transform;
         this.terrain = terrain;
         if (!this._sourceLoaded || this._paused) { return; }

package/src/source/terrain_source_cache.test.ts

@@ -9,6 +9,9 @@ import Painter from '../render/painter';
 import Context from '../gl/context';
 import gl from 'gl';
 import RasterDEMTileSource from './raster_dem_tile_source';
+import {OverscaledTileID} from './tile_id';
+import Tile from './tile';
+import DEMData from '../data/dem_data';
 
 const context = new Context(gl(10, 10));
 const transform = new Transform();
@@ -54,8 +57,8 @@ describe('TerrainSourceCache', () => {
         global.fetch = null;
         server = fakeServer.create();
         server.respondWith('/source.json', JSON.stringify({
-            minzoom: 0,
-            maxzoom: 22,
+            minzoom: 5,
+            maxzoom: 12,
             attribution: 'MapLibre',
             tiles: ['http://example.com/{z}/{x}/{y}.pngraw'],
             bounds: [-47, -7, -45, -5]
@@ -86,4 +89,16 @@ describe('TerrainSourceCache', () => {
         expect(tsc.sourceCache.tileSize).toBe(tsc.tileSize * 2 ** tsc.deltaZoom);
     });
 
+    test('#getSourceTile', () => {
+        const tileID = new OverscaledTileID(5, 0, 5, 17, 11);
+        const tile = new Tile(tileID, 256);
+        tile.dem = {} as DEMData;
+        tsc.sourceCache._tiles[tileID.key] = tile;
+        expect(tsc.deltaZoom).toBe(1);
+        expect(tsc.getSourceTile(tileID)).toBeFalsy();
+        expect(tsc.getSourceTile(tileID.children(12)[0])).toBeTruthy();
+        expect(tsc.getSourceTile(tileID.children(12)[0].children(12)[0])).toBeFalsy();
+        expect(tsc.getSourceTile(tileID.children(12)[0].children(12)[0], true)).toBeTruthy();
+    });
+
 });

package/src/source/terrain_source_cache.ts

@@ -50,7 +50,7 @@ export default class TerrainSourceCache extends Evented {
         this.maxzoom = 22;
         this.tileSize = 512;
         this.deltaZoom = 1;
-        this.renderHistorySize = 150;
+        this.renderHistorySize = sourceCache._cache.max;
         sourceCache.usedForTerrain = true;
         sourceCache.tileSize = this.tileSize * 2 ** this.deltaZoom;
     }
@@ -98,15 +98,19 @@ export default class TerrainSourceCache extends Evented {
     removeOutdated(painter: Painter) {
         // create lookuptable for actual needed tiles
         const tileIDs = {};
+        // remove duplicates from renderHistory and chop to renderHistorySize
+        this.renderHistory = this.renderHistory.filter((i, p) => {
+            return this.renderHistory.indexOf(i) === p;
+        }).slice(0, this.renderHistorySize);
+        // fill lookuptable with current rendered tiles
         for (const key of this._renderableTilesKeys) tileIDs[key] = true;
-        // remove duplicates from renderHistory
-        this.renderHistory = this.renderHistory.filter((i, p) => this.renderHistory.indexOf(i) === p);
+        // fill lookuptable with most recent rendered tiles outside the viewport
+        for (const key of this.renderHistory) tileIDs[key] = true;
         // free (GPU) memory from previously rendered not needed tiles
-        while (this.renderHistory.length > this.renderHistorySize) {
-            const tile = this.sourceCache._tiles[this.renderHistory.shift()];
-            if (tile && !tileIDs[tile.tileID.key]) {
-                tile.clearTextures(painter);
-                delete this.sourceCache._tiles[tile.tileID.key];
+        for (const key in this._tiles) {
+            if (!tileIDs[key]) {
+                this._tiles[key].clearTextures(painter);
+                delete this._tiles[key];
             }
         }
     }
@@ -129,11 +133,11 @@ export default class TerrainSourceCache extends Evented {
     }
 
     /**
-     * searches for the corresponding current renderable terrain-tiles
+     * Searches for the corresponding current renderable terrain-tiles
      * @param {OverscaledTileID} tileID - the tile to look for
-     * @returns {[_:string]: Tile} - the tiles that were found
+     * @returns {Record<string, OverscaledTileID>} - the tiles that were found
      */
-    getTerrainCoords(tileID: OverscaledTileID): {[_: string]: OverscaledTileID} {
+    getTerrainCoords(tileID: OverscaledTileID): Record<string, OverscaledTileID> {
         const coords = {};
         for (const key of this._renderableTilesKeys) {
             const _tileID = this._tiles[key].tileID;
@@ -185,7 +189,7 @@ export default class TerrainSourceCache extends Evented {
         let tile = this.sourceCache.getTileByID(this._sourceTileCache[tileID.key]);
         // during tile-loading phase look if parent tiles (with loaded dem) are available.
         if (!(tile && tile.dem) && searchForDEM)
-            while (z > source.minzoom && !(tile && tile.dem))
+            while (z >= source.minzoom && !(tile && tile.dem))
                 tile = this.sourceCache.getTileByID(tileID.scaledTo(z--).key);
         return tile;
     }

package/src/source/vector_tile_source.test.ts

@@ -253,7 +253,7 @@ describe('VectorTileSource', () => {
 
         source.on('data', (e) => {
             if (e.sourceDataType === 'metadata') {
-                expect(source.tileBounds.bounds).toEqual({_sw:{lng: -47, lat: -7}, _ne:{lng: -45, lat: 90}});
+                expect(source.tileBounds.bounds).toEqual({_sw: {lng: -47, lat: -7}, _ne: {lng: -45, lat: 90}});
                 done();
             }
         });

package/src/source/vector_tile_worker_source.test.ts

@@ -236,7 +236,7 @@ describe('vector tile worker source', () => {
 
         const source = new VectorTileWorkerSource(actor, layerIndex, [], loadVectorData);
 
-        window.performance.getEntriesByName = jest.fn().mockReturnValue([ exampleResourceTiming ]);
+        window.performance.getEntriesByName = jest.fn().mockReturnValue([exampleResourceTiming]);
 
         source.loadTile({
             source: 'source',