maplibre-gl 2.0.4 → 2.1.2

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/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 15.1.0
+
+### ✨ Features and improvements
+* Add `icon-overlap` and `text-overlap` symbol layout properties [#347](https://github.com/maplibre/maplibre-gl-js/pull/347)
+* Deprecate `icon-allow-overlap` and `text-allow-overlap` symbol layout properties. `icon-overlap` and `text-overlap` are their replacements.
+
 ## 15.0.0
 
 ### Breaking changes

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};

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 {