maplibre-gl 2.0.4 → 2.1.2

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

package/src/style-spec/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maplibre/maplibre-gl-style-spec",
   "description": "a specification for maplibre gl styles",
-  "version": "15.0.0",
+  "version": "15.1.0",
   "author": "MapLibre",
   "keywords": [
     "mapbox",

package/src/style-spec/reference/v8.json

@@ -1144,7 +1144,10 @@
       "default": false,
       "doc": "If true, the icon will be visible even if it collides with other previously drawn symbols.",
       "requires": [
-        "icon-image"
+        "icon-image",
+        {
+          "!": "icon-overlap"
+        }
       ],
       "sdk-support": {
         "basic functionality": {
@@ -1162,6 +1165,36 @@
       },
       "property-type": "data-constant"
     },
+    "icon-overlap": {
+      "type": "enum",
+      "values": {
+        "never": {
+          "doc": "The icon will be hidden if it collides with any other previously drawn symbol."
+        },
+        "always": {
+          "doc": "The icon will be visible even if it collides with any other previously drawn symbol."
+        },
+        "cooperative": {
+          "doc": "If the icon collides with another previously drawn symbol, the overlap mode for that symbol is checked. If the previous symbol was placed using `never` overlap mode, the new icon is hidden. If the previous symbol was placed using `always` or `cooperative` overlap mode, the new icon is visible."
+        }
+      },
+      "doc": "Allows for control over whether to show an icon when it overlaps other symbols on the map. If `icon-overlap` is not set, `icon-allow-overlap` is used instead.",
+      "requires": [
+        "icon-image"
+      ],
+      "sdk-support": {
+        "basic functionality": {
+          "js": "2.1.0"
+        }
+      },
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "property-type": "data-constant"
+    },
     "icon-ignore-placement": {
       "type": "boolean",
       "default": false,
@@ -2309,7 +2342,10 @@
       "default": false,
       "doc": "If true, the text will be visible even if it collides with other previously drawn symbols.",
       "requires": [
-        "text-field"
+        "text-field",
+        {
+          "!": "text-overlap"
+        }
       ],
       "sdk-support": {
         "basic functionality": {
@@ -2327,6 +2363,36 @@
       },
       "property-type": "data-constant"
     },
+    "text-overlap": {
+      "type": "enum",
+      "values": {
+        "never": {
+          "doc": "The text will be hidden if it collides with any other previously drawn symbol."
+        },
+        "always": {
+          "doc": "The text will be visible even if it collides with any other previously drawn symbol."
+        },
+        "cooperative": {
+          "doc": "If the text collides with another previously drawn symbol, the overlap mode for that symbol is checked. If the previous symbol was placed using `never` overlap mode, the new text is hidden. If the previous symbol was placed using `always` or `cooperative` overlap mode, the new text is visible."
+        }
+      },
+      "doc": "Allows for control over whether to show symbol text when it overlaps other symbols on the map. If `text-overlap` is not set, `text-allow-overlap` is used instead",
+      "requires": [
+        "text-field"
+      ],
+      "sdk-support": {
+        "basic functionality": {
+          "js": "2.1.0"
+        }
+      },
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "property-type": "data-constant"
+    },
     "text-ignore-placement": {
       "type": "boolean",
       "default": false,

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/types.ts

@@ -248,6 +248,7 @@ export type SymbolLayerSpecification = {
         "symbol-sort-key"?: DataDrivenPropertyValueSpecification<number>,
         "symbol-z-order"?: PropertyValueSpecification<"auto" | "viewport-y" | "source">,
         "icon-allow-overlap"?: PropertyValueSpecification<boolean>,
+        "icon-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">,
         "icon-ignore-placement"?: PropertyValueSpecification<boolean>,
         "icon-optional"?: PropertyValueSpecification<boolean>,
         "icon-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">,
@@ -281,6 +282,7 @@ export type SymbolLayerSpecification = {
         "text-transform"?: DataDrivenPropertyValueSpecification<"none" | "uppercase" | "lowercase">,
         "text-offset"?: DataDrivenPropertyValueSpecification<[number, number]>,
         "text-allow-overlap"?: PropertyValueSpecification<boolean>,
+        "text-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">,
         "text-ignore-placement"?: PropertyValueSpecification<boolean>,
         "text-optional"?: PropertyValueSpecification<boolean>,
         "visibility"?: "visible" | "none"

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