maplibre-gl 2.1.1 → 2.1.2

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

@@ -27,27 +27,27 @@ import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../../source/tile_id';
 
 export type Feature = {
-  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;
+        };
     };
-  };
-  readonly geometry?: Array<Array<Point>>;
+    readonly geometry?: Array<Array<Point>>;
 };
 
 export type FeatureState = {[_: string]: any};
 
 export type GlobalProperties = Readonly<{
-  zoom: number;
-  heatmapDensity?: number;
-  lineProgress?: number;
-  isSupportedScript?: (_: string) => boolean;
-  accumulated?: Value;
+    zoom: number;
+    heatmapDensity?: number;
+    lineProgress?: number;
+    isSupportedScript?: (_: string) => boolean;
+    accumulated?: Value;
 }>;
 
 export class StyleExpression {
@@ -67,12 +67,12 @@ export class StyleExpression {
     }
 
     evaluateWithoutErrorHandling(
-      globals: GlobalProperties,
-      feature?: Feature,
-      featureState?: FeatureState,
-      canonical?: CanonicalTileID,
-      availableImages?: Array<string>,
-      formattedSection?: FormattedSection
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
     ): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature;
@@ -85,12 +85,12 @@ export class StyleExpression {
     }
 
     evaluate(
-      globals: GlobalProperties,
-      feature?: Feature,
-      featureState?: FeatureState,
-      canonical?: CanonicalTileID,
-      availableImages?: Array<string>,
-      formattedSection?: FormattedSection
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
     ): any {
         this._evaluator.globals = globals;
         this._evaluator.feature = feature || null;
@@ -162,23 +162,23 @@ export class ZoomConstantExpression<Kind extends EvaluationKind> {
     }
 
     evaluateWithoutErrorHandling(
-      globals: GlobalProperties,
-      feature?: Feature,
-      featureState?: FeatureState,
-      canonical?: CanonicalTileID,
-      availableImages?: Array<string>,
-      formattedSection?: FormattedSection
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
     ): any {
         return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
     evaluate(
-      globals: GlobalProperties,
-      feature?: Feature,
-      featureState?: FeatureState,
-      canonical?: CanonicalTileID,
-      availableImages?: Array<string>,
-      formattedSection?: FormattedSection
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
     ): any {
         return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
@@ -201,23 +201,23 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
     }
 
     evaluateWithoutErrorHandling(
-      globals: GlobalProperties,
-      feature?: Feature,
-      featureState?: FeatureState,
-      canonical?: CanonicalTileID,
-      availableImages?: Array<string>,
-      formattedSection?: FormattedSection
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
     ): any {
         return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
 
     evaluate(
-      globals: GlobalProperties,
-      feature?: Feature,
-      featureState?: FeatureState,
-      canonical?: CanonicalTileID,
-      availableImages?: Array<string>,
-      formattedSection?: FormattedSection
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
     ): any {
         return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
     }
@@ -232,57 +232,57 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
 }
 
 export type ConstantExpression = {
-  kind: 'constant';
-  readonly evaluate: (
-    globals: GlobalProperties,
-    feature?: Feature,
-    featureState?: FeatureState,
-    canonical?: CanonicalTileID,
-    availableImages?: Array<string>
-  ) => any;
+    kind: 'constant';
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>
+    ) => any;
 };
 
 export type SourceExpression = {
-  kind: 'source';
-  isStateDependent: boolean;
-  readonly evaluate: (
-    globals: GlobalProperties,
-    feature?: Feature,
-    featureState?: FeatureState,
-    canonical?: CanonicalTileID,
-    availableImages?: Array<string>,
-    formattedSection?: FormattedSection
-  ) => any;
+    kind: 'source';
+    isStateDependent: boolean;
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
+    ) => any;
 };
 
 export type CameraExpression = {
-  kind: 'camera';
-  readonly evaluate: (
-    globals: GlobalProperties,
-    feature?: Feature,
-    featureState?: FeatureState,
-    canonical?: CanonicalTileID,
-    availableImages?: Array<string>
-  ) => any;
-  readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
-  zoomStops: Array<number>;
-  interpolationType: InterpolationType;
+    kind: 'camera';
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>
+    ) => any;
+    readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
+    zoomStops: Array<number>;
+    interpolationType: InterpolationType;
 };
 
 export type CompositeExpression = {
-  kind: 'composite';
-  isStateDependent: boolean;
-  readonly evaluate: (
-    globals: GlobalProperties,
-    feature?: Feature,
-    featureState?: FeatureState,
-    canonical?: CanonicalTileID,
-    availableImages?: Array<string>,
-    formattedSection?: FormattedSection
-  ) => any;
-  readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
-  zoomStops: Array<number>;
-  interpolationType: InterpolationType;
+    kind: 'composite';
+    isStateDependent: boolean;
+    readonly evaluate: (
+        globals: GlobalProperties,
+        feature?: Feature,
+        featureState?: FeatureState,
+        canonical?: CanonicalTileID,
+        availableImages?: Array<string>,
+        formattedSection?: FormattedSection
+    ) => any;
+    readonly interpolationFactor: (input: number, lower: number, upper: number) => number;
+    zoomStops: Array<number>;
+    interpolationType: InterpolationType;
 };
 
 export type StylePropertyExpression = ConstantExpression | SourceExpression | CameraExpression | CompositeExpression;
@@ -348,8 +348,8 @@ export class StylePropertyFunction<T> {
     }
 
     static deserialize<T>(serialized: {
-      _parameters: PropertyValueSpecification<T>;
-      _specification: StylePropertySpecification;
+        _parameters: PropertyValueSpecification<T>;
+        _specification: StylePropertySpecification;
     }) {
         return new StylePropertyFunction(serialized._parameters, serialized._specification) as StylePropertyFunction<T>;
     }
@@ -363,8 +363,8 @@ export class StylePropertyFunction<T> {
 }
 
 export function normalizePropertyExpression<T>(
-  value: PropertyValueSpecification<T>,
-  specification: StylePropertySpecification
+    value: PropertyValueSpecification<T>,
+    specification: StylePropertySpecification
 ): StylePropertyExpression {
     if (isFunction(value)) {
         return new StylePropertyFunction(value, specification) as any;

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

@@ -54,13 +54,13 @@ class ParsingContext {
      * @private
      */
     parse(
-      expr: unknown,
-      index?: number,
-      expectedType?: Type | null,
-      bindings?: Array<[string, Expression]>,
-      options: {
-        typeAnnotation?: 'assert' | 'coerce' | 'omit';
-      } = {}
+        expr: unknown,
+        index?: number,
+        expectedType?: Type | null,
+        bindings?: Array<[string, Expression]>,
+        options: {
+            typeAnnotation?: 'assert' | 'coerce' | 'omit';
+        } = {}
     ): Expression {
         if (index) {
             return this.concat(index, expectedType, bindings)._parse(expr, options);
@@ -69,10 +69,10 @@ class ParsingContext {
     }
 
     _parse(
-      expr: unknown,
-      options: {
-        typeAnnotation?: 'assert' | 'coerce' | 'omit';
-      }
+        expr: unknown,
+        options: {
+            typeAnnotation?: 'assert' | 'coerce' | 'omit';
+        }
     ): Expression {
         if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
             expr = ['literal', expr];

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

@@ -2,9 +2,9 @@
 // https://github.com/facebook/flow/issues/1270
 
 declare let Intl: {
-  Collator: {
-    new (...args: any): Intl$Collator;
-  };
+    Collator: {
+        new (...args: any): Intl$Collator;
+    };
 };
 
 declare class Intl$Collator {
@@ -14,12 +14,12 @@ declare class Intl$Collator {
 }
 
 type CollatorOptions = {
-  localeMatcher?: 'lookup' | 'best fit';
-  usage?: 'sort' | 'search';
-  sensitivity?: 'base' | 'accent' | 'case' | 'variant';
-  ignorePunctuation?: boolean;
-  numeric?: boolean;
-  caseFirst?: 'upper' | 'lower' | 'false';
+    localeMatcher?: 'lookup' | 'best fit';
+    usage?: 'sort' | 'search';
+    sensitivity?: 'base' | 'accent' | 'case' | 'variant';
+    ignorePunctuation?: boolean;
+    numeric?: boolean;
+    caseFirst?: 'upper' | 'lower' | 'false';
 };
 
 export default class Collator {

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

@@ -1,6 +1,6 @@
 export type ResolvedImageOptions = {
-  name: string;
-  available: boolean;
+    name: string;
+    available: boolean;
 };
 
 export default class ResolvedImage {

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

@@ -1,35 +1,35 @@
 export type NullTypeT = {
-  kind: 'null';
+    kind: 'null';
 };
 export type NumberTypeT = {
-  kind: 'number';
+    kind: 'number';
 };
 export type StringTypeT = {
-  kind: 'string';
+    kind: 'string';
 };
 export type BooleanTypeT = {
-  kind: 'boolean';
+    kind: 'boolean';
 };
 export type ColorTypeT = {
-  kind: 'color';
+    kind: 'color';
 };
 export type ObjectTypeT = {
-  kind: 'object';
+    kind: 'object';
 };
 export type ValueTypeT = {
-  kind: 'value';
+    kind: 'value';
 };
 export type ErrorTypeT = {
-  kind: 'error';
+    kind: 'error';
 };
 export type CollatorTypeT = {
-  kind: 'collator';
+    kind: 'collator';
 };
 export type FormattedTypeT = {
-  kind: 'formatted';
+    kind: 'formatted';
 };
 export type ResolvedImageTypeT = {
-  kind: 'resolvedImage';
+    kind: 'resolvedImage';
 };
 
 export type EvaluationKind = 'constant' | 'source' | 'camera' | 'composite';
@@ -38,9 +38,9 @@ export type Type = NullTypeT | NumberTypeT | StringTypeT | BooleanTypeT | ColorT
 ArrayType | ErrorTypeT | CollatorTypeT | FormattedTypeT | ResolvedImageTypeT;
 
 export type ArrayType = {
-  kind: 'array';
-  itemType: Type;
-  N: number;
+    kind: 'array';
+    itemType: Type;
+    N: number;
 };
 
 export type NativeType = 'number' | 'string' | 'boolean' | 'null' | 'array' | 'object';

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

@@ -28,7 +28,7 @@ export function validateRGBA(r: unknown, g: unknown, b: unknown, a?: unknown): s
 }
 
 export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | ReadonlyArray<Value> | {
-  readonly [x: string]: Value;
+    readonly [x: string]: Value;
 };
 
 export function isValue(mixed: unknown): boolean {

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

@@ -4,14 +4,14 @@ import type {CanonicalTileID} from '../../source/tile_id';
 import {StylePropertySpecification} from '../style-spec';
 
 type FilterExpression = (
-  globalProperties: GlobalProperties,
-  feature: Feature,
-  canonical?: CanonicalTileID
+    globalProperties: GlobalProperties,
+    feature: Feature,
+    canonical?: CanonicalTileID
 ) => boolean;
 
 export type FeatureFilter = {
-  filter: FilterExpression;
-  needGeometry: boolean;
+    filter: FilterExpression;
+    needGeometry: boolean;
 };
 
 export default createFilter;
@@ -26,36 +26,36 @@ function isExpressionFilter(filter: any) {
         return false;
     }
     switch (filter[0]) {
-    case 'has':
-        return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';
-
-    case 'in':
-        return filter.length >= 3 && (typeof filter[1] !== 'string' || Array.isArray(filter[2]));
-
-    case '!in':
-    case '!has':
-    case 'none':
-        return false;
-
-    case '==':
-    case '!=':
-    case '>':
-    case '>=':
-    case '<':
-    case '<=':
-        return filter.length !== 3 || (Array.isArray(filter[1]) || Array.isArray(filter[2]));
-
-    case 'any':
-    case 'all':
-        for (const f of filter.slice(1)) {
-            if (!isExpressionFilter(f) && typeof f !== 'boolean') {
-                return false;
+        case 'has':
+            return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';
+
+        case 'in':
+            return filter.length >= 3 && (typeof filter[1] !== 'string' || Array.isArray(filter[2]));
+
+        case '!in':
+        case '!has':
+        case 'none':
+            return false;
+
+        case '==':
+        case '!=':
+        case '>':
+        case '>=':
+        case '<':
+        case '<=':
+            return filter.length !== 3 || (Array.isArray(filter[1]) || Array.isArray(filter[2]));
+
+        case 'any':
+        case 'all':
+            for (const f of filter.slice(1)) {
+                if (!isExpressionFilter(f) && typeof f !== 'boolean') {
+                    return false;
+                }
             }
-        }
-        return true;
+            return true;
 
-    default:
-        return true;
+        default:
+            return true;
     }
 }
 
@@ -118,31 +118,31 @@ function convertFilter(filter?: Array<any> | null): unknown {
     if (filter.length <= 1) return (op !== 'any');
     const converted =
         op === '==' ? convertComparisonOp(filter[1], filter[2], '==') :
-        op === '!=' ? convertNegation(convertComparisonOp(filter[1], filter[2], '==')) :
-        op === '<' ||
+            op === '!=' ? convertNegation(convertComparisonOp(filter[1], filter[2], '==')) :
+                op === '<' ||
         op === '>' ||
         op === '<=' ||
         op === '>=' ? convertComparisonOp(filter[1], filter[2], op) :
-        op === 'any' ? convertDisjunctionOp(filter.slice(1)) :
-        op === 'all' ? ['all' as unknown].concat(filter.slice(1).map(convertFilter)) :
-        op === 'none' ? ['all' as unknown].concat(filter.slice(1).map(convertFilter).map(convertNegation)) :
-        op === 'in' ? convertInOp(filter[1], filter.slice(2)) :
-        op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) :
-        op === 'has' ? convertHasOp(filter[1]) :
-        op === '!has' ? convertNegation(convertHasOp(filter[1])) :
-        op === 'within' ? filter :
-        true;
+                    op === 'any' ? convertDisjunctionOp(filter.slice(1)) :
+                        op === 'all' ? ['all' as unknown].concat(filter.slice(1).map(convertFilter)) :
+                            op === 'none' ? ['all' as unknown].concat(filter.slice(1).map(convertFilter).map(convertNegation)) :
+                                op === 'in' ? convertInOp(filter[1], filter.slice(2)) :
+                                    op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) :
+                                        op === 'has' ? convertHasOp(filter[1]) :
+                                            op === '!has' ? convertNegation(convertHasOp(filter[1])) :
+                                                op === 'within' ? filter :
+                                                    true;
     return converted;
 }
 
 function convertComparisonOp(property: string, value: any, op: string) {
     switch (property) {
-    case '$type':
-        return [`filter-type-${op}`, value];
-    case '$id':
-        return [`filter-id-${op}`, value];
-    default:
-        return [`filter-${op}`, property, value];
+        case '$type':
+            return [`filter-type-${op}`, value];
+        case '$id':
+            return [`filter-id-${op}`, value];
+        default:
+            return [`filter-${op}`, property, value];
     }
 }
 
@@ -153,27 +153,27 @@ function convertDisjunctionOp(filters: Array<Array<any>>) {
 function convertInOp(property: string, values: Array<any>) {
     if (values.length === 0) { return false; }
     switch (property) {
-    case '$type':
-        return ['filter-type-in', ['literal', values]];
-    case '$id':
-        return ['filter-id-in', ['literal', values]];
-    default:
-        if (values.length > 200 && !values.some(v => typeof v !== typeof values[0])) {
-            return ['filter-in-large', property, ['literal', values.sort(compare)]];
-        } else {
-            return ['filter-in-small', property, ['literal', values]];
-        }
+        case '$type':
+            return ['filter-type-in', ['literal', values]];
+        case '$id':
+            return ['filter-id-in', ['literal', values]];
+        default:
+            if (values.length > 200 && !values.some(v => typeof v !== typeof values[0])) {
+                return ['filter-in-large', property, ['literal', values.sort(compare)]];
+            } else {
+                return ['filter-in-small', property, ['literal', values]];
+            }
     }
 }
 
 function convertHasOp(property: string) {
     switch (property) {
-    case '$type':
-        return true;
-    case '$id':
-        return ['filter-has-id'];
-    default:
-        return ['filter-has', property];
+        case '$type':
+            return true;
+        case '$id':
+            return ['filter-has-id'];
+        default:
+            return ['filter-has', property];
     }
 }
 

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

@@ -60,9 +60,9 @@ function convertIdentityFunction(parameters, propertySpec): Array<unknown> {
 
 function getInterpolateOperator(parameters) {
     switch (parameters.colorSpace) {
-    case 'hcl': return 'interpolate-hcl';
-    case 'lab': return 'interpolate-lab';
-    default: return 'interpolate';
+        case 'hcl': return 'interpolate-hcl';
+        case 'lab': return 'interpolate-lab';
+        default: return 'interpolate';
     }
 }