maplibre-gl 2.1.1 → 2.1.2

package/src/render/glyph_manager.ts

@@ -10,26 +10,26 @@ import type {RequestManager} from '../util/request_manager';
 import type {Callback} from '../types/callback';
 
 type Entry = {
-  // null means we've requested the range, but the glyph wasn't included in the result.
-  glyphs: {
-    [id: number]: StyleGlyph | null;
-  };
-  requests: {
-    [range: number]: Array<Callback<{
-      [_: number]: StyleGlyph | null;
-    }>>;
-  };
-  ranges: {
-    [range: number]: boolean | null;
-  };
-  tinySDF?: TinySDF;
+    // null means we've requested the range, but the glyph wasn't included in the result.
+    glyphs: {
+        [id: number]: StyleGlyph | null;
+    };
+    requests: {
+        [range: number]: Array<Callback<{
+            [_: number]: StyleGlyph | null;
+        }>>;
+    };
+    ranges: {
+        [range: number]: boolean | null;
+    };
+    tinySDF?: TinySDF;
 };
 
 export default class GlyphManager {
     requestManager: RequestManager;
     localIdeographFontFamily: string;
     entries: {
-      [_: string]: Entry;
+        [_: string]: Entry;
     };
     url: string;
 
@@ -48,11 +48,11 @@ export default class GlyphManager {
     }
 
     getGlyphs(glyphs: {
-      [stack: string]: Array<number>;
+        [stack: string]: Array<number>;
     }, callback: Callback<{
-      [stack: string]: {
-        [id: number]: StyleGlyph;
-      };
+        [stack: string]: {
+            [id: number]: StyleGlyph;
+        };
     }>) {
         const all = [];
 
@@ -63,9 +63,9 @@ export default class GlyphManager {
         }
 
         asyncAll(all, ({stack, id}, callback: Callback<{
-          stack: string;
-          id: number;
-          glyph: StyleGlyph;
+            stack: string;
+            id: number;
+            glyph: StyleGlyph;
         }>) => {
             let entry = this.entries[stack];
             if (!entry) {
@@ -105,7 +105,7 @@ export default class GlyphManager {
                 requests = entry.requests[range] = [];
                 GlyphManager.loadGlyphRange(stack, range, this.url, this.requestManager,
                     (err, response?: {
-                      [_: number]: StyleGlyph | null;
+                        [_: number]: StyleGlyph | null;
                     } | null) => {
                         if (response) {
                             for (const id in response) {
@@ -123,7 +123,7 @@ export default class GlyphManager {
             }
 
             requests.push((err, result?: {
-              [_: number]: StyleGlyph | null;
+                [_: number]: StyleGlyph | null;
             } | null) => {
                 if (err) {
                     callback(err);
@@ -132,9 +132,9 @@ export default class GlyphManager {
                 }
             });
         }, (err, glyphs?: Array<{
-          stack: string;
-          id: number;
-          glyph: StyleGlyph;
+            stack: string;
+            id: number;
+            glyph: StyleGlyph;
         }> | null) => {
             if (err) {
                 callback(err);
@@ -195,15 +195,16 @@ export default class GlyphManager {
             });
         }
 
+        const char = tinySDF.draw(String.fromCharCode(id));
         return {
             id,
-            bitmap: new AlphaImage({width: 30, height: 30}, tinySDF.draw(String.fromCharCode(id)).data),
+            bitmap: new AlphaImage({width: char.width || 30, height: char.height || 30}, char.data),
             metrics: {
-                width: 24,
-                height: 24,
-                left: 0,
-                top: -8,
-                advance: 24
+                width: char.glyphWidth || 24,
+                height: char.glyphHeight || 24,
+                left: char.glyphLeft || 0,
+                top: char.glyphTop || -8,
+                advance: char.glyphAdvance || 24
             }
         };
     }

package/src/render/image_manager.ts

@@ -14,8 +14,8 @@ import type {PotpackBox} from 'potpack';
 import type {Callback} from '../types/callback';
 
 type Pattern = {
-  bin: PotpackBox;
-  position: ImagePosition;
+    bin: PotpackBox;
+    position: ImagePosition;
 };
 
 // When copied into the atlas texture, image data is padded by one pixel on each side. Icon
@@ -41,8 +41,8 @@ class ImageManager extends Evented {
     callbackDispatchedThisFrame: {[_: string]: boolean};
     loaded: boolean;
     requestors: Array<{
-      ids: Array<string>;
-      callback: Callback<{[_: string]: StyleImage}>;
+        ids: Array<string>;
+        callback: Callback<{[_: string]: StyleImage}>;
     }>;
 
     patterns: {[_: string]: Pattern};

package/src/render/painter.ts

@@ -5,7 +5,7 @@ import SourceCache from '../source/source_cache';
 import EXTENT from '../data/extent';
 import pixelsToTileUnits from '../source/pixels_to_tile_units';
 import SegmentVector from '../data/segment';
-import {RasterBoundsArray, PosArray, TriangleIndexArray, LineStripIndexArray} from '../data/array_types';
+import {RasterBoundsArray, PosArray, TriangleIndexArray, LineStripIndexArray} from '../data/array_types.g';
 import rasterBoundsAttributes from '../data/raster_bounds_attributes';
 import posAttributes from '../data/pos_attributes';
 import ProgramConfiguration from '../data/program_configuration';
@@ -65,14 +65,14 @@ import type {RGBAImage} from '../util/image';
 export type RenderPass = 'offscreen' | 'opaque' | 'translucent';
 
 type PainterOptions = {
-  showOverdrawInspector: boolean;
-  showTileBoundaries: boolean;
-  showPadding: boolean;
-  rotating: boolean;
-  zooming: boolean;
-  moving: boolean;
-  gpuTiming: boolean;
-  fadeDuration: number;
+    showOverdrawInspector: boolean;
+    showTileBoundaries: boolean;
+    showPadding: boolean;
+    rotating: boolean;
+    zooming: boolean;
+    moving: boolean;
+    gpuTiming: boolean;
+    fadeDuration: number;
 };
 
 /**
@@ -85,7 +85,7 @@ class Painter {
     context: Context;
     transform: Transform;
     _tileTextures: {
-      [_: number]: Array<Texture>;
+        [_: number]: Array<Texture>;
     };
     numSublayers: number;
     depthEpsilon: number;
@@ -305,7 +305,7 @@ class Painter {
      * Returns [StencilMode for tile overscaleZ map, sortedCoords].
      */
     stencilConfigForOverlap(tileIDs: Array<OverscaledTileID>): [{
-      [_: number]: Readonly<StencilMode>;
+        [_: number]: Readonly<StencilMode>;
     }, Array<OverscaledTileID>] {
         const gl = this.context.gl;
         const coords = tileIDs.sort((a, b) => b.overscaledZ - a.overscaledZ);

package/src/render/program/background_program.ts

@@ -19,29 +19,29 @@ import type ResolvedImage from '../../style-spec/expression/types/resolved_image
 import {mat4} from 'gl-matrix';
 
 export type BackgroundUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_opacity': Uniform1f;
-  'u_color': UniformColor;
+    'u_matrix': UniformMatrix4f;
+    'u_opacity': Uniform1f;
+    'u_color': UniformColor;
 };
 
 export type BackgroundPatternUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_opacity': Uniform1f;
-  // pattern uniforms:
-  'u_image': Uniform1i;
-  'u_pattern_tl_a': Uniform2f;
-  'u_pattern_br_a': Uniform2f;
-  'u_pattern_tl_b': Uniform2f;
-  'u_pattern_br_b': Uniform2f;
-  'u_texsize': Uniform2f;
-  'u_mix': Uniform1f;
-  'u_pattern_size_a': Uniform2f;
-  'u_pattern_size_b': Uniform2f;
-  'u_scale_a': Uniform1f;
-  'u_scale_b': Uniform1f;
-  'u_pixel_coord_upper': Uniform2f;
-  'u_pixel_coord_lower': Uniform2f;
-  'u_tile_units_to_pixels': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    'u_opacity': Uniform1f;
+    // pattern uniforms:
+    'u_image': Uniform1i;
+    'u_pattern_tl_a': Uniform2f;
+    'u_pattern_br_a': Uniform2f;
+    'u_pattern_tl_b': Uniform2f;
+    'u_pattern_br_b': Uniform2f;
+    'u_texsize': Uniform2f;
+    'u_mix': Uniform1f;
+    'u_pattern_size_a': Uniform2f;
+    'u_pattern_size_b': Uniform2f;
+    'u_scale_a': Uniform1f;
+    'u_scale_b': Uniform1f;
+    'u_pixel_coord_upper': Uniform2f;
+    'u_pixel_coord_lower': Uniform2f;
+    'u_tile_units_to_pixels': Uniform1f;
 };
 
 const backgroundUniforms = (context: Context, locations: UniformLocations): BackgroundUniformsType => ({
@@ -76,15 +76,15 @@ const backgroundUniformValues = (matrix: mat4, opacity: number, color: Color): U
 });
 
 const backgroundPatternUniformValues = (
-  matrix: mat4,
-  opacity: number,
-  painter: Painter,
-  image: CrossFaded<ResolvedImage>,
-  tile: {
-    tileID: OverscaledTileID;
-    tileSize: number;
-  },
-  crossfade: CrossfadeParameters
+    matrix: mat4,
+    opacity: number,
+    painter: Painter,
+    image: CrossFaded<ResolvedImage>,
+    tile: {
+        tileID: OverscaledTileID;
+        tileSize: number;
+    },
+    crossfade: CrossfadeParameters
 ): UniformValues<BackgroundPatternUniformsType> => extend(
     bgPatternUniformValues(image, crossfade, painter, tile),
     {

package/src/render/program/circle_program.ts

@@ -9,12 +9,12 @@ import type CircleStyleLayer from '../../style/style_layer/circle_style_layer';
 import type Painter from '../painter';
 
 export type CircleUniformsType = {
-  'u_camera_to_center_distance': Uniform1f;
-  'u_scale_with_map': Uniform1i;
-  'u_pitch_with_map': Uniform1i;
-  'u_extrude_scale': Uniform2f;
-  'u_device_pixel_ratio': Uniform1f;
-  'u_matrix': UniformMatrix4f;
+    'u_camera_to_center_distance': Uniform1f;
+    'u_scale_with_map': Uniform1i;
+    'u_pitch_with_map': Uniform1i;
+    'u_extrude_scale': Uniform2f;
+    'u_device_pixel_ratio': Uniform1f;
+    'u_matrix': UniformMatrix4f;
 };
 
 const circleUniforms = (context: Context, locations: UniformLocations): CircleUniformsType => ({
@@ -27,10 +27,10 @@ const circleUniforms = (context: Context, locations: UniformLocations): CircleUn
 });
 
 const circleUniformValues = (
-  painter: Painter,
-  coord: OverscaledTileID,
-  tile: Tile,
-  layer: CircleStyleLayer
+    painter: Painter,
+    coord: OverscaledTileID,
+    tile: Tile,
+    layer: CircleStyleLayer
 ): UniformValues<CircleUniformsType> => {
     const transform = painter.transform;
 

package/src/render/program/clipping_mask_program.ts

@@ -5,7 +5,7 @@ import type {UniformValues, UniformLocations} from '../uniform_binding';
 import {mat4} from 'gl-matrix';
 
 export type ClippingMaskUniformsType = {
-  'u_matrix': UniformMatrix4f;
+    'u_matrix': UniformMatrix4f;
 };
 
 const clippingMaskUniforms = (context: Context, locations: UniformLocations): ClippingMaskUniformsType => ({

package/src/render/program/collision_program.ts

@@ -8,18 +8,18 @@ import type Tile from '../../source/tile';
 import {mat4} from 'gl-matrix';
 
 export type CollisionUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_camera_to_center_distance': Uniform1f;
-  'u_pixels_to_tile_units': Uniform1f;
-  'u_extrude_scale': Uniform2f;
-  'u_overscale_factor': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    'u_camera_to_center_distance': Uniform1f;
+    'u_pixels_to_tile_units': Uniform1f;
+    'u_extrude_scale': Uniform2f;
+    'u_overscale_factor': Uniform1f;
 };
 
 export type CollisionCircleUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_inv_matrix': UniformMatrix4f;
-  'u_camera_to_center_distance': Uniform1f;
-  'u_viewport_size': Uniform2f;
+    'u_matrix': UniformMatrix4f;
+    'u_inv_matrix': UniformMatrix4f;
+    'u_camera_to_center_distance': Uniform1f;
+    'u_viewport_size': Uniform2f;
 };
 
 const collisionUniforms = (context: Context, locations: UniformLocations): CollisionUniformsType => ({

package/src/render/program/debug_program.ts

@@ -6,10 +6,10 @@ import type Color from '../../style-spec/util/color';
 import {mat4} from 'gl-matrix';
 
 export type DebugUniformsType = {
-  'u_color': UniformColor;
-  'u_matrix': UniformMatrix4f;
-  'u_overlay': Uniform1i;
-  'u_overlay_scale': Uniform1f;
+    'u_color': UniformColor;
+    'u_matrix': UniformMatrix4f;
+    'u_overlay': Uniform1i;
+    'u_overlay_scale': Uniform1f;
 };
 
 const debugUniforms = (context: Context, locations: UniformLocations): DebugUniformsType => ({

package/src/render/program/fill_extrusion_program.ts

@@ -18,29 +18,29 @@ import type {CrossfadeParameters} from '../../style/evaluation_parameters';
 import type Tile from '../../source/tile';
 
 export type FillExtrusionUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_lightpos': Uniform3f;
-  'u_lightintensity': Uniform1f;
-  'u_lightcolor': Uniform3f;
-  'u_vertical_gradient': Uniform1f;
-  'u_opacity': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    'u_lightpos': Uniform3f;
+    'u_lightintensity': Uniform1f;
+    'u_lightcolor': Uniform3f;
+    'u_vertical_gradient': Uniform1f;
+    'u_opacity': Uniform1f;
 };
 
 export type FillExtrusionPatternUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_lightpos': Uniform3f;
-  'u_lightintensity': Uniform1f;
-  'u_lightcolor': Uniform3f;
-  'u_height_factor': Uniform1f;
-  'u_vertical_gradient': Uniform1f;
-  // pattern uniforms:
-  'u_texsize': Uniform2f;
-  'u_image': Uniform1i;
-  'u_pixel_coord_upper': Uniform2f;
-  'u_pixel_coord_lower': Uniform2f;
-  'u_scale': Uniform3f;
-  'u_fade': Uniform1f;
-  'u_opacity': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    'u_lightpos': Uniform3f;
+    'u_lightintensity': Uniform1f;
+    'u_lightcolor': Uniform3f;
+    'u_height_factor': Uniform1f;
+    'u_vertical_gradient': Uniform1f;
+    // pattern uniforms:
+    'u_texsize': Uniform2f;
+    'u_image': Uniform1i;
+    'u_pixel_coord_upper': Uniform2f;
+    'u_pixel_coord_lower': Uniform2f;
+    'u_scale': Uniform3f;
+    'u_fade': Uniform1f;
+    'u_opacity': Uniform1f;
 };
 
 const fillExtrusionUniforms = (context: Context, locations: UniformLocations): FillExtrusionUniformsType => ({
@@ -70,10 +70,10 @@ const fillExtrusionPatternUniforms = (context: Context, locations: UniformLocati
 });
 
 const fillExtrusionUniformValues = (
-  matrix: mat4,
-  painter: Painter,
-  shouldUseVerticalGradient: boolean,
-  opacity: number
+    matrix: mat4,
+    painter: Painter,
+    shouldUseVerticalGradient: boolean,
+    opacity: number
 ): UniformValues<FillExtrusionUniformsType> => {
     const light = painter.style.light;
     const _lp = light.properties.get('position');
@@ -97,13 +97,13 @@ const fillExtrusionUniformValues = (
 };
 
 const fillExtrusionPatternUniformValues = (
-  matrix: mat4,
-  painter: Painter,
-  shouldUseVerticalGradient: boolean,
-  opacity: number,
-  coord: OverscaledTileID,
-  crossfade: CrossfadeParameters,
-  tile: Tile
+    matrix: mat4,
+    painter: Painter,
+    shouldUseVerticalGradient: boolean,
+    opacity: number,
+    coord: OverscaledTileID,
+    crossfade: CrossfadeParameters,
+    tile: Tile
 ): UniformValues<FillExtrusionPatternUniformsType> => {
     return extend(fillExtrusionUniformValues(matrix, painter, shouldUseVerticalGradient, opacity),
         patternUniformValues(crossfade, painter, tile),

package/src/render/program/fill_program.ts

@@ -16,35 +16,35 @@ import type Tile from '../../source/tile';
 import {mat4} from 'gl-matrix';
 
 export type FillUniformsType = {
-  'u_matrix': UniformMatrix4f;
+    'u_matrix': UniformMatrix4f;
 };
 
 export type FillOutlineUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_world': Uniform2f;
+    'u_matrix': UniformMatrix4f;
+    'u_world': Uniform2f;
 };
 
 export type FillPatternUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  // pattern uniforms:
-  'u_texsize': Uniform2f;
-  'u_image': Uniform1i;
-  'u_pixel_coord_upper': Uniform2f;
-  'u_pixel_coord_lower': Uniform2f;
-  'u_scale': Uniform3f;
-  'u_fade': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    // pattern uniforms:
+    'u_texsize': Uniform2f;
+    'u_image': Uniform1i;
+    'u_pixel_coord_upper': Uniform2f;
+    'u_pixel_coord_lower': Uniform2f;
+    'u_scale': Uniform3f;
+    'u_fade': Uniform1f;
 };
 
 export type FillOutlinePatternUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_world': Uniform2f;
-  // pattern uniforms:
-  'u_texsize': Uniform2f;
-  'u_image': Uniform1i;
-  'u_pixel_coord_upper': Uniform2f;
-  'u_pixel_coord_lower': Uniform2f;
-  'u_scale': Uniform3f;
-  'u_fade': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    'u_world': Uniform2f;
+    // pattern uniforms:
+    'u_texsize': Uniform2f;
+    'u_image': Uniform1i;
+    'u_pixel_coord_upper': Uniform2f;
+    'u_pixel_coord_lower': Uniform2f;
+    'u_scale': Uniform3f;
+    'u_fade': Uniform1f;
 };
 
 const fillUniforms = (context: Context, locations: UniformLocations): FillUniformsType => ({
@@ -82,10 +82,10 @@ const fillUniformValues = (matrix: mat4): UniformValues<FillUniformsType> => ({
 });
 
 const fillPatternUniformValues = (
-  matrix: mat4,
-  painter: Painter,
-  crossfade: CrossfadeParameters,
-  tile: Tile
+    matrix: mat4,
+    painter: Painter,
+    crossfade: CrossfadeParameters,
+    tile: Tile
 ): UniformValues<FillPatternUniformsType> => extend(
     fillUniformValues(matrix),
     patternUniformValues(crossfade, painter, tile)
@@ -97,11 +97,11 @@ const fillOutlineUniformValues = (matrix: mat4, drawingBufferSize: [number, numb
 });
 
 const fillOutlinePatternUniformValues = (
-  matrix: mat4,
-  painter: Painter,
-  crossfade: CrossfadeParameters,
-  tile: Tile,
-  drawingBufferSize: [number, number]
+    matrix: mat4,
+    painter: Painter,
+    crossfade: CrossfadeParameters,
+    tile: Tile,
+    drawingBufferSize: [number, number]
 ): UniformValues<FillOutlinePatternUniformsType> => extend(
     fillPatternUniformValues(matrix, painter, crossfade, tile),
     {

package/src/render/program/heatmap_program.ts

@@ -15,17 +15,17 @@ import type Painter from '../painter';
 import type HeatmapStyleLayer from '../../style/style_layer/heatmap_style_layer';
 
 export type HeatmapUniformsType = {
-  'u_extrude_scale': Uniform1f;
-  'u_intensity': Uniform1f;
-  'u_matrix': UniformMatrix4f;
+    'u_extrude_scale': Uniform1f;
+    'u_intensity': Uniform1f;
+    'u_matrix': UniformMatrix4f;
 };
 
 export type HeatmapTextureUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_world': Uniform2f;
-  'u_image': Uniform1i;
-  'u_color_ramp': Uniform1i;
-  'u_opacity': Uniform1f;
+    'u_matrix': UniformMatrix4f;
+    'u_world': Uniform2f;
+    'u_image': Uniform1i;
+    'u_color_ramp': Uniform1i;
+    'u_opacity': Uniform1f;
 };
 
 const heatmapUniforms = (context: Context, locations: UniformLocations): HeatmapUniformsType => ({
@@ -49,10 +49,10 @@ const heatmapUniformValues = (matrix: mat4, tile: Tile, zoom: number, intensity:
 });
 
 const heatmapTextureUniformValues = (
-  painter: Painter,
-  layer: HeatmapStyleLayer,
-  textureUnit: number,
-  colorRampUnit: number
+    painter: Painter,
+    layer: HeatmapStyleLayer,
+    textureUnit: number,
+    colorRampUnit: number
 ): UniformValues<HeatmapTextureUniformsType> => {
     const matrix = mat4.create();
     mat4.ortho(matrix, 0, painter.width, painter.height, 0, 0, 1);

package/src/render/program/hillshade_program.ts

@@ -20,21 +20,21 @@ import type DEMData from '../../data/dem_data';
 import type {OverscaledTileID} from '../../source/tile_id';
 
 export type HillshadeUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_image': Uniform1i;
-  'u_latrange': Uniform2f;
-  'u_light': Uniform2f;
-  'u_shadow': UniformColor;
-  'u_highlight': UniformColor;
-  'u_accent': UniformColor;
+    'u_matrix': UniformMatrix4f;
+    'u_image': Uniform1i;
+    'u_latrange': Uniform2f;
+    'u_light': Uniform2f;
+    'u_shadow': UniformColor;
+    'u_highlight': UniformColor;
+    'u_accent': UniformColor;
 };
 
 export type HillshadePrepareUniformsType = {
-  'u_matrix': UniformMatrix4f;
-  'u_image': Uniform1i;
-  'u_dimension': Uniform2f;
-  'u_zoom': Uniform1f;
-  'u_unpack': Uniform4f;
+    'u_matrix': UniformMatrix4f;
+    'u_image': Uniform1i;
+    'u_dimension': Uniform2f;
+    'u_zoom': Uniform1f;
+    'u_unpack': Uniform4f;
 };
 
 const hillshadeUniforms = (context: Context, locations: UniformLocations): HillshadeUniformsType => ({