maplibre-gl 2.1.1 → 2.1.2

package/src/data/bucket.ts

@@ -1,4 +1,4 @@
-import type {CollisionBoxArray} from './array_types';
+import type {CollisionBoxArray} from './array_types.g';
 import type Style from '../style/style';
 import type {TypedStyleLayer} from '../style/style_layer/typed_style_layer';
 import type FeatureIndex from './feature_index';
@@ -10,46 +10,46 @@ import type {VectorTileFeature, VectorTileLayer} from '@mapbox/vector-tile';
 import Point from '@mapbox/point-geometry';
 
 export type BucketParameters<Layer extends TypedStyleLayer> = {
-  index: number;
-  layers: Array<Layer>;
-  zoom: number;
-  pixelRatio: number;
-  overscaling: number;
-  collisionBoxArray: CollisionBoxArray;
-  sourceLayerIndex: number;
-  sourceID: string;
+    index: number;
+    layers: Array<Layer>;
+    zoom: number;
+    pixelRatio: number;
+    overscaling: number;
+    collisionBoxArray: CollisionBoxArray;
+    sourceLayerIndex: number;
+    sourceID: string;
 };
 
 export type PopulateParameters = {
-  featureIndex: FeatureIndex;
-  iconDependencies: {};
-  patternDependencies: {};
-  glyphDependencies: {};
-  availableImages: Array<string>;
+    featureIndex: FeatureIndex;
+    iconDependencies: {};
+    patternDependencies: {};
+    glyphDependencies: {};
+    availableImages: Array<string>;
 };
 
 export type IndexedFeature = {
-  feature: VectorTileFeature;
-  id: number | string;
-  index: number;
-  sourceLayerIndex: number;
+    feature: VectorTileFeature;
+    id: number | string;
+    index: number;
+    sourceLayerIndex: number;
 };
 
 export type BucketFeature = {
-  index: number;
-  sourceLayerIndex: number;
-  geometry: Array<Array<Point>>;
-  properties: any;
-  type: 1 | 2 | 3;
-  id?: any;
-  readonly patterns: {
-    [_: string]: {
-      'min': string;
-      'mid': string;
-      'max': string;
+    index: number;
+    sourceLayerIndex: number;
+    geometry: Array<Array<Point>>;
+    properties: any;
+    type: 1 | 2 | 3;
+    id?: any;
+    readonly patterns: {
+        [_: string]: {
+            'min': string;
+            'mid': string;
+            'max': string;
+        };
     };
-  };
-  sortKey?: number;
+    sortKey?: number;
 };
 
 /**
@@ -76,24 +76,24 @@ export type BucketFeature = {
  * @private
  */
 export interface Bucket {
-  layerIds: Array<string>;
-  hasPattern: boolean;
-  readonly layers: Array<any>;
-  readonly stateDependentLayers: Array<any>;
-  readonly stateDependentLayerIds: Array<string>;
-  populate(features: Array<IndexedFeature>, options: PopulateParameters, canonical: CanonicalTileID): void;
-  update(states: FeatureStates, vtLayer: VectorTileLayer, imagePositions: {[_: string]: ImagePosition}): void;
-  isEmpty(): boolean;
-  upload(context: Context): void;
-  uploadPending(): boolean;
-  /**
+    layerIds: Array<string>;
+    hasPattern: boolean;
+    readonly layers: Array<any>;
+    readonly stateDependentLayers: Array<any>;
+    readonly stateDependentLayerIds: Array<string>;
+    populate(features: Array<IndexedFeature>, options: PopulateParameters, canonical: CanonicalTileID): void;
+    update(states: FeatureStates, vtLayer: VectorTileLayer, imagePositions: {[_: string]: ImagePosition}): void;
+    isEmpty(): boolean;
+    upload(context: Context): void;
+    uploadPending(): boolean;
+    /**
      * Release the WebGL resources associated with the buffers. Note that because
      * buckets are shared between layers having the same layout properties, they
      * must be destroyed in groups (all buckets for a tile, or all symbol buckets).
      *
      * @private
      */
-  destroy(): void;
+    destroy(): void;
 }
 
 export function deserialize(input: Array<Bucket>, style: Style): {[_: string]: Bucket} {

package/src/data/dem_data.ts

@@ -95,21 +95,21 @@ export default class DEMData {
             yMax = dy * this.dim + this.dim;
 
         switch (dx) {
-        case -1:
-            xMin = xMax - 1;
-            break;
-        case 1:
-            xMax = xMin + 1;
-            break;
+            case -1:
+                xMin = xMax - 1;
+                break;
+            case 1:
+                xMax = xMin + 1;
+                break;
         }
 
         switch (dy) {
-        case -1:
-            yMin = yMax - 1;
-            break;
-        case 1:
-            yMax = yMin + 1;
-            break;
+            case -1:
+                yMin = yMax - 1;
+                break;
+            case 1:
+                yMax = yMin + 1;
+                break;
         }
 
         const ox = -dx * this.dim;

package/src/data/evaluation_feature.ts

@@ -3,17 +3,17 @@ import type Point from '@mapbox/point-geometry';
 import type {VectorTileFeature} from '@mapbox/vector-tile';
 
 type EvaluationFeature = {
-  readonly type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
-  readonly id?: any;
-  readonly properties: {[_: string]: any};
-  readonly patterns?: {
-    [_: string]: {
-      'min': string;
-      'mid': string;
-      'max': string;
+    readonly type: 1 | 2 | 3 | 'Unknown' | 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
+    readonly id?: any;
+    readonly properties: {[_: string]: any};
+    readonly patterns?: {
+        [_: string]: {
+            'min': string;
+            'mid': string;
+            'max': string;
+        };
     };
-  };
-  geometry: Array<Array<Point>>;
+    geometry: Array<Array<Point>>;
 };
 
 /**

package/src/data/feature_index.ts

@@ -15,7 +15,7 @@ import EvaluationParameters from '../style/evaluation_parameters';
 import SourceFeatureState from '../source/source_state';
 import {polygonIntersectsBox} from '../util/intersection_tests';
 import {PossiblyEvaluated} from '../style/properties';
-import {FeatureIndexArray} from './array_types';
+import {FeatureIndexArray} from './array_types.g';
 import {mat4} from 'gl-matrix';
 
 import type StyleLayer from '../style/style_layer';
@@ -26,18 +26,18 @@ import type {FeatureState} from '../style-spec/expression';
 import type {VectorTileFeature, VectorTileLayer} from '@mapbox/vector-tile';
 
 type QueryParameters = {
-  scale: number;
-  pixelPosMatrix: mat4;
-  transform: Transform;
-  tileSize: number;
-  queryGeometry: Array<Point>;
-  cameraQueryGeometry: Array<Point>;
-  queryPadding: number;
-  params: {
-    filter: FilterSpecification;
-    layers: Array<string>;
-    availableImages: Array<string>;
-  };
+    scale: number;
+    pixelPosMatrix: mat4;
+    transform: Transform;
+    tileSize: number;
+    queryGeometry: Array<Point>;
+    cameraQueryGeometry: Array<Point>;
+    queryPadding: number;
+    params: {
+        filter: FilterSpecification;
+        layers: Array<string>;
+        availableImages: Array<string>;
+    };
 };
 
 class FeatureIndex {
@@ -104,10 +104,10 @@ class FeatureIndex {
 
     // Finds non-symbol features in this tile at a particular position.
     query(
-      args: QueryParameters,
-      styleLayers: {[_: string]: StyleLayer},
-      serializedLayers: {[_: string]: any},
-      sourceFeatureState: SourceFeatureState
+        args: QueryParameters,
+        styleLayers: {[_: string]: StyleLayer},
+        serializedLayers: {[_: string]: any},
+        sourceFeatureState: SourceFeatureState
     ): {[_: string]: Array<{featureIndex: number; feature: GeoJSONFeature}>} {
         this.loadVTLayers();
 
@@ -123,10 +123,10 @@ class FeatureIndex {
 
         const cameraBounds = getBounds(args.cameraQueryGeometry);
         const matching3D = this.grid3D.query(
-                cameraBounds.minX - queryPadding, cameraBounds.minY - queryPadding, cameraBounds.maxX + queryPadding, cameraBounds.maxY + queryPadding,
-                (bx1, by1, bx2, by2) => {
-                    return polygonIntersectsBox(args.cameraQueryGeometry, bx1 - queryPadding, by1 - queryPadding, bx2 + queryPadding, by2 + queryPadding);
-                });
+            cameraBounds.minX - queryPadding, cameraBounds.minY - queryPadding, cameraBounds.maxX + queryPadding, cameraBounds.maxY + queryPadding,
+            (bx1, by1, bx2, by2) => {
+                return polygonIntersectsBox(args.cameraQueryGeometry, bx1 - queryPadding, by1 - queryPadding, bx2 + queryPadding, by2 + queryPadding);
+            });
 
         for (const key of matching3D) {
             matching.push(key);
@@ -171,11 +171,11 @@ class FeatureIndex {
 
     loadMatchingFeature(
         result: {
-          [_: string]: Array<{
-            featureIndex: number;
-            feature: GeoJSONFeature;
-            intersectionZ?: boolean | number;
-          }>;
+            [_: string]: Array<{
+                featureIndex: number;
+                feature: GeoJSONFeature;
+                intersectionZ?: boolean | number;
+            }>;
         },
         bucketIndex: number,
         sourceLayerIndex: number,
@@ -187,10 +187,10 @@ class FeatureIndex {
         serializedLayers: {[_: string]: any},
         sourceFeatureState?: SourceFeatureState,
         intersectionTest?: (
-          feature: VectorTileFeature,
-          styleLayer: StyleLayer,
-          featureState: any,
-          id: string | number | void
+            feature: VectorTileFeature,
+            styleLayer: StyleLayer,
+            featureState: any,
+            id: string | number | void
         ) => boolean | number) {
 
         const layerIDs = this.bucketLayerIDs[bucketIndex];
@@ -253,13 +253,13 @@ class FeatureIndex {
     // Given a set of symbol indexes that have already been looked up,
     // return a matching set of GeoJSONFeatures
     lookupSymbolFeatures(symbolFeatureIndexes: Array<number>,
-                         serializedLayers: {[_: string]: StyleLayer},
-                         bucketIndex: number,
-                         sourceLayerIndex: number,
-                         filterSpec: FilterSpecification,
-                         filterLayerIDs: Array<string>,
-                         availableImages: Array<string>,
-                         styleLayers: {[_: string]: StyleLayer}) {
+        serializedLayers: {[_: string]: StyleLayer},
+        bucketIndex: number,
+        sourceLayerIndex: number,
+        filterSpec: FilterSpecification,
+        filterLayerIDs: Array<string>,
+        availableImages: Array<string>,
+        styleLayers: {[_: string]: StyleLayer}) {
         const result = {};
         this.loadVTLayers();
 

package/src/data/feature_position_map.ts

@@ -3,14 +3,14 @@ import {register} from '../util/web_worker_transfer';
 import assert from 'assert';
 
 type SerializedFeaturePositionMap = {
-  ids: Float64Array;
-  positions: Uint32Array;
+    ids: Float64Array;
+    positions: Uint32Array;
 };
 
 type FeaturePosition = {
-  index: number;
-  start: number;
-  end: number;
+    index: number;
+    start: number;
+    end: number;
 };
 
 // A transferable data structure that maps feature ids to their indices and buffer offsets

package/src/data/index_array_type.ts

@@ -1,4 +1,4 @@
-import {LineIndexArray, TriangleIndexArray, LineStripIndexArray} from './array_types';
+import {LineIndexArray, TriangleIndexArray, LineStripIndexArray} from './array_types.g';
 
 /**
  * An index array stores Uint16 indices of vertexes in a corresponding vertex array. We use

package/src/data/load_geometry.test.ts

@@ -5,7 +5,7 @@ import {VectorTile} from '@mapbox/vector-tile';
 import loadGeometry from './load_geometry';
 
 // Load a line feature from fixture tile.
-const vt = new VectorTile(new Protobuf(fs.readFileSync(path.resolve(__dirname, '../../test/fixtures/mbsv5-6-18-23.vector.pbf'))));
+const vt = new VectorTile(new Protobuf(fs.readFileSync(path.resolve(__dirname, '../../test/unit/assets/mbsv5-6-18-23.vector.pbf'))));
 
 describe('loadGeometry', () => {
     test('loadGeometry', () => {

package/src/data/program_configuration.ts

@@ -3,7 +3,7 @@ import Color from '../style-spec/util/color';
 import {supportsPropertyExpression} from '../style-spec/util/properties';
 import {register} from '../util/web_worker_transfer';
 import {PossiblyEvaluatedPropertyValue} from '../style/properties';
-import {StructArrayLayout1f4, StructArrayLayout2f8, StructArrayLayout4f16, PatternLayoutArray} from './array_types';
+import {StructArrayLayout1f4, StructArrayLayout2f8, StructArrayLayout4f16, PatternLayoutArray} from './array_types.g';
 import {clamp} from '../util/util';
 import patternAttributes from './bucket/pattern_attributes';
 import EvaluationParameters from '../style/evaluation_parameters';
@@ -31,9 +31,9 @@ import type {FormattedSection} from '../style-spec/expression/types/formatted';
 import type {VectorTileLayer} from '@mapbox/vector-tile';
 
 export type BinderUniform = {
-  name: string;
-  property: string;
-  binding: Uniform<any>;
+    name: string;
+    property: string;
+    binding: Uniform<any>;
 };
 
 function packColor(color: Color): [number, number] {
@@ -72,33 +72,33 @@ function packColor(color: Color): [number, number] {
  */
 
 interface AttributeBinder {
-  populatePaintArray(
-    length: number,
-    feature: Feature,
-    imagePositions: {[_: string]: ImagePosition},
-    canonical?: CanonicalTileID,
-    formattedSection?: FormattedSection
-  ): void;
-  updatePaintArray(
-    start: number,
-    length: number,
-    feature: Feature,
-    featureState: FeatureState,
-    imagePositions: {[_: string]: ImagePosition}
-  ): void;
-  upload(a: Context): void;
-  destroy(): void;
+    populatePaintArray(
+        length: number,
+        feature: Feature,
+        imagePositions: {[_: string]: ImagePosition},
+        canonical?: CanonicalTileID,
+        formattedSection?: FormattedSection
+    ): void;
+    updatePaintArray(
+        start: number,
+        length: number,
+        feature: Feature,
+        featureState: FeatureState,
+        imagePositions: {[_: string]: ImagePosition}
+    ): void;
+    upload(a: Context): void;
+    destroy(): void;
 }
 
 interface UniformBinder {
-  uniformNames: Array<string>;
-  setUniform(
-    uniform: Uniform<any>,
-    globals: GlobalProperties,
-    currentValue: PossiblyEvaluatedPropertyValue<any>,
-    uniformName: string
-  ): void;
-  getBinding(context: Context, location: WebGLUniformLocation, name: string): Partial<Uniform<any>>;
+    uniformNames: Array<string>;
+    setUniform(
+        uniform: Uniform<any>,
+        globals: GlobalProperties,
+        currentValue: PossiblyEvaluatedPropertyValue<any>,
+        uniformName: string
+    ): void;
+    getBinding(context: Context, location: WebGLUniformLocation, name: string): Partial<Uniform<any>>;
 }
 
 class ConstantBinder implements UniformBinder {
@@ -113,9 +113,9 @@ class ConstantBinder implements UniformBinder {
     }
 
     setUniform(
-      uniform: Uniform<any>,
-      globals: GlobalProperties,
-      currentValue: PossiblyEvaluatedPropertyValue<unknown>
+        uniform: Uniform<any>,
+        globals: GlobalProperties,
+        currentValue: PossiblyEvaluatedPropertyValue<unknown>
     ): void {
         uniform.set(currentValue.constantOr(this.value));
     }
@@ -152,9 +152,9 @@ class CrossFadedConstantBinder implements UniformBinder {
     setUniform(uniform: Uniform<any>, globals: GlobalProperties, currentValue: PossiblyEvaluatedPropertyValue<unknown>, uniformName: string) {
         const pos =
             uniformName === 'u_pattern_to' ? this.patternTo :
-            uniformName === 'u_pattern_from' ? this.patternFrom :
-            uniformName === 'u_pixel_ratio_to' ? this.pixelRatioTo :
-            uniformName === 'u_pixel_ratio_from' ? this.pixelRatioFrom : null;
+                uniformName === 'u_pattern_from' ? this.patternFrom :
+                    uniformName === 'u_pixel_ratio_to' ? this.pixelRatioTo :
+                        uniformName === 'u_pixel_ratio_from' ? this.pixelRatioFrom : null;
         if (pos) uniform.set(pos);
     }
 
@@ -175,7 +175,7 @@ class SourceExpressionBinder implements AttributeBinder {
     paintVertexBuffer: VertexBuffer;
 
     constructor(expression: SourceExpression, names: Array<string>, type: string, PaintVertexArray: {
-      new (...args: any): StructArray;
+        new (...args: any): StructArray;
     }) {
         this.expression = expression;
         this.type = type;
@@ -245,7 +245,7 @@ class CompositeExpressionBinder implements AttributeBinder, UniformBinder {
     paintVertexBuffer: VertexBuffer;
 
     constructor(expression: CompositeExpression, names: Array<string>, type: string, useIntegerZoom: boolean, zoom: number, PaintVertexArray: {
-      new (...args: any): StructArray;
+        new (...args: any): StructArray;
     }) {
         this.expression = expression;
         this.uniformNames = names.map(name => `u_${name}_t`);
@@ -332,7 +332,7 @@ class CrossFadedCompositeBinder implements AttributeBinder {
     paintVertexAttributes: Array<StructArrayMember>;
 
     constructor(expression: CompositeExpression, type: string, useIntegerZoom: boolean, zoom: number, PaintVertexArray: {
-      new (...args: any): StructArray;
+        new (...args: any): StructArray;
     }, layerId: string) {
         this.expression = expression;
         this.type = type;
@@ -485,11 +485,11 @@ export default class ProgramConfiguration {
     }
 
     updatePaintArrays(
-      featureStates: FeatureStates,
-      featureMap: FeaturePositionMap,
-      vtLayer: VectorTileLayer,
-      layer: TypedStyleLayer,
-      imagePositions: {[_: string]: ImagePosition}
+        featureStates: FeatureStates,
+        featureMap: FeaturePositionMap,
+        vtLayer: VectorTileLayer,
+        layer: TypedStyleLayer,
+        imagePositions: {[_: string]: ImagePosition}
     ): boolean {
         let dirty: boolean = false;
         for (const id in featureStates) {
@@ -576,10 +576,10 @@ export default class ProgramConfiguration {
     }
 
     setUniforms(
-      context: Context,
-      binderUniforms: Array<BinderUniform>,
-      properties: any,
-      globals: GlobalProperties
+        context: Context,
+        binderUniforms: Array<BinderUniform>,
+        properties: any,
+        globals: GlobalProperties
     ) {
         // Uniform state bindings are owned by the Program, but we set them
         // from within the ProgramConfiguraton's binder members.

package/src/data/segment.ts

@@ -6,12 +6,12 @@ import type VertexArrayObject from '../render/vertex_array_object';
 import type {StructArray} from '../util/struct_array';
 
 export type Segment = {
-  sortKey?: number;
-  vertexOffset: number;
-  primitiveOffset: number;
-  vertexLength: number;
-  primitiveLength: number;
-  vaos: {[_: string]: VertexArrayObject};
+    sortKey?: number;
+    vertexOffset: number;
+    primitiveOffset: number;
+    vertexLength: number;
+    primitiveLength: number;
+    vaos: {[_: string]: VertexArrayObject};
 };
 
 class SegmentVector {
@@ -23,10 +23,10 @@ class SegmentVector {
     }
 
     prepareSegment(
-      numVertices: number,
-      layoutVertexArray: StructArray,
-      indexArray: StructArray,
-      sortKey?: number
+        numVertices: number,
+        layoutVertexArray: StructArray,
+        indexArray: StructArray,
+        sortKey?: number
     ): Segment {
         let segment: Segment = this.segments[this.segments.length - 1];
         if (numVertices > SegmentVector.MAX_VERTEX_ARRAY_LENGTH) warnOnce(`Max vertices per segment is ${SegmentVector.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${numVertices}`);
@@ -56,10 +56,10 @@ class SegmentVector {
     }
 
     static simpleSegment(
-      vertexOffset: number,
-      primitiveOffset: number,
-      vertexLength: number,
-      primitiveLength: number
+        vertexOffset: number,
+        primitiveOffset: number,
+        vertexLength: number,
+        primitiveLength: number
     ): SegmentVector {
         return new SegmentVector([{
             vertexOffset,

package/src/geo/edge_insets.ts

@@ -116,8 +116,8 @@ class EdgeInsets {
  */
 export type PaddingOptions = {
     /**
-    * @property {number} top Padding in pixels from the top of the map canvas.
-    */
+     * @property {number} top Padding in pixels from the top of the map canvas.
+     */
     top: number;
     /**
      * @property {number} bottom Padding in pixels from the bottom of the map canvas.

package/src/geo/lng_lat.ts

@@ -161,11 +161,11 @@ class LngLat {
  * var v3 = {lon: -122.420679, lat: 37.772537};
  */
 export type LngLatLike = LngLat | {
-  lng: number;
-  lat: number;
+    lng: number;
+    lat: number;
 } | {
-  lon: number;
-  lat: number;
+    lon: number;
+    lat: number;
 } | [number, number];
 
 export default LngLat;