@mapbox/mapbox-gl-style-spec 14.25.0 → 14.26.0

package/expression/parsing_context.ts

@@ -10,7 +10,7 @@ import CollatorExpression from './definitions/collator';
 import Within from './definitions/within';
 import Distance from './definitions/distance';
 import Config from './definitions/config';
-import {isGlobalPropertyConstant, isFeatureConstant} from './is_constant';
+import {isGlobalPropertyConstantSet, isFeatureConstant} from './is_constant';
 import Var from './definitions/var';
 
 import type {Expression, ExpressionRegistry} from './expression';
@@ -36,9 +36,6 @@ class ParsingContext {
     // `expectedType`.
     expectedType: Type | null | undefined;
 
-    // `key` is only consulted on the error path, so compute it lazily.
-    private _key: string | undefined;
-
     constructor(
         registry: ExpressionRegistry,
         path: Array<number | string> = [],
@@ -60,16 +57,12 @@ class ParsingContext {
     }
 
     get key(): string {
-        if (this._key === undefined) {
-            const path = this.path;
-            let key = '';
-            for (let i = 0; i < path.length; i++) {
-                const part = path[i];
-                key += typeof part === 'string' ? `['${part}']` : `[${part}]`;
-            }
-            this._key = key;
+        let key = '';
+        for (let i = 0; i < this.path.length; i++) {
+            const part = this.path[i];
+            key += typeof part === 'string' ? `['${part}']` : `[${part}]`;
         }
-        return this._key;
+        return key;
     }
 
     /**
@@ -89,7 +82,17 @@ class ParsingContext {
         } = {},
     ): Expression | null | void {
         if (index || expectedType) {
-            return this.concat(index, null, expectedType, bindings)._parse(expr, options);
+            const prevExpectedType = this.expectedType;
+            const prevScope = this.scope;
+            if (bindings) this.scope = this.scope.concat(bindings);
+            this.expectedType = expectedType || null;
+            const pushed = typeof index === 'number';
+            if (pushed) this.path.push(index);
+            const result = this._parse(expr, options);
+            if (pushed) this.path.pop();
+            this.expectedType = prevExpectedType;
+            this.scope = prevScope;
+            return result;
         }
         return this._parse(expr, options);
     }
@@ -112,7 +115,18 @@ class ParsingContext {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
         } = {},
     ): Expression | null | void {
-        return this.concat(index, key, expectedType, bindings)._parse(expr, options);
+        const prevExpectedType = this.expectedType;
+        const prevScope = this.scope;
+        if (bindings) this.scope = this.scope.concat(bindings);
+        this.expectedType = expectedType || null;
+        this.path.push(index);
+        this.path.push(key);
+        const result = this._parse(expr, options);
+        this.path.pop();
+        this.path.pop();
+        this.expectedType = prevExpectedType;
+        this.scope = prevScope;
+        return result;
     }
 
     _parse(
@@ -125,16 +139,6 @@ class ParsingContext {
             expr = ['literal', expr];
         }
 
-        function annotate(parsed: Expression, type: Type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
-            if (typeAnnotation === 'assert') {
-                return new Assertion(type, [parsed]);
-            } else if (typeAnnotation === 'coerce') {
-                return new Coercion(type, [parsed]);
-            } else {
-                return parsed;
-            }
-        }
-
         if (Array.isArray(expr)) {
             if (expr.length === 0) {
                 return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
@@ -209,9 +213,10 @@ class ParsingContext {
         expectedType?: Type | null,
         bindings?: Array<[string, Expression]>,
     ): ParsingContext {
-        let path = typeof index === 'number' ? this.path.concat(index) : this.path;
-        path = typeof key === 'string' ? path.concat(key) : path;
         const scope = bindings ? this.scope.concat(bindings) : this.scope;
+        const path = this.path.slice();
+        if (typeof index === 'number') path.push(index);
+        if (typeof key === 'string') path.push(key);
         return new ParsingContext(
             this.registry,
             path,
@@ -224,6 +229,25 @@ class ParsingContext {
         );
     }
 
+    /**
+     * Returns a fresh context that shares the same path position as this one
+     * but has an empty errors array. Used by CompoundExpression to probe
+     * overload signatures without polluting the parent errors list.
+     * @private
+     */
+    _forkForSignature(): ParsingContext {
+        return new ParsingContext(
+            this.registry,
+            this.path.slice(),
+            null,
+            this.scope,
+            [],
+            this._scope,
+            this.options,
+            this.iconImageUseTheme
+        );
+    }
+
     /**
      * Push a parsing (or type checking) error into the `this.errors`
      * @param error The message
@@ -249,6 +273,22 @@ class ParsingContext {
 
 export default ParsingContext;
 
+const CONSTANT_FOLD_EXCLUDED_GLOBALS = new Set([
+    'zoom', 'heatmap-density', 'worldview', 'line-progress', 'raster-value',
+    'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch',
+    'distance-from-center', 'measure-light', 'raster-particle-speed', 'is-active-floor',
+]);
+
+function annotate(parsed: Expression, type: Type, typeAnnotation: 'assert' | 'coerce' | 'omit') {
+    if (typeAnnotation === 'assert') {
+        return new Assertion(type, [parsed]);
+    } else if (typeAnnotation === 'coerce') {
+        return new Coercion(type, [parsed]);
+    } else {
+        return parsed;
+    }
+}
+
 function isConstant(expression: Expression) {
     if (expression instanceof Var) {
         return isConstant(expression.boundExpression);
@@ -290,5 +330,5 @@ function isConstant(expression: Expression) {
     }
 
     return isFeatureConstant(expression) &&
-        isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'worldview', 'line-progress', 'raster-value', 'sky-radial-progress', 'accumulated', 'is-supported-script', 'pitch', 'distance-from-center', 'measure-light', 'raster-particle-speed', 'is-active-floor']);
+        isGlobalPropertyConstantSet(expression, CONSTANT_FOLD_EXCLUDED_GLOBALS);
 }

package/function/index.ts

@@ -33,7 +33,7 @@ export function createFunction(parameters, propertySpec) {
 
     if (isColor) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        parameters = Object.assign({}, parameters);
+        parameters = {...parameters};
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         if (parameters.stops) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.25.0",
+  "version": "14.26.0",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -46,7 +46,6 @@
   "dependencies": {
     "@mapbox/point-geometry": "^1.1.0",
     "@mapbox/unitbezier": "^1.0.0",
-    "cheap-ruler": "^4.0.0",
     "csscolorparser": "~1.0.3",
     "json-stringify-pretty-compact": "^4.0.0",
     "quickselect": "^3.0.0",

package/reference/v8.json

@@ -1335,6 +1335,24 @@
          "units": "degrees",
          "doc": "Override the orientation of the model node in euler angles [x, y, z]."
        }
+  },
+   "modelLightOverrides": {
+    "light-ambient-color": {
+      "type": "color",
+      "doc": "Override the color of ambient lights."
+    },
+    "light-ambient-intensity": {
+      "type": "number",
+      "doc": "Override the intensity of light-ambient-color (on a scale from 0 to 1)."
+    },
+     "light-directional-color": {
+      "type": "color",
+      "doc": "Override the color of directional lights."
+    },
+    "light-directional-intensity": {
+      "type": "number",
+      "doc": "Override the intensity of light-directional-color (on a scale from 0 to 1)."
+    }
   },
   "modelNodeOverrides": {
     "*": {
@@ -1393,6 +1411,11 @@
         "units": "degrees",
         "doc": "Orientation of the model in euler angles [x, y, z]."
       },
+      "lightOverrides": {
+        "type": "modelLightOverrides",
+        "required": false,
+        "doc": "A collection of light overrides."
+      },
       "nodeOverrides": {
         "type": "modelNodeOverrides",
         "required": false,
@@ -6653,13 +6676,6 @@
           "doc": "Projection where objects are of the same scale regardless of whether they are far away or near to the camera. Parallel lines remains parallel and there is no vanishing point."
         }
       },
-      "transition": true,
-      "expression": {
-        "interpolated": true,
-        "parameters": [
-          "zoom"
-        ]
-      },
       "sdk-support": {
         "basic functionality": {
           "js": "3.0.0",

package/types.ts

@@ -130,6 +130,12 @@ export type ModelsSpecification = {
     [_: string]: ModelSpecification
 };
 
+export type ModelLightOverridesSpecification = {
+    "light-ambient-color"?: ColorSpecification,
+    "light-ambient-intensity"?: number,
+    "light-directional-color"?: ColorSpecification,
+    "light-directional-intensity"?: number
+};
 export type ModelNodeOverrideSpecification = {
     "orientation"?: [number, number, number]
 };
@@ -152,6 +158,7 @@ export type ModelSourceModelSpecification = {
     "uri": string,
     "position"?: [number, number],
     "orientation"?: [number, number, number],
+    "lightOverrides"?: ModelLightOverridesSpecification,
     "nodeOverrides"?: ModelNodeOverridesSpecification,
     "materialOverrides"?: ModelMaterialOverridesSpecification,
     "nodeOverrideNames"?: Array<string>,
@@ -310,8 +317,7 @@ export type RainSpecification = {
 };
 
 export type CameraSpecification = {
-    "camera-projection"?: PropertyValueSpecification<"perspective" | "orthographic">,
-    "camera-projection-transition"?: TransitionSpecification
+    "camera-projection"?: "perspective" | "orthographic"
 };
 
 export type ColorThemeSpecification = {

package/util/geometry_util.ts

@@ -14,15 +14,15 @@ export type BBox = [number, number, number, number];
 export function calculateSignedArea(ring: Ring): number {
     let sum = 0;
     for (let i = 0, len = ring.length, j = len - 1, p1: Point, p2: Point; i < len; j = i++) {
-        p1 = ring[i];
-        p2 = ring[j];
+        p1 = ring[i] as Point;
+        p2 = ring[j] as Point;
         sum += (p2.x - p1.x) * (p1.y + p2.y);
     }
     return sum;
 }
 
 function compareAreas(a: Ring, b: Ring): number {
-    return b.area - a.area;
+    return (b.area as number) - (a.area as number);
 }
 
 // classifies an array of rings into polygons with outer rings and holes
@@ -32,22 +32,22 @@ export function classifyRings(rings: Array<Ring>, maxRings: number): Array<Array
     if (len <= 1) return [rings];
 
     const polygons: Array<Array<Ring>> = [];
-    let polygon: Array<Ring>,
-        ccw: boolean;
+    let polygon: Array<Ring> | undefined,
+        ccw: boolean | undefined;
 
     for (let i = 0; i < len; i++) {
-        const area = calculateSignedArea(rings[i]);
+        const area = calculateSignedArea(rings[i] as Ring);
         if (area === 0) continue;
 
-        rings[i].area = Math.abs(area);
+        (rings[i] as Ring).area = Math.abs(area);
 
         if (ccw === undefined) ccw = area < 0;
 
         if (ccw === area < 0) {
             if (polygon) polygons.push(polygon);
-            polygon = [rings[i]];
+            polygon = [rings[i] as Ring];
         } else {
-            (polygon).push(rings[i]);
+            (polygon as Array<Ring>).push(rings[i] as Ring);
         }
     }
     if (polygon) polygons.push(polygon);
@@ -56,9 +56,10 @@ export function classifyRings(rings: Array<Ring>, maxRings: number): Array<Array
     // reason, we limit strip out all but the `maxRings` largest rings.
     if (maxRings > 1) {
         for (let j = 0; j < polygons.length; j++) {
-            if (polygons[j].length <= maxRings) continue;
-            quickselect(polygons[j], maxRings, 1, polygons[j].length - 1, compareAreas);
-            polygons[j] = polygons[j].slice(0, maxRings);
+            const currentPolygon = polygons[j] as Array<Ring>;
+            if (currentPolygon.length <= maxRings) continue;
+            quickselect(currentPolygon, maxRings, 1, currentPolygon.length - 1, compareAreas);
+            polygons[j] = currentPolygon.slice(0, maxRings);
         }
     }
 
@@ -66,10 +67,10 @@ export function classifyRings(rings: Array<Ring>, maxRings: number): Array<Array
 }
 
 export function updateBBox(bbox: BBox, coord: GeoJSON.Position) {
-    bbox[0] = Math.min(bbox[0], coord[0]);
-    bbox[1] = Math.min(bbox[1], coord[1]);
-    bbox[2] = Math.max(bbox[2], coord[0]);
-    bbox[3] = Math.max(bbox[3], coord[1]);
+    bbox[0] = Math.min(bbox[0], coord[0] as number);
+    bbox[1] = Math.min(bbox[1], coord[1] as number);
+    bbox[2] = Math.max(bbox[2], coord[0] as number);
+    bbox[3] = Math.max(bbox[3], coord[1] as number);
 }
 
 export function boxWithinBox(bbox1: BBox, bbox2: BBox): boolean {
@@ -81,15 +82,15 @@ export function boxWithinBox(bbox1: BBox, bbox2: BBox): boolean {
 }
 
 function onBoundary(p: GeoJSON.Position, p1: GeoJSON.Position, p2: GeoJSON.Position) {
-    const x1 = p[0] - p1[0];
-    const y1 = p[1] - p1[1];
-    const x2 = p[0] - p2[0];
-    const y2 = p[1] - p2[1];
+    const x1 = (p[0] as number) - (p1[0] as number);
+    const y1 = (p[1] as number) - (p1[1] as number);
+    const x2 = (p[0] as number) - (p2[0] as number);
+    const y2 = (p[1] as number) - (p2[1] as number);
     return (x1 * y2 - x2 * y1 === 0) && (x1 * x2 <= 0) && (y1 * y2 <= 0);
 }
 
 function rayIntersect(p: GeoJSON.Position, p1: GeoJSON.Position, p2: GeoJSON.Position) {
-    return ((p1[1] > p[1]) !== (p2[1] > p[1])) && (p[0] < (p2[0] - p1[0]) * (p[1] - p1[1]) / (p2[1] - p1[1]) + p1[0]);
+    return (((p1[1] as number) > (p[1] as number)) !== ((p2[1] as number) > (p[1] as number))) && ((p[0] as number) < ((p2[0] as number) - (p1[0] as number)) * ((p[1] as number) - (p1[1] as number)) / ((p2[1] as number) - (p1[1] as number)) + (p1[0] as number));
 }
 
 // ray casting algorithm for detecting if point is in polygon
@@ -100,10 +101,10 @@ export function pointWithinPolygon(
 ): boolean {
     let inside = false;
     for (let i = 0, len = rings.length; i < len; i++) {
-        const ring = rings[i];
+        const ring = rings[i] as Array<GeoJSON.Position>;
         for (let j = 0, len2 = ring.length, k = len2 - 1; j < len2; k = j++) {
-            const q1 = ring[k];
-            const q2 = ring[j];
+            const q1 = ring[k] as GeoJSON.Position;
+            const q2 = ring[j] as GeoJSON.Position;
             if (onBoundary(point, q1, q2)) return trueOnBoundary;
             if (rayIntersect(point, q1, q2)) inside = !inside;
         }
@@ -112,18 +113,18 @@ export function pointWithinPolygon(
 }
 
 function perp(v1: GeoJSON.Position, v2: GeoJSON.Position) {
-    return v1[0] * v2[1] - v1[1] * v2[0];
+    return (v1[0] as number) * (v2[1] as number) - (v1[1] as number) * (v2[0] as number);
 }
 
 // check if p1 and p2 are in different sides of line segment q1->q2
 function twoSided(p1: GeoJSON.Position, p2: GeoJSON.Position, q1: GeoJSON.Position, q2: GeoJSON.Position) {
     // q1->p1 (x1, y1), q1->p2 (x2, y2), q1->q2 (x3, y3)
-    const x1 = p1[0] - q1[0];
-    const y1 = p1[1] - q1[1];
-    const x2 = p2[0] - q1[0];
-    const y2 = p2[1] - q1[1];
-    const x3 = q2[0] - q1[0];
-    const y3 = q2[1] - q1[1];
+    const x1 = (p1[0] as number) - (q1[0] as number);
+    const y1 = (p1[1] as number) - (q1[1] as number);
+    const x2 = (p2[0] as number) - (q1[0] as number);
+    const y2 = (p2[1] as number) - (q1[1] as number);
+    const x3 = (q2[0] as number) - (q1[0] as number);
+    const y3 = (q2[1] as number) - (q1[1] as number);
     const det1 = x1 * y3 - x3 * y1;
     const det2 = x2 * y3 - x3 * y2;
     if ((det1 > 0 && det2 < 0) || (det1 < 0 && det2 > 0)) return true;
@@ -139,8 +140,8 @@ export function segmentIntersectSegment(
     // check if two segments are parallel or not
     // precondition is end point a, b is inside polygon, if line a->b is
     // parallel to polygon edge c->d, then a->b won't intersect with c->d
-    const vectorP = [b[0] - a[0], b[1] - a[1]];
-    const vectorQ = [d[0] - c[0], d[1] - c[1]];
+    const vectorP = [(b[0] as number) - (a[0] as number), (b[1] as number) - (a[1] as number)];
+    const vectorQ = [(d[0] as number) - (c[0] as number), (d[1] as number) - (c[1] as number)];
     if (perp(vectorQ, vectorP) === 0) return false;
 
     // If lines are intersecting with each other, the relative location should be:
@@ -159,7 +160,7 @@ export function computeBounds(points: Point[][]): Bounds {
     const min = new Point(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
     const max = new Point(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
 
-    for (const point of points[0]) {
+    for (const point of points[0] as Point[]) {
         if (min.x > point.x) min.x = point.x;
         if (min.y > point.y) min.y = point.y;
         if (max.x < point.x) max.x = point.x;

package/util/interpolate.ts

@@ -14,6 +14,6 @@ export function color(from: Color, to: Color, t: number): Color {
 
 export function array(from: Array<number>, to: Array<number>, t: number): Array<number> {
     return from.map((d, i) => {
-        return number(d, to[i], t);
+        return number(d, to[i] as number, t);
     });
 }

package/validate/validate.ts

@@ -117,10 +117,11 @@ export default function validate(options: ValidatorOptions, arrayAsExpression: b
         return errors;
     }
 
-    const errors = validateObject(Object.assign({}, options, {
+    const errors = validateObject({
+        ...options,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec
-    }));
+    });
 
     return errors;
 }

package/validate/validate_appearance.ts

@@ -33,8 +33,8 @@ export default function validateAppearance(options: AppearanceValidatorOptions):
         style: options.style,
         styleSpec: options.styleSpec,
         objectElementValidators: {
-            condition: (options) => validateCondition(Object.assign({layer, layerType}, options)),
-            properties: (options) => validateProperties(Object.assign({layer, layerType}, options)),
+            condition: (options) => validateCondition({layer, layerType, ...options}),
+            properties: (options) => validateProperties({layer, layerType, ...options}),
         }
     });
 
@@ -65,7 +65,8 @@ function validateProperties(options: AppearanceValidatorOptions): Array<Validati
             continue;
         }
 
-        const propertyValidationOptions = Object.assign({}, options, {
+        const propertyValidationOptions = {
+            ...options,
             key: `${options.key}.${propertyKey}`,
             object: properties,
             objectKey: propertyKey,
@@ -73,7 +74,7 @@ function validateProperties(options: AppearanceValidatorOptions): Array<Validati
             layerType,
             value: properties[propertyKey] as unknown,
             valueSpec: (propertyType === 'paint' ? paintProperties[propertyKey] : layoutProperties[propertyKey]),
-        });
+        };
 
         errors.push(...validateProperty(propertyValidationOptions, propertyType));
     }

package/validate/validate_filter.ts

@@ -25,11 +25,12 @@ export default function validateFilter(options: FilterValidatorOptions): Validat
         // We default to a layerType of `fill` because that points to a non-dynamic filter definition within the style-spec.
         const layerType = options.layerType || 'fill';
 
-        return validateExpression(Object.assign({}, options, {
+        return validateExpression({
+            ...options,
             expressionContext: 'filter' as const,
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             valueSpec: options.styleSpec[`filter_${layerType}`]
-        }));
+        });
     } else {
         return validateNonExpressionFilter(options);
     }

package/validate/validate_import.ts

@@ -30,11 +30,12 @@ export default function validateImport(options: ImportValidatorOptions): Validat
         enumerable: false
     });
 
-    let errors = validateObject(Object.assign({}, options, {
+    let errors = validateObject({
+        ...options,
         value: importSpec,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: styleSpec.import
-    }));
+    });
 
     // Empty string is reserved for the root style id
     if (unbundle(importSpec.id) === '') {

package/validate/validate_layer.ts

@@ -132,7 +132,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                 });
             },
             filter(options) {
-                return validateFilter(Object.assign({layerType: type}, options));
+                return validateFilter({layerType: type, ...options});
             },
             layout(options) {
                 return validateObject({
@@ -144,7 +144,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
                         '*'(options: PropertyValidatorOptions) {
-                            return validateLayoutProperty(Object.assign({layerType: type}, options));
+                            return validateLayoutProperty({layerType: type, ...options});
                         }
                     }
                 });
@@ -159,7 +159,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                     styleSpec: options.styleSpec,
                     objectElementValidators: {
                         '*'(options: PropertyValidatorOptions) {
-                            return validatePaintProperty(Object.assign({layerType: type, layer}, options));
+                            return validatePaintProperty({layerType: type, layer, ...options});
                         }
                     }
                 });
@@ -172,7 +172,7 @@ export default function validateLayer(options: LayerValidatorOptions): Validatio
                     valueSpec: options.valueSpec,
                     style: options.style,
                     styleSpec: options.styleSpec,
-                    arrayElementValidator: (options) => validateAppearance(Object.assign({layerType: type, layer}, options) as AppearanceValidatorOptions)
+                    arrayElementValidator: (options) => validateAppearance(({layerType: type, layer, ...(options as object)}) as AppearanceValidatorOptions)
                 });
                 // Check non-repeated names on a given layer
                 const appearances = Array.isArray(options.value) ? options.value : [];

package/validate/validate_option.ts

@@ -19,7 +19,8 @@ export default function validateOption(options: ValidatorOptions): ValidationErr
     const isArrayOption = isObject(optionValue) && unbundle(optionValue.array) === true;
     const declaredType = !isArrayOption && isObject(optionValue) ? unbundle(optionValue.type) : undefined;
 
-    return validateObject(Object.assign({}, options, {
+    return validateObject({
+        ...options,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         valueSpec: styleSpec.option,
         objectElementValidators: declaredType ? {
@@ -28,10 +29,8 @@ export default function validateOption(options: ValidatorOptions): ValidationErr
             // permissive validation, mirroring the runtime parser's narrowing
             // in style.ts/parser.cpp.
             default: (elementOptions: ValidatorOptions): ValidationError[] => (Array.isArray(elementOptions.value) ?
-                validateSpec(Object.assign({}, elementOptions, {
-                    valueSpec: Object.assign({}, elementOptions.valueSpec, {type: declaredType}),
-                })) :
+                validateSpec({...elementOptions, valueSpec: {...elementOptions.valueSpec, type: declaredType} as typeof elementOptions.valueSpec}) :
                 validateSpec(elementOptions)),
         } : undefined,
-    }));
+    });
 }

package/validate/validate_style.ts

@@ -14,12 +14,11 @@ export default function validateStyle(style: unknown, styleSpec: StyleReference
         key: options.key || '',
         value: style,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        valueSpec: Object.assign(
-            {},
-            styleSpec.$root,
+        valueSpec: {
+            ...styleSpec.$root,
             // Skip validation of the root properties that are not defined in the style spec (e.g. 'owner').
-            {'*': {type: '*'}},
-        ),
+            '*': {type: '*'},
+        },
         styleSpec,
         style,
         objectElementValidators: {