@mapbox/mapbox-gl-style-spec 14.11.0 → 14.12.0-beta.1

package/expression/compound_expression.ts

@@ -73,7 +73,7 @@ class CompoundExpression implements Expression {
 
         const overloadParams = [];
 
-        let signatureContext: ParsingContext = (null as any);
+        let signatureContext: ParsingContext = null;
 
         let overloadIndex = -1;
 

package/expression/definitions/coalesce.ts

@@ -21,7 +21,7 @@ class Coalesce implements Expression {
             // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Coalesce'.
             return context.error("Expectected at least one argument.");
         }
-        let outputType: Type = (null as any);
+        let outputType: Type = null;
         const expectedType = context.expectedType;
         if (expectedType && expectedType.kind !== 'value') {
             outputType = expectedType;
@@ -46,7 +46,7 @@ class Coalesce implements Expression {
 
         return needsAnnotation ?
             new Coalesce(ValueType, parsedArgs) :
-            new Coalesce((outputType as any), parsedArgs);
+            new Coalesce(outputType, parsedArgs);
     }
 
     evaluate(ctx: EvaluationContext): any {

package/expression/definitions/config.ts

@@ -101,7 +101,7 @@ class Config implements Expression {
             if (typeof result === 'number') {
                 result = clampToAllowedNumber(result, minValue, maxValue, stepValue);
             } else if (Array.isArray(result)) {
-                result = result.map((item) => typeof item === 'number' ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item);
+                result = result.map((item) => (typeof item === 'number' ? clampToAllowedNumber(item, minValue, maxValue, stepValue) : item));
             }
         }
 

package/expression/definitions/index.ts

@@ -47,6 +47,7 @@ import Distance from './distance';
 import {mulberry32} from '../../util/random';
 
 import type {Type} from '../types';
+import type {Value} from '../values';
 import type EvaluationContext from '../evaluation_context';
 import type {Varargs} from '../compound_expression';
 import type {Expression, ExpressionRegistry} from '../expression';
@@ -242,7 +243,7 @@ CompoundExpression.register(expressions, {
     'properties': [
         ObjectType,
         [],
-        (ctx) => ctx.properties()
+        (ctx) => ctx.properties() as Value
     ],
     'geometry-type': [
         StringType,
@@ -302,7 +303,7 @@ CompoundExpression.register(expressions, {
     'accumulated': [
         ValueType,
         [],
-        (ctx) => ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated
+        (ctx) => (ctx.globals.accumulated === undefined ? null : ctx.globals.accumulated)
     ],
     '+': [
         NumberType,

package/expression/definitions/interpolate.ts

@@ -91,7 +91,7 @@ class Interpolate implements Expression {
 
             interpolation = {
                 name: 'cubic-bezier',
-                controlPoints: (controlPoints as any)
+                controlPoints
             };
         } else {
             return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
@@ -110,7 +110,7 @@ class Interpolate implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = (null as any);
+        let outputType: Type = null;
         if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
             outputType = ColorType;
         } else if (context.expectedType && context.expectedType.kind !== 'value') {

package/expression/definitions/match.ts

@@ -138,7 +138,7 @@ class Match implements Expression {
             }
         }
 
-        const coerceLabel = (label: number | string) => this.inputType.kind === 'number' ? Number(label) : label;
+        const coerceLabel = (label: number | string) => (this.inputType.kind === 'number' ? Number(label) : label);
 
         for (const [outputIndex, labels] of groupedByOutput) {
             if (labels.length === 1) {

package/expression/definitions/step.ts

@@ -40,7 +40,7 @@ class Step implements Expression {
 
         const stops: Stops = [];
 
-        let outputType: Type = (null as any);
+        let outputType: Type = null;
         if (context.expectedType && context.expectedType.kind !== 'value') {
             outputType = context.expectedType;
         }

package/expression/evaluation_context.ts

@@ -27,7 +27,7 @@ class EvaluationContext {
     };
 
     constructor(scope?: string | null, options?: ConfigOptions | null) {
-        this.globals = (null as any);
+        this.globals = null;
         this.feature = null;
         this.featureState = null;
         this.formattedSection = null;
@@ -40,7 +40,7 @@ class EvaluationContext {
         this.options = options;
     }
 
-    id(): number | null {
+    id(): string | number | null {
         return this.feature && this.feature.id !== undefined ? this.feature.id : null;
     }
 
@@ -56,9 +56,7 @@ class EvaluationContext {
         return this.canonical;
     }
 
-    properties(): {
-        [key: string]: any;
-        } {
+    properties(): {readonly [key: string]: unknown} {
         return (this.feature && this.feature.properties) || {};
     }
 

package/expression/index.ts

@@ -39,13 +39,9 @@ import type {ImageId} from './types/image_id';
 
 export interface Feature {
     readonly type: 0 | 1 | 2 | 3 | 'Unknown' | 'Point' | 'LineString' | 'Polygon';
-    readonly id?: number | null;
-    readonly properties: {
-        [_: string]: any;
-    };
-    readonly patterns?: {
-        [_: string]: string;
-    };
+    readonly id?: string | number | null;
+    readonly properties: Record<PropertyKey, unknown>;
+    readonly patterns?: Record<PropertyKey, string>;
     readonly geometry?: Array<Array<Point>>;
 }
 
@@ -135,7 +131,7 @@ export class StyleExpression {
                 throw new RuntimeError(`Expected value to be one of ${Object.keys(this._enumValues).map(v => JSON.stringify(v)).join(', ')}, but found ${JSON.stringify(val)} instead.`);
             }
             return val;
-        } catch (e: any) {
+        } catch (e) {
             if (!this._warningHistory[e.message]) {
                 this._warningHistory[e.message] = true;
                 if (typeof console !== 'undefined') {

package/expression/parsing_context.ts

@@ -157,7 +157,7 @@ class ParsingContext {
                     const ec = new EvaluationContext(this._scope, this.options);
                     try {
                         parsed = new Literal(parsed.type, parsed.evaluate(ec));
-                    } catch (e: any) {
+                    } catch (e) {
                         this.error(e.message);
                         return null;
                     }

package/expression/values.ts

@@ -51,9 +51,7 @@ export function validateHSLA(h: unknown, s: unknown, l: unknown, a?: unknown): s
     return null;
 }
 
-export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | ReadonlyArray<Value> | {
-    readonly [key: string]: Value;
-};
+export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | ReadonlyArray<Value> | {readonly [key: string]: Value};
 
 export function isValue(mixed: unknown): boolean {
     if (mixed === null) {

package/feature_filter/index.ts

@@ -99,7 +99,7 @@ function createFilter(filter?: FilterSpecification, scope: string = "", options:
     let staticFilter = true;
     try {
         staticFilter = extractStaticFilter(filterExp);
-    } catch (e: any) {
+    } catch (e) {
         console.warn(
 `Failed to extract static filter. Filter will continue working, but at higher memory usage and slower framerate.
 This is most likely a bug, please report this via https://github.com/mapbox/mapbox-gl-js/issues/new?assignees=&labels=&template=Bug_report.md

package/migrate/expressions.ts

@@ -10,7 +10,7 @@ import type {StyleSpecification, FunctionSpecification} from '../types';
  * this will convert (a) "stop" functions, and (b) legacy filters to their
  * expression equivalents.
  */
-export default function(style: StyleSpecification): StyleSpecification {
+export default function (style: StyleSpecification): StyleSpecification {
     const converted = [];
 
     eachLayer(style, (layer) => {

package/migrate/v8.ts

@@ -34,7 +34,7 @@ function renameProperty(obj, from, to) {
     obj[to] = obj[from]; delete obj[from];
 }
 
-export default function(style) {
+export default function (style) {
     style.version = 8;
 
     // Rename properties, reverse coordinates in source and layers

package/migrate/v9.ts

@@ -8,7 +8,7 @@ function eachLayer(style, callback) {
     }
 }
 
-export default function(style) {
+export default function (style) {
     style.version = 9;
 
     // remove user-specified refs

package/migrate.ts

@@ -17,7 +17,7 @@ import migrateToExpressions from './migrate/expressions';
  * var style = fs.readFileSync('./style.json', 'utf8');
  * fs.writeFileSync('./style.json', JSON.stringify(migrate(style)));
  */
-export default function(style) {
+export default function (style) {
     let migrated = false;
 
     if (style.version === 7) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.11.0",
+  "version": "14.12.0-beta.1",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",

package/reference/v8.json

@@ -1367,6 +1367,13 @@
             }
           }
         },
+        "building": {
+          "doc": "A procedural 3D building.",
+          "sdk-support": {
+          },
+          "experimental": true,
+          "private": true
+        },
         "raster": {
           "doc": "Raster map textures such as satellite imagery.",
           "sdk-support": {
@@ -1508,6 +1515,7 @@
     "layout_circle",
     "layout_heatmap",
     "layout_fill-extrusion",
+    "layout_building",
     "layout_symbol",
     "layout_raster",
     "layout_raster-particle",
@@ -1957,6 +1965,115 @@
       "property-type": "constant"
     }
   },
+  "layout_building": {
+    "visibility": {
+      "type": "enum",
+      "values": {
+        "visible": {
+          "doc": "The layer is shown."
+        },
+        "none": {
+          "doc": "The layer is not shown."
+        }
+      },
+      "default": "visible",
+      "doc": "Whether this layer is displayed.",
+      "sdk-support": {
+        "basic functionality": {
+        }
+      },
+      "expression": {
+        "interpolated": false
+      },
+      "property-type": "constant"
+    },
+    "building-roof-shape": {
+      "type": "enum",
+      "values": {
+        "flat": {
+          "doc": "Use regular extruded buildings with flat roofs."
+        },
+        "hipped": {
+          "doc": "Use hipped roof for the procedurally generated buildings."
+        },
+        "gabled": {
+          "doc": "Use gabled roof for the procedurally generated buildings."
+        },
+        "parapet": {
+          "doc": "Use parapet roof for the procedurally generated buildings."
+        },
+        "mansard": {     
+          "doc": "Use mansard roof for the procedurally generated buildings."
+        },
+        "skillion": {      
+          "doc": "Use skillion roof for the procedurally generated buildings."
+        },
+        "pyramidal": {    
+          "doc": "Use pyramidal roof for the procedurally generated buildings."
+        }
+      },
+      "default": "flat",
+      "doc": "Roof type to use for the procedural buildings.",
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+        },
+        "data-driven styling": {
+        }
+      },
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "feature"
+        ]
+      },
+      "property-type": "data-driven"
+    },
+    "building-height": {
+      "type": "number",
+      "default": 0,
+      "minimum": 0,
+      "units": "meters",
+      "doc": "The height of the procedural buildings.",
+      "transition": true,
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+        },
+        "data-driven styling": {
+        }
+      },
+      "expression": {
+        "interpolated": false
+      },
+      "property-type": "data-driven"
+    },
+    "building-base": {
+      "type": "number",
+      "default": 0,
+      "minimum": 0,
+      "units": "meters",
+      "doc": "The height with which to extrude the base of this layer. Must be less than or equal to `building-height`.",
+      "transition": true,
+      "requires": [
+        "building-height"
+      ],
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+        },
+        "data-driven styling": {
+        }
+      },
+      "expression": {
+        "interpolated": false
+      },
+      "property-type": "data-driven"
+    }
+  },
   "layout_line": {
     "line-cap": {
       "type": "enum",
@@ -3925,6 +4042,17 @@
       "parameters": ["zoom", "feature"]
     }
   },
+  "filter_building": {
+    "type": "boolean",
+    "doc": "Expression which determines whether or not to display a Polygon. Building layer does NOT support dynamic filtering, meaning this expression can NOT use the `[\"pitch\"]` and `[\"distance-from-center\"]` expressions to reference the current state of the view.",
+    "default": false,
+    "transition": false,
+    "property-type": "data-driven",
+    "expression": {
+      "interpolated": false,
+      "parameters": ["zoom", "feature"]
+    }
+  },
   "filter_heatmap": {
     "type": "boolean",
     "doc": "Expression used to determine whether a point is being displayed or not. Heatmap layer does NOT support dynamic filtering, meaning this expression can NOT use the `[\"pitch\"]` and `[\"distance-from-center\"]` expressions to reference the current state of the view.",
@@ -6247,6 +6375,7 @@
     "paint_circle",
     "paint_heatmap",
     "paint_fill-extrusion",
+    "paint_building",
     "paint_symbol",
     "paint_raster",
     "paint_raster-particle",
@@ -7235,6 +7364,189 @@
       "property-type": "data-constant"
     }
   },
+  "paint_building": {
+    "building-opacity": {
+      "type": "number",
+      "default": 1,
+      "minimum": 0,
+      "maximum": 1,
+      "doc": "The opacity of the entire procedural buildings layer. This is rendered on a per-layer, not per-feature, basis, and data-driven styling is not available.",
+      "transition": true,
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+        }
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "property-type": "data-constant"
+    },
+    "building-ambient-occlusion-wall-intensity": {
+      "property-type": "data-constant",
+      "type": "number",
+      "default": 0,
+      "minimum": 0,
+      "maximum": 1,
+      "experimental": true,
+      "private": true,
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "transition": true,
+      "doc": "Controls the intensity of shading concave angles between walls and building elements, such as facades and rooftop.",
+      "sdk-support": {
+        "basic functionality": {
+        }
+      }
+    },
+    "building-ambient-occlusion-ground-intensity": {
+      "property-type": "data-constant",
+      "type": "number",
+      "default": 0,
+      "minimum": 0,
+      "maximum": 1,
+      "experimental": true,
+      "private": true,
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "transition": true,
+      "doc": "Controls the intensity of shading near ground",
+      "sdk-support": {
+        "basic functionality": {
+        }
+      }
+    },
+    "building-ambient-occlusion-ground-radius": {
+      "property-type": "data-constant",
+      "type": "number",
+      "experimental": true,
+      "private": true,
+      "default": 3.0,
+      "minimum": 0,
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "transition": true,
+      "doc": "The extent of the ambient occlusion effect on the ground beneath the procedural buildings in meters.",
+      "sdk-support": {
+        "basic functionality": {
+        }
+      }
+    },
+    "building-ambient-occlusion-ground-attenuation": {
+      "property-type": "data-constant",
+      "type": "number",
+      "experimental": true,
+      "private": true,
+      "default": 0.69,
+      "minimum": 0.0,
+      "maximum": 1.0,
+      "doc": "Provides a control to further fine-tune the look of the ambient occlusion on the ground beneath the procedural buildings. Lower values give the effect a more solid look while higher values make it smoother.",
+      "transition": true,
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "sdk-support": {
+        "basic functionality": {
+        }
+      }
+    },
+    "building-vertical-scale": {
+      "property-type": "data-constant",
+      "type": "number",
+      "experimental": true,
+      "private": true,
+      "default": 1.0,
+      "minimum": 0.0,
+      "doc": "A global multiplier that can be used to scale base and height of the procedural buildings.",
+      "transition": true,
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "zoom"
+        ]
+      },
+      "sdk-support": {
+        "basic functionality": {
+        }
+      }
+    },
+    "building-cast-shadows": {
+      "type": "boolean",
+      "default": true,
+      "doc": "Enable/Disable shadow casting for this layer",
+      "transition": false,
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+          "basic functionality": {
+        }
+      },
+      "property-type": "data-constant"
+    },
+    "building-color": {
+      "type": "color",
+      "default": "rgba(193, 154, 127, 1)",
+      "doc": "Color buildings. This can be styled using different building parts (e.g. windows, wall, roof, etc.). This won't be used if `building-roof-shape` has a value `flat`.",
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+        },
+        "data-driven styling": {
+        }
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "feature",
+          "feature-state"
+        ]
+      },
+      "property-type": "data-driven"
+    },
+    "building-emissive-strength": {
+      "type": "number",
+      "default": 0,
+      "minimum": 0,
+      "doc": "Controls the intensity of light emitted on the source features.",
+      "experimental": true,
+      "private": true,
+      "sdk-support": {
+        "basic functionality": {
+        },
+        "data-driven styling": {
+        }
+      },
+      "expression": {
+        "interpolated": true,
+        "parameters": [
+          "feature",
+          "feature-state",
+          "measure-light"
+        ]
+      },
+      "property-type": "data-driven"
+    }
+  },
   "paint_line": {
     "line-opacity": {
       "type": "number",

package/test.js

@@ -4,13 +4,11 @@ import fs from 'fs';
 import {execSync} from 'child_process';
 import {createRequire} from 'module';
 
-// @ts-expect-error - TS2345 - Argument of type 'Buffer' is not assignable to parameter of type 'string'.
-const packageJson = JSON.parse(fs.readFileSync('./package.json'));
+const packageJson = JSON.parse(fs.readFileSync('./package.json').toString());
 
-process.on('unhandledRejection', (error) => {
+process.on('unhandledRejection', (/** @type {Error} */ error) => {
     // don't log `error` directly, because errors from child_process.execSync
     // contain an (undocumented) `envPairs` with environment variable values
-    // @ts-expect-error - TS2339 - Property 'message' does not exist on type 'unknown'.
     console.log(error.message || 'unhandledRejection');
     process.exit(1);
 });