maplibre-gl 2.1.0 → 2.1.4

package/src/style/style_layer/hillshade_style_layer.ts

@@ -1,9 +1,9 @@
 import StyleLayer from '../style_layer';
 
-import properties, {HillshadePaintPropsPossiblyEvaluated} from './hillshade_style_layer_properties';
+import properties, {HillshadePaintPropsPossiblyEvaluated} from './hillshade_style_layer_properties.g';
 import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
 
-import type {HillshadePaintProps} from './hillshade_style_layer_properties';
+import type {HillshadePaintProps} from './hillshade_style_layer_properties.g';
 import type {LayerSpecification} from '../../style-spec/types';
 
 class HillshadeStyleLayer extends StyleLayer {

package/src/style/style_layer/line_style_layer.ts

@@ -4,7 +4,7 @@ import StyleLayer from '../style_layer';
 import LineBucket from '../../data/bucket/line_bucket';
 import {polygonIntersectsBufferedMultiLine} from '../../util/intersection_tests';
 import {getMaximumPaintValue, translateDistance, translate} from '../query_utils';
-import properties, {LineLayoutPropsPossiblyEvaluated, LinePaintPropsPossiblyEvaluated} from './line_style_layer_properties';
+import properties, {LineLayoutPropsPossiblyEvaluated, LinePaintPropsPossiblyEvaluated} from './line_style_layer_properties.g';
 import {extend} from '../../util/util';
 import EvaluationParameters from '../evaluation_parameters';
 import {Transitionable, Transitioning, Layout, PossiblyEvaluated, DataDrivenProperty} from '../properties';
@@ -12,7 +12,7 @@ import {Transitionable, Transitioning, Layout, PossiblyEvaluated, DataDrivenProp
 import Step from '../../style-spec/expression/definitions/step';
 import type {FeatureState, ZoomConstantExpression} from '../../style-spec/expression';
 import type {Bucket, BucketParameters} from '../../data/bucket';
-import type {LineLayoutProps, LinePaintProps} from './line_style_layer_properties';
+import type {LineLayoutProps, LinePaintProps} from './line_style_layer_properties.g';
 import type Transform from '../../geo/transform';
 import type {LayerSpecification} from '../../style-spec/types';
 import type {VectorTileFeature} from '@mapbox/vector-tile';
@@ -88,13 +88,13 @@ class LineStyleLayer extends StyleLayer {
     }
 
     queryIntersectsFeature(
-      queryGeometry: Array<Point>,
-      feature: VectorTileFeature,
-      featureState: FeatureState,
-      geometry: Array<Array<Point>>,
-      zoom: number,
-      transform: Transform,
-      pixelsToTileUnits: number
+        queryGeometry: Array<Point>,
+        feature: VectorTileFeature,
+        featureState: FeatureState,
+        geometry: Array<Array<Point>>,
+        zoom: number,
+        transform: Transform,
+        pixelsToTileUnits: number
     ): boolean {
         const translatedPolygon = translate(queryGeometry,
             this.paint.get('line-translate'),

package/src/style/style_layer/raster_style_layer.ts

@@ -1,9 +1,9 @@
 import StyleLayer from '../style_layer';
 
-import properties, {RasterPaintPropsPossiblyEvaluated} from './raster_style_layer_properties';
+import properties, {RasterPaintPropsPossiblyEvaluated} from './raster_style_layer_properties.g';
 import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
 
-import type {RasterPaintProps} from './raster_style_layer_properties';
+import type {RasterPaintProps} from './raster_style_layer_properties.g';
 import type {LayerSpecification} from '../../style-spec/types';
 
 class RasterStyleLayer extends StyleLayer {

package/src/style/style_layer/symbol_style_layer.ts

@@ -3,7 +3,7 @@ import StyleLayer from '../style_layer';
 import assert from 'assert';
 import SymbolBucket from '../../data/bucket/symbol_bucket';
 import resolveTokens from '../../util/resolve_tokens';
-import properties, {SymbolLayoutPropsPossiblyEvaluated, SymbolPaintPropsPossiblyEvaluated} from './symbol_style_layer_properties';
+import properties, {SymbolLayoutPropsPossiblyEvaluated, SymbolPaintPropsPossiblyEvaluated} from './symbol_style_layer_properties.g';
 
 import {
     Transitionable,
@@ -22,7 +22,7 @@ import {
 } from '../../style-spec/expression';
 
 import type {BucketParameters} from '../../data/bucket';
-import type {SymbolLayoutProps, SymbolPaintProps} from './symbol_style_layer_properties';
+import type {SymbolLayoutProps, SymbolPaintProps} from './symbol_style_layer_properties.g';
 import type EvaluationParameters from '../evaluation_parameters';
 import type {LayerSpecification} from '../../style-spec/types';
 import type {Feature, SourceExpression, CompositeExpression} from '../../style-spec/expression';
@@ -127,13 +127,13 @@ class SymbolStyleLayer extends StyleLayer {
                 expression = (new ZoomConstantExpression('source', styleExpression) as SourceExpression);
             } else {
                 expression = (new ZoomDependentExpression('composite',
-                                                          styleExpression,
-                                                          overriden.value.zoomStops,
-                                                          (overriden.value as any)._interpolationType) as CompositeExpression);
+                    styleExpression,
+                    overriden.value.zoomStops,
+                    (overriden.value as any)._interpolationType) as CompositeExpression);
             }
             this.paint._values[overridable] = new PossiblyEvaluatedPropertyValue(overriden.property,
-                                                                                 expression,
-                                                                                 overriden.parameters);
+                expression,
+                overriden.parameters);
         }
     }
 

package/src/style/style_layer.ts

@@ -58,19 +58,19 @@ abstract class StyleLayer extends Evented {
 
     queryRadius?(bucket: Bucket): number;
     queryIntersectsFeature?(
-      queryGeometry: Array<Point>,
-      feature: VectorTileFeature,
-      featureState: FeatureState,
-      geometry: Array<Array<Point>>,
-      zoom: number,
-      transform: Transform,
-      pixelsToTileUnits: number,
-      pixelPosMatrix: mat4
+        queryGeometry: Array<Point>,
+        feature: VectorTileFeature,
+        featureState: FeatureState,
+        geometry: Array<Array<Point>>,
+        zoom: number,
+        transform: Transform,
+        pixelsToTileUnits: number,
+        pixelPosMatrix: mat4
     ): boolean | number;
 
     constructor(layer: LayerSpecification | CustomLayerInterface, properties: Readonly<{
-      layout?: Properties<any>;
-      paint?: Properties<any>;
+        layout?: Properties<any>;
+        paint?: Properties<any>;
     }>) {
         super();
 

package/src/style/style_layer_index.ts

@@ -12,9 +12,9 @@ export type Family<Layer extends TypedStyleLayer> = Array<Layer>;
 
 class StyleLayerIndex {
     familiesBySource: {
-      [source: string]: {
-        [sourceLayer: string]: Array<Family<any>>;
-      };
+        [source: string]: {
+            [sourceLayer: string]: Array<Family<any>>;
+        };
     };
     keyCache: {[source: string]: string};
 

package/src/style/validate_style.ts

@@ -4,21 +4,21 @@ import {ErrorEvent} from '../util/evented';
 import type {Evented} from '../util/evented';
 
 type ValidationError = {
-  message: string;
-  line: number;
-  identifier?: string;
+    message: string;
+    line: number;
+    identifier?: string;
 };
 
 export type Validator = (a: any) => ReadonlyArray<ValidationError>;
 
 type ValidateStyle = {
-  source: Validator;
-  layer: Validator;
-  light: Validator;
-  filter: Validator;
-  paintProperty: Validator;
-  layoutProperty: Validator;
-  (b: any, a?: any | null): ReadonlyArray<ValidationError>;
+    source: Validator;
+    layer: Validator;
+    light: Validator;
+    filter: Validator;
+    paintProperty: Validator;
+    layoutProperty: Validator;
+    (b: any, a?: any | null): ReadonlyArray<ValidationError>;
 };
 
 export const validateStyle = (validateStyleMin as ValidateStyle);
@@ -30,11 +30,11 @@ export const validatePaintProperty = validateStyle.paintProperty;
 export const validateLayoutProperty = validateStyle.layoutProperty;
 
 export function emitValidationErrors(
-  emitter: Evented,
-  errors?: ReadonlyArray<{
-    message: string;
-    identifier?: string;
-  }> | null
+    emitter: Evented,
+    errors?: ReadonlyArray<{
+        message: string;
+        identifier?: string;
+    }> | null
 ): boolean {
     let hasErrors = false;
     if (errors && errors.length) {

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

@@ -6,7 +6,7 @@ export default class ValidationError {
     line: number;
 
     constructor(key: string, value: {
-      __line__: number;
+        __line__: number;
     }, message: string, identifier?: string | null) {
         this.message = (key ? `${key}: ` : '') + message;
         if (identifier) this.identifier = identifier;

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

@@ -9,14 +9,14 @@ import type {Type} from './types';
 import type {Value} from './values';
 
 export type Varargs = {
-  type: Type;
+    type: Type;
 };
 type Signature = Array<Type> | Varargs;
 type Evaluate = (b: EvaluationContext, a: Array<Expression>) => Value;
 
 type Definition = [Type, Signature, Evaluate] | {
-  type: Type;
-  overloads: Array<[Signature, Evaluate]>;
+    type: Type;
+    overloads: Array<[Signature, Evaluate]>;
 };
 
 class CompoundExpression implements Expression {

package/src/style-spec/expression/definitions/format.ts

@@ -16,12 +16,12 @@ import type ParsingContext from '../parsing_context';
 import type {Type} from '../types';
 
 type FormattedSectionExpression = {
-  // Content of a section may be Image expression or other
-  // type of expression that is coercable to 'string'.
-  content: Expression;
-  scale: Expression | null;
-  font: Expression | null;
-  textColor: Expression | null;
+    // Content of a section may be Image expression or other
+    // type of expression that is coercable to 'string'.
+    content: Expression;
+    scale: Expression | null;
+    font: Expression | null;
+    textColor: Expression | null;
 };
 
 export default class FormatExpression implements Expression {
@@ -97,11 +97,11 @@ export default class FormatExpression implements Expression {
             }
 
             return new FormattedSection(
-                    toString(evaluatedContent),
-                    null,
-                    section.scale ? section.scale.evaluate(ctx) : null,
-                    section.font ? section.font.evaluate(ctx).join(',') : null,
-                    section.textColor ? section.textColor.evaluate(ctx) : null
+                toString(evaluatedContent),
+                null,
+                section.scale ? section.scale.evaluate(ctx) : null,
+                section.font ? section.font.evaluate(ctx).join(',') : null,
+                section.textColor ? section.textColor.evaluate(ctx) : null
             );
         };
 

package/src/style-spec/expression/definitions/interpolate.ts

@@ -12,13 +12,13 @@ import type EvaluationContext from '../evaluation_context';
 import type {Type} from '../types';
 
 export type InterpolationType = {
-  name: 'linear';
+    name: 'linear';
 } | {
-  name: 'exponential';
-  base: number;
+    name: 'exponential';
+    base: number;
 } | {
-  name: 'cubic-bezier';
-  controlPoints: [number, number, number, number];
+    name: 'cubic-bezier';
+    controlPoints: [number, number, number, number];
 };
 
 class Interpolate implements Expression {

package/src/style-spec/expression/definitions/match.ts

@@ -11,7 +11,7 @@ import type EvaluationContext from '../evaluation_context';
 
 // Map input label values to output expression index
 type Cases = {
-  [k in number | string]: number;
+    [k in number | string]: number;
 };
 
 class Match implements Expression {
@@ -128,7 +128,7 @@ class Match implements Expression {
         // serializations of the form [case1, case2, ...] -> matchExpression
         const groupedByOutput: Array<[number, Array<number | string>]> = [];
         const outputLookup: {
-          [index: number]: number;
+            [index: number]: number;
         } = {}; // lookup index into groupedByOutput for a given output expression
         for (const label of sortedLabels) {
             const outputIndex = outputLookup[this.cases[label]];

package/src/style-spec/expression/definitions/number_format.ts

@@ -6,9 +6,9 @@ import type ParsingContext from '../parsing_context';
 import type {Type} from '../types';
 
 declare let Intl: {
-  NumberFormat: {
-    new (...args: any): Intl$NumberFormat;
-  };
+    NumberFormat: {
+        new (...args: any): Intl$NumberFormat;
+    };
 };
 
 declare class Intl$NumberFormat {
@@ -18,10 +18,10 @@ declare class Intl$NumberFormat {
 }
 
 type NumberFormatOptions = {
-  style?: 'decimal' | 'currency' | 'percent';
-  currency?: null | string;
-  minimumFractionDigits?: null | string;
-  maximumFractionDigits?: null | string;
+    style?: 'decimal' | 'currency' | 'percent';
+    currency?: null | string;
+    minimumFractionDigits?: null | string;
+    maximumFractionDigits?: null | string;
 };
 
 export default class NumberFormat implements Expression {
@@ -33,10 +33,10 @@ export default class NumberFormat implements Expression {
     maxFractionDigits: Expression | null; // Default 3
 
     constructor(number: Expression,
-                locale: Expression | null,
-                currency: Expression | null,
-                minFractionDigits: Expression | null,
-                maxFractionDigits: Expression | null) {
+        locale: Expression | null,
+        currency: Expression | null,
+        minFractionDigits: Expression | null,
+        maxFractionDigits: Expression | null) {
         this.type = StringType;
         this.number = number;
         this.locale = locale;

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

@@ -5,21 +5,21 @@ import type EvaluationContext from './evaluation_context';
 type SerializedExpression = Array<unknown> | string | number | boolean | null;
 
 export interface Expression {
-  readonly type: Type;
-  evaluate(ctx: EvaluationContext): any;
-  eachChild(fn: (a: Expression) => void): void;
-  /**
+    readonly type: Type;
+    evaluate(ctx: EvaluationContext): any;
+    eachChild(fn: (a: Expression) => void): void;
+    /**
      * Statically analyze the expression, attempting to enumerate possible outputs. Returns
      * false if the complete set of outputs is statically undecidable, otherwise true.
      */
-  outputDefined(): boolean;
-  serialize(): SerializedExpression;
+    outputDefined(): boolean;
+    serialize(): SerializedExpression;
 }
 
 export type ExpressionParser = (args: ReadonlyArray<unknown>, context: ParsingContext) => Expression;
 export type ExpressionRegistration = {
-  new (...args: any): Expression;
+    new (...args: any): Expression;
 } & {
-  readonly parse: ExpressionParser;
+    readonly parse: ExpressionParser;
 };
 export type ExpressionRegistry = {[_: string]: ExpressionRegistration};