maplibre-gl 2.1.1 → 2.1.2

package/src/style-spec/style-spec.ts

@@ -2,59 +2,59 @@ type ExpressionType = 'data-driven' | 'cross-faded' | 'cross-faded-data-driven'
 type ExpressionParameters = Array<'zoom' | 'feature' | 'feature-state' | 'heatmap-density' | 'line-progress'>;
 
 type ExpressionSpecification = {
-  interpolated: boolean;
-  parameters: ExpressionParameters;
+    interpolated: boolean;
+    parameters: ExpressionParameters;
 };
 
 export type StylePropertySpecification = {
-  type: 'number';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  transition: boolean;
-  default?: number;
+    type: 'number';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition: boolean;
+    default?: number;
 } | {
-  type: 'string';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  transition: boolean;
-  default?: string;
-  tokens?: boolean;
+    type: 'string';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition: boolean;
+    default?: string;
+    tokens?: boolean;
 } | {
-  type: 'boolean';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  transition: boolean;
-  default?: boolean;
+    type: 'boolean';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition: boolean;
+    default?: boolean;
 } | {
-  type: 'enum';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  values: {[_: string]: {}};
-  transition: boolean;
-  default?: string;
+    type: 'enum';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    values: {[_: string]: {}};
+    transition: boolean;
+    default?: string;
 } | {
-  type: 'color';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  transition: boolean;
-  default?: string;
-  overridable: boolean;
+    type: 'color';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    transition: boolean;
+    default?: string;
+    overridable: boolean;
 } | {
-  type: 'array';
-  value: 'number';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  length?: number;
-  transition: boolean;
-  default?: Array<number>;
+    type: 'array';
+    value: 'number';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    length?: number;
+    transition: boolean;
+    default?: Array<number>;
 } | {
-  type: 'array';
-  value: 'string';
-  'property-type': ExpressionType;
-  expression?: ExpressionSpecification;
-  length?: number;
-  transition: boolean;
-  default?: Array<string>;
+    type: 'array';
+    value: 'string';
+    'property-type': ExpressionType;
+    expression?: ExpressionSpecification;
+    length?: number;
+    transition: boolean;
+    default?: Array<string>;
 };
 
 import v8 from './reference/v8.json';

package/src/style-spec/util/color_spaces.ts

@@ -3,17 +3,17 @@ import Color from './color';
 import {number as interpolateNumber} from './interpolate';
 
 type LABColor = {
-  l: number;
-  a: number;
-  b: number;
-  alpha: number;
+    l: number;
+    a: number;
+    b: number;
+    alpha: number;
 };
 
 type HCLColor = {
-  h: number;
-  c: number;
-  l: number;
-  alpha: number;
+    h: number;
+    c: number;
+    l: number;
+    alpha: number;
 };
 
 // Constants

package/src/style-spec/util/result.ts

@@ -5,11 +5,11 @@
  * @private
  */
 export type Result<T, E> = {
-  result: 'success';
-  value: T;
+    result: 'success';
+    value: T;
 } | {
-  result: 'error';
-  value: E;
+    result: 'error';
+    value: E;
 };
 
 export function success<T, E>(value: T): Result<T, E> {

package/src/style-spec/validate/validate_filter.ts

@@ -44,74 +44,74 @@ function validateNonExpressionFilter(options) {
     }));
 
     switch (unbundle(value[0])) {
-    case '<':
-    case '<=':
-    case '>':
-    case '>=':
-        if (value.length >= 2 && unbundle(value[1]) === '$type') {
-            errors.push(new ValidationError(key, value, `"$type" cannot be use with operator "${value[0]}"`));
-        }
+        case '<':
+        case '<=':
+        case '>':
+        case '>=':
+            if (value.length >= 2 && unbundle(value[1]) === '$type') {
+                errors.push(new ValidationError(key, value, `"$type" cannot be use with operator "${value[0]}"`));
+            }
         /* falls through */
-    case '==':
-    case '!=':
-        if (value.length !== 3) {
-            errors.push(new ValidationError(key, value, `filter array for operator "${value[0]}" must have 3 elements`));
-        }
+        case '==':
+        case '!=':
+            if (value.length !== 3) {
+                errors.push(new ValidationError(key, value, `filter array for operator "${value[0]}" must have 3 elements`));
+            }
         /* falls through */
-    case 'in':
-    case '!in':
-        if (value.length >= 2) {
-            type = getType(value[1]);
-            if (type !== 'string') {
-                errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
+        case 'in':
+        case '!in':
+            if (value.length >= 2) {
+                type = getType(value[1]);
+                if (type !== 'string') {
+                    errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
+                }
+            }
+            for (let i = 2; i < value.length; i++) {
+                type = getType(value[i]);
+                if (unbundle(value[1]) === '$type') {
+                    errors = errors.concat(validateEnum({
+                        key: `${key}[${i}]`,
+                        value: value[i],
+                        valueSpec: styleSpec.geometry_type,
+                        style: options.style,
+                        styleSpec: options.styleSpec
+                    }));
+                } else if (type !== 'string' && type !== 'number' && type !== 'boolean') {
+                    errors.push(new ValidationError(`${key}[${i}]`, value[i], `string, number, or boolean expected, ${type} found`));
+                }
             }
-        }
-        for (let i = 2; i < value.length; i++) {
-            type = getType(value[i]);
-            if (unbundle(value[1]) === '$type') {
-                errors = errors.concat(validateEnum({
+            break;
+
+        case 'any':
+        case 'all':
+        case 'none':
+            for (let i = 1; i < value.length; i++) {
+                errors = errors.concat(validateNonExpressionFilter({
                     key: `${key}[${i}]`,
                     value: value[i],
-                    valueSpec: styleSpec.geometry_type,
                     style: options.style,
                     styleSpec: options.styleSpec
                 }));
-            } else if (type !== 'string' && type !== 'number' && type !== 'boolean') {
-                errors.push(new ValidationError(`${key}[${i}]`, value[i], `string, number, or boolean expected, ${type} found`));
             }
-        }
-        break;
+            break;
 
-    case 'any':
-    case 'all':
-    case 'none':
-        for (let i = 1; i < value.length; i++) {
-            errors = errors.concat(validateNonExpressionFilter({
-                key: `${key}[${i}]`,
-                value: value[i],
-                style: options.style,
-                styleSpec: options.styleSpec
-            }));
-        }
-        break;
-
-    case 'has':
-    case '!has':
-        type = getType(value[1]);
-        if (value.length !== 2) {
-            errors.push(new ValidationError(key, value, `filter array for "${value[0]}" operator must have 2 elements`));
-        } else if (type !== 'string') {
-            errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
-        }
-        break;
-    case 'within':
-        type = getType(value[1]);
-        if (value.length !== 2) {
-            errors.push(new ValidationError(key, value, `filter array for "${value[0]}" operator must have 2 elements`));
-        } else if (type !== 'object') {
-            errors.push(new ValidationError(`${key}[1]`, value[1], `object expected, ${type} found`));
-        }
-        break;
+        case 'has':
+        case '!has':
+            type = getType(value[1]);
+            if (value.length !== 2) {
+                errors.push(new ValidationError(key, value, `filter array for "${value[0]}" operator must have 2 elements`));
+            } else if (type !== 'string') {
+                errors.push(new ValidationError(`${key}[1]`, value[1], `string expected, ${type} found`));
+            }
+            break;
+        case 'within':
+            type = getType(value[1]);
+            if (value.length !== 2) {
+                errors.push(new ValidationError(key, value, `filter array for "${value[0]}" operator must have 2 elements`));
+            } else if (type !== 'object') {
+                errors.push(new ValidationError(`${key}[1]`, value[1], `object expected, ${type} found`));
+            }
+            break;
     }
     return errors;
 }

package/src/style-spec/validate/validate_source.ts

@@ -25,76 +25,76 @@ export default function validateSource(options) {
     let errors;
 
     switch (type) {
-    case 'vector':
-    case 'raster':
-    case 'raster-dem':
-        errors = validateObject({
-            key,
-            value,
-            valueSpec: styleSpec[`source_${type.replace('-', '_')}`],
-            style: options.style,
-            styleSpec,
-            objectElementValidators
-        });
-        return errors;
+        case 'vector':
+        case 'raster':
+        case 'raster-dem':
+            errors = validateObject({
+                key,
+                value,
+                valueSpec: styleSpec[`source_${type.replace('-', '_')}`],
+                style: options.style,
+                styleSpec,
+                objectElementValidators
+            });
+            return errors;
 
-    case 'geojson':
-        errors = validateObject({
-            key,
-            value,
-            valueSpec: styleSpec.source_geojson,
-            style,
-            styleSpec,
-            objectElementValidators
-        });
-        if (value.cluster) {
-            for (const prop in value.clusterProperties) {
-                const [operator, mapExpr] = value.clusterProperties[prop];
-                const reduceExpr = typeof operator === 'string' ? [operator, ['accumulated'], ['get', prop]] : operator;
+        case 'geojson':
+            errors = validateObject({
+                key,
+                value,
+                valueSpec: styleSpec.source_geojson,
+                style,
+                styleSpec,
+                objectElementValidators
+            });
+            if (value.cluster) {
+                for (const prop in value.clusterProperties) {
+                    const [operator, mapExpr] = value.clusterProperties[prop];
+                    const reduceExpr = typeof operator === 'string' ? [operator, ['accumulated'], ['get', prop]] : operator;
 
-                errors.push(...validateExpression({
-                    key: `${key}.${prop}.map`,
-                    value: mapExpr,
-                    expressionContext: 'cluster-map'
-                }));
-                errors.push(...validateExpression({
-                    key: `${key}.${prop}.reduce`,
-                    value: reduceExpr,
-                    expressionContext: 'cluster-reduce'
-                }));
+                    errors.push(...validateExpression({
+                        key: `${key}.${prop}.map`,
+                        value: mapExpr,
+                        expressionContext: 'cluster-map'
+                    }));
+                    errors.push(...validateExpression({
+                        key: `${key}.${prop}.reduce`,
+                        value: reduceExpr,
+                        expressionContext: 'cluster-reduce'
+                    }));
+                }
             }
-        }
-        return errors;
+            return errors;
 
-    case 'video':
-        return validateObject({
-            key,
-            value,
-            valueSpec: styleSpec.source_video,
-            style,
-            styleSpec
-        });
+        case 'video':
+            return validateObject({
+                key,
+                value,
+                valueSpec: styleSpec.source_video,
+                style,
+                styleSpec
+            });
 
-    case 'image':
-        return validateObject({
-            key,
-            value,
-            valueSpec: styleSpec.source_image,
-            style,
-            styleSpec
-        });
+        case 'image':
+            return validateObject({
+                key,
+                value,
+                valueSpec: styleSpec.source_image,
+                style,
+                styleSpec
+            });
 
-    case 'canvas':
-        return [new ValidationError(key, null, 'Please use runtime APIs to add canvas sources, rather than including them in stylesheets.', 'source.canvas')];
+        case 'canvas':
+            return [new ValidationError(key, null, 'Please use runtime APIs to add canvas sources, rather than including them in stylesheets.', 'source.canvas')];
 
-    default:
-        return validateEnum({
-            key: `${key}.type`,
-            value: value.type,
-            valueSpec: {values: ['vector', 'raster', 'raster-dem', 'geojson', 'video', 'image']},
-            style,
-            styleSpec
-        });
+        default:
+            return validateEnum({
+                key: `${key}.type`,
+                value: value.type,
+                valueSpec: {values: ['vector', 'raster', 'raster-dem', 'geojson', 'video', 'image']},
+                style,
+                styleSpec
+            });
     }
 }
 

package/src/style-spec/visit.ts

@@ -36,22 +36,22 @@ export function eachLayer(style: StyleSpecification, callback: (_: LayerSpecific
 }
 
 type PropertyCallback = (
-  a: {
-    path: [string, 'paint' | 'layout', string]; // [layerid, paint/layout, property key],
-    key: string;
-    value: PropertyValueSpecification<unknown> | DataDrivenPropertyValueSpecification<unknown>;
-    reference: StylePropertySpecification;
-    set: (
-      a: PropertyValueSpecification<unknown> | DataDrivenPropertyValueSpecification<unknown>
-    ) => void;
-  }
+    a: {
+        path: [string, 'paint' | 'layout', string]; // [layerid, paint/layout, property key],
+        key: string;
+        value: PropertyValueSpecification<unknown> | DataDrivenPropertyValueSpecification<unknown>;
+        reference: StylePropertySpecification;
+        set: (
+            a: PropertyValueSpecification<unknown> | DataDrivenPropertyValueSpecification<unknown>
+        ) => void;
+    }
 ) => void;
 
 export function eachProperty(
     style: StyleSpecification,
     options: {
-      paint?: boolean;
-      layout?: boolean;
+        paint?: boolean;
+        layout?: boolean;
     },
     callback: PropertyCallback
 ) {

package/src/symbol/collision_feature.test.ts

@@ -1,7 +1,7 @@
 import CollisionFeature from './collision_feature';
 import Anchor from './anchor';
 import Point from '@mapbox/point-geometry';
-import {CollisionBoxArray} from '../data/array_types';
+import {CollisionBoxArray} from '../data/array_types.g';
 
 describe('CollisionFeature', () => {
 

package/src/symbol/collision_feature.ts

@@ -1,4 +1,4 @@
-import type {CollisionBoxArray} from '../data/array_types';
+import type {CollisionBoxArray} from '../data/array_types.g';
 import Point from '@mapbox/point-geometry';
 import type Anchor from './anchor';
 
@@ -27,15 +27,15 @@ class CollisionFeature {
      * @private
      */
     constructor(collisionBoxArray: CollisionBoxArray,
-                anchor: Anchor,
-                featureIndex: number,
-                sourceLayerIndex: number,
-                bucketIndex: number,
-                shaped: any,
-                boxScale: number,
-                padding: number,
-                alignLine: boolean,
-                rotate: number) {
+        anchor: Anchor,
+        featureIndex: number,
+        sourceLayerIndex: number,
+        bucketIndex: number,
+        shaped: any,
+        boxScale: number,
+        padding: number,
+        alignLine: boolean,
+        rotate: number) {
 
         this.boxStartIndex = collisionBoxArray.length;
 

package/src/symbol/collision_index.ts

@@ -15,7 +15,7 @@ import type {SingleCollisionBox} from '../data/bucket/symbol_bucket';
 import type {
     GlyphOffsetArray,
     SymbolLineVertexArray
-} from '../data/array_types';
+} from '../data/array_types.g';
 import type {OverlapMode} from '../style/style_layer/symbol_style_layer';
 
 // When a symbol crosses the edge that causes it to be included in
@@ -73,15 +73,15 @@ class CollisionIndex {
     }
 
     placeCollisionBox(
-      collisionBox: SingleCollisionBox,
-      overlapMode: OverlapMode,
-      textPixelRatio: number,
-      posMatrix: mat4,
-      collisionGroupPredicate?: (key: FeatureKey) => boolean
+        collisionBox: SingleCollisionBox,
+        overlapMode: OverlapMode,
+        textPixelRatio: number,
+        posMatrix: mat4,
+        collisionGroupPredicate?: (key: FeatureKey) => boolean
     ): {
-      box: Array<number>;
-      offscreen: boolean;
-    } {
+            box: Array<number>;
+            offscreen: boolean;
+        } {
         const projectedPoint = this.projectAndGetPerspectiveRatio(posMatrix, collisionBox.anchorPointX, collisionBox.anchorPointY);
         const tileToViewport = textPixelRatio * projectedPoint.perspectiveRatio;
         const tlX = collisionBox.x1 * tileToViewport + projectedPoint.point.x;
@@ -104,24 +104,24 @@ class CollisionIndex {
     }
 
     placeCollisionCircles(
-      overlapMode: OverlapMode,
-      symbol: any,
-      lineVertexArray: SymbolLineVertexArray,
-      glyphOffsetArray: GlyphOffsetArray,
-      fontSize: number,
-      posMatrix: mat4,
-      labelPlaneMatrix: mat4,
-      labelToScreenMatrix: mat4,
-      showCollisionCircles: boolean,
-      pitchWithMap: boolean,
-      collisionGroupPredicate: (key: FeatureKey) => boolean,
-      circlePixelDiameter: number,
-      textPixelPadding: number
+        overlapMode: OverlapMode,
+        symbol: any,
+        lineVertexArray: SymbolLineVertexArray,
+        glyphOffsetArray: GlyphOffsetArray,
+        fontSize: number,
+        posMatrix: mat4,
+        labelPlaneMatrix: mat4,
+        labelToScreenMatrix: mat4,
+        showCollisionCircles: boolean,
+        pitchWithMap: boolean,
+        collisionGroupPredicate: (key: FeatureKey) => boolean,
+        circlePixelDiameter: number,
+        textPixelPadding: number
     ): {
-      circles: Array<number>;
-      offscreen: boolean;
-      collisionDetected: boolean;
-    } {
+            circles: Array<number>;
+            offscreen: boolean;
+            collisionDetected: boolean;
+        } {
         const placedCollisionCircles = [];
 
         const tileUnitAnchorPoint = new Point(symbol.anchorX, symbol.anchorY);

package/src/symbol/cross_tile_symbol_index.ts

@@ -1,8 +1,8 @@
 import EXTENT from '../data/extent';
 
-import {SymbolInstanceArray} from '../data/array_types';
+import {SymbolInstanceArray} from '../data/array_types.g';
 
-import type {SymbolInstance} from '../data/array_types';
+import type {SymbolInstance} from '../data/array_types.g';
 import type {OverscaledTileID} from '../source/tile_id';
 import type SymbolBucket from '../data/bucket/symbol_bucket';
 import type StyleLayer from '../style/style_layer';
@@ -28,13 +28,13 @@ const roundingFactor = 512 / EXTENT / 2;
 class TileLayerIndex {
     tileID: OverscaledTileID;
     indexedSymbolInstances: {
-      [_: number]: Array<{
-        crossTileID: number;
-        coord: {
-          x: number;
-          y: number;
-        };
-      }>;
+        [_: number]: Array<{
+            crossTileID: number;
+            coord: {
+                x: number;
+                y: number;
+            };
+        }>;
     };
     bucketInstanceId: number;
 
@@ -74,7 +74,7 @@ class TileLayerIndex {
     }
 
     findMatches(symbolInstances: SymbolInstanceArray, newTileID: OverscaledTileID, zoomCrossTileIDs: {
-      [crossTileID: number]: boolean;
+        [crossTileID: number]: boolean;
     }) {
         const tolerance = this.tileID.canonical.z < newTileID.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - newTileID.canonical.z);
 
@@ -123,14 +123,14 @@ class CrossTileIDs {
 
 class CrossTileSymbolLayerIndex {
     indexes: {
-      [zoom in string | number]: {
-        [tileId in string | number]: TileLayerIndex;
-      };
+        [zoom in string | number]: {
+            [tileId in string | number]: TileLayerIndex;
+        };
     };
     usedCrossTileIDs: {
-      [zoom in string | number]: {
-        [crossTileID: number]: boolean;
-      };
+        [zoom in string | number]: {
+            [crossTileID: number]: boolean;
+        };
     };
     lng: number;
 
@@ -234,7 +234,7 @@ class CrossTileSymbolLayerIndex {
     }
 
     removeStaleBuckets(currentIDs: {
-      [k in string | number]: boolean;
+        [k in string | number]: boolean;
     }) {
         let tilesChanged = false;
         for (const z in this.indexes) {