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

package/expression/definitions/interpolate.ts

@@ -1,10 +1,8 @@
 import UnitBezier from '@mapbox/unitbezier';
 import * as interpolate from '../../util/interpolate';
-import {toString, NumberType, ColorType, ValueType} from '../types';
+import {toString, NumberType, ColorType} from '../types';
 import {findStopLessThanOrEqualTo} from '../stops';
 import {hcl, lab} from '../../util/color_spaces';
-import Literal from './literal';
-import RuntimeError from '../runtime_error';
 
 import type Color from '../../util/color';
 import type {Stops} from '../stops';
@@ -13,32 +11,30 @@ import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
 import type {Type} from '../types';
 
-export type InterpolationType = {
-    name: 'linear';
-} | {
-    name: 'exponential';
-    base: number;
-} | {
-    name: 'cubic-bezier';
-    controlPoints: [number, number, number, number];
-};
+export type InterpolationType =
+    | {name: 'linear'}
+    | {name: 'exponential'; base: number}
+    | {name: 'cubic-bezier'; controlPoints: [number, number, number, number]};
+
+export type InterpolationOperator =
+    | 'interpolate'
+    | 'interpolate-hcl'
+    | 'interpolate-lab';
 
 class Interpolate implements Expression {
     type: Type;
 
-    operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab';
+    operator: InterpolationOperator;
     interpolation: InterpolationType;
     input: Expression;
-    dynamicStops: Expression | null;
     labels: Array<number>;
     outputs: Array<Expression>;
 
-    constructor(type: Type, operator: 'interpolate' | 'interpolate-hcl' | 'interpolate-lab', interpolation: InterpolationType, input: Expression, dynamicStops: Expression | null, stops: Stops) {
+    constructor(type: Type, operator: InterpolationOperator, interpolation: InterpolationType, input: Expression, stops: Stops) {
         this.type = type;
         this.operator = operator;
         this.interpolation = interpolation;
         this.input = input;
-        this.dynamicStops = dynamicStops;
 
         this.labels = [];
         this.outputs = [];
@@ -67,11 +63,10 @@ class Interpolate implements Expression {
         return t;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Interpolate | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Interpolate | null | void {
         let [operator, interpolation, input, ...rest] = args;
 
         if (!Array.isArray(interpolation) || interpolation.length === 0) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Expected an interpolation type expression.`, 1);
         }
 
@@ -80,7 +75,6 @@ class Interpolate implements Expression {
         } else if (interpolation[0] === 'exponential') {
             const base = interpolation[1];
             if (typeof base !== 'number')
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error(`Exponential interpolation requires a numeric base.`, 1, 1);
             interpolation = {
                 name: 'exponential',
@@ -92,7 +86,6 @@ class Interpolate implements Expression {
                 controlPoints.length !== 4 ||
                 controlPoints.some(t => typeof t !== 'number' || t < 0 || t > 1)
             ) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error('Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.', 1);
             }
 
@@ -101,17 +94,14 @@ class Interpolate implements Expression {
                 controlPoints: (controlPoints as any)
             };
         } else {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
         }
 
-        if (args.length - 1 < 3) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
-            return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
+        if (args.length - 1 < 4) {
+            return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         }
 
         if (args.length - 1 > 3 && (args.length - 1) % 2 !== 0) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Expected an even number of arguments.`);
         }
 
@@ -127,15 +117,6 @@ class Interpolate implements Expression {
             outputType = context.expectedType;
         }
 
-        // Exactly 3 arguments means that the steps are created by an expression
-        if (args.length - 1 === 3) {
-            const dynamicStops = context.parse(rest[0], 3, ValueType);
-            if (!dynamicStops) return null;
-
-            // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'InterpolationType'.
-            return new Interpolate(outputType, (operator as any), interpolation, input, dynamicStops, stops);
-        }
-
         for (let i = 0; i < rest.length; i += 2) {
             const label = rest[i];
             const value = rest[i + 1];
@@ -144,12 +125,10 @@ class Interpolate implements Expression {
             const valueKey = i + 4;
 
             if (typeof label !== 'number') {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
             }
 
             if (stops.length && stops[stops.length - 1][0] >= label) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
                 return context.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 
@@ -167,41 +146,15 @@ class Interpolate implements Expression {
                 typeof outputType.N === 'number'
             )
         ) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Interpolate'.
             return context.error(`Type ${toString(outputType)} is not interpolatable.`);
         }
 
-        // @ts-expect-error - TS2345 - Argument of type 'unknown' is not assignable to parameter of type 'InterpolationType'.
-        return new Interpolate(outputType, (operator as any), interpolation, input, null, stops);
+        return new Interpolate(outputType, operator as InterpolationOperator, interpolation as InterpolationType, input as Expression, stops);
     }
 
     evaluate(ctx: EvaluationContext): Color {
-        let labels = this.labels;
-        let outputs = this.outputs;
-
-        if (this.dynamicStops) {
-            const dynamicStopsValue = (this.dynamicStops.evaluate(ctx) as [number]);
-            if (dynamicStopsValue.length % 2 !== 0) {
-                throw new RuntimeError('Expected an even number of arguments.');
-            }
-            labels = [];
-            outputs = [];
-            for (let i = 0; i < dynamicStopsValue.length; i += 2) {
-                const label = dynamicStopsValue[i];
-                const output = new Literal(NumberType, dynamicStopsValue[i + 1]);
-                if (typeof label !== 'number') {
-                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.');
-                }
-                if (labels.length && labels[labels.length - 1] >= label) {
-                    throw new RuntimeError('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.');
-                }
-                labels.push(label);
-                outputs.push(output);
-            }
-            if (labels.length === 0) {
-                throw new RuntimeError('Expected at least one input/output pair.');
-            }
-        }
+        const labels = this.labels;
+        const outputs = this.outputs;
 
         if (labels.length === 1) {
             return outputs[0].evaluate(ctx);
@@ -246,31 +199,26 @@ class Interpolate implements Expression {
     }
 
     serialize(): SerializedExpression {
-        let interpolation;
+        let interpolation: [InterpolationType['name'], ...number[]];
         if (this.interpolation.name === 'linear') {
-            interpolation = ["linear"];
+            interpolation = ['linear'];
         } else if (this.interpolation.name === 'exponential') {
             if  (this.interpolation.base === 1) {
-                interpolation = ["linear"];
+                interpolation = ['linear'];
             } else {
-                interpolation = ["exponential", this.interpolation.base];
+                interpolation = ['exponential', this.interpolation.base];
             }
         } else {
-            // @ts-expect-error - TS2769 - No overload matches this call.
-            interpolation = ["cubic-bezier" ].concat(this.interpolation.controlPoints);
+            interpolation = ['cubic-bezier', ...this.interpolation.controlPoints];
         }
 
         const serialized = [this.operator, interpolation, this.input.serialize()];
 
-        if (this.dynamicStops) {
-            serialized.push(this.dynamicStops.serialize());
-        } else {
-            for (let i = 0; i < this.labels.length; i++) {
-                serialized.push(
-                    this.labels[i],
-                    this.outputs[i].serialize()
-                );
-            }
+        for (let i = 0; i < this.labels.length; i++) {
+            serialized.push(
+                this.labels[i],
+                this.outputs[i].serialize()
+            );
         }
         return serialized;
     }

package/expression/definitions/let.ts

@@ -25,9 +25,8 @@ class Let implements Expression {
         fn(this.result);
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Let | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Let | null | void {
         if (args.length < 4)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Let'.
             return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
 
         const bindings: Array<[string, Expression]> = [];
@@ -35,12 +34,10 @@ class Let implements Expression {
             const name = args[i];
 
             if (typeof name !== 'string') {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Let'.
                 return context.error(`Expected string, but found ${typeof name} instead.`, i);
             }
 
             if (/[^a-zA-Z0-9_]/.test(name)) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Let'.
                 return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
             }
 
@@ -61,12 +58,10 @@ class Let implements Expression {
     }
 
     serialize(): SerializedExpression {
-        const serialized = ["let"];
+        const serialized: SerializedExpression[] = ["let"];
         for (const [name, expr] of this.bindings) {
-            // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
             serialized.push(name, expr.serialize());
         }
-        // @ts-expect-error - TS2345 - Argument of type 'SerializedExpression' is not assignable to parameter of type 'string'.
         serialized.push(this.result.serialize());
         return serialized;
     }

package/expression/definitions/literal.ts

@@ -58,8 +58,7 @@ class Literal implements Expression {
             // Constant-folding can generate Literal expressions that you
             // couldn't actually generate with a "literal" expression,
             // so we have to implement an equivalent serialization here
-            // @ts-expect-error - TS2769 - No overload matches this call.
-            return ["rgba"].concat(this.value.toRenderColor(null).toArray());
+            return ["rgba" as SerializedExpression].concat(this.value.toRenderColor(null).toArray());
         } else if (this.value instanceof Formatted) {
             // Same as Color
             return this.value.serialize();

package/expression/definitions/match.ts

@@ -28,12 +28,10 @@ class Match implements Expression {
         this.otherwise = otherwise;
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Match | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Match | null | void {
         if (args.length < 5)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         if (args.length % 2 !== 1)
-        // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
             return context.error(`Expected an even number of arguments.`);
 
         let inputType;
@@ -52,23 +50,17 @@ class Match implements Expression {
             }
 
             const labelContext = context.concat(i);
-            // @ts-expect-error - TS2339 - Property 'length' does not exist on type 'unknown'.
-            if (labels.length === 0) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
+            if ((labels as unknown[]).length === 0) {
                 return labelContext.error('Expected at least one branch label.');
             }
 
-            // @ts-expect-error - TS2488 - Type 'unknown' must have a '[Symbol.iterator]()' method that returns an iterator.
-            for (const label of labels) {
+            for (const label of (labels as unknown[])) {
                 if (typeof label !== 'number' && typeof label !== 'string') {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error(`Branch labels must be numbers or strings.`);
                 } else if (typeof label === 'number' && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
 
                 } else if (typeof label === 'number' && Math.floor(label) !== label) {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error(`Numeric branch labels must be integer values.`);
 
                 } else if (!inputType) {
@@ -78,7 +70,6 @@ class Match implements Expression {
                 }
 
                 if (typeof cases[String(label)] !== 'undefined') {
-                    // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Match'.
                     return labelContext.error('Branch labels must be unique.');
                 }
 

package/expression/definitions/step.ts

@@ -26,14 +26,12 @@ class Step implements Expression {
         }
     }
 
-    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Step | null | undefined {
+    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Step | null | void {
         if (args.length - 1 < 4) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
             return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
         }
 
         if ((args.length - 1) % 2 !== 0) {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
             return context.error(`Expected an even number of arguments.`);
         }
 
@@ -55,12 +53,10 @@ class Step implements Expression {
             const valueKey = i + 1;
 
             if (typeof label !== 'number') {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
                 return context.error('Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.', labelKey);
             }
 
             if (stops.length && stops[stops.length - 1][0] >= label) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Step'.
                 return context.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.', labelKey);
             }
 

package/expression/evaluation_context.ts

@@ -88,10 +88,9 @@ class EvaluationContext {
         return 0;
     }
 
-    parseColor(input: string): Color | null | undefined {
+    parseColor(input: string): Color | undefined {
         let cached = this._parseColorCache[input];
         if (!cached) {
-            // @ts-expect-error - TS2322 - Type 'void | Color' is not assignable to type 'Color'. | TS2322 - Type 'void | Color' is not assignable to type 'Color'.
             cached = this._parseColorCache[input] = Color.parse(input);
         }
         return cached;

package/expression/index.ts

@@ -339,19 +339,16 @@ export interface CompositeExpression {
 export type StylePropertyExpression = ConstantExpression | SourceExpression | CameraExpression | CompositeExpression;
 
 export function createPropertyExpression(
-    expression: unknown,
+    expression: any,
     propertySpec: StylePropertySpecification,
     scope?: string | null,
     options?: ConfigOptions | null,
 ): Result<StylePropertyExpression, Array<ParsingError>> {
     expression = createExpression(expression, propertySpec, scope, options);
-    // @ts-expect-error - TS2339 - Property 'result' does not exist on type 'unknown'.
     if (expression.result === 'error') {
-        // @ts-expect-error - TS2322 - Type 'unknown' is not assignable to type 'Result<StylePropertyExpression, ParsingError[]>'.
         return expression;
     }
 
-    // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
     const parsed = expression.value.expression;
 
     const isFeatureConstant = isConstant.isFeatureConstant(parsed);
@@ -386,18 +383,14 @@ export function createPropertyExpression(
 
     if (!zoomCurve) {
         return success((isFeatureConstant && isLineProgressConstant) ?
-        // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
             (new ZoomConstantExpression('constant', expression.value, isLightConstant, isLineProgressConstant) as ConstantExpression) :
-        // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
             (new ZoomConstantExpression('source', expression.value, isLightConstant, isLineProgressConstant) as SourceExpression));
     }
 
     const interpolationType = zoomCurve instanceof Interpolate ? zoomCurve.interpolation : undefined;
 
     return success((isFeatureConstant && isLineProgressConstant) ?
-    // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
         (new ZoomDependentExpression('camera', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CameraExpression) :
-    // @ts-expect-error - TS2339 - Property 'value' does not exist on type 'unknown'.
         (new ZoomDependentExpression('composite', expression.value, zoomCurve.labels, interpolationType, isLightConstant, isLineProgressConstant) as CompositeExpression));
 }
 

package/expression/parsing_context.ts

@@ -70,7 +70,7 @@ class ParsingContext {
         options: {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
         } = {},
-    ): Expression | null | undefined {
+    ): Expression | null | void {
         if (index || expectedType) {
             return this.concat(index, null, expectedType, bindings)._parse(expr, options);
         }
@@ -94,7 +94,7 @@ class ParsingContext {
         options: {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
         } = {},
-    ): Expression | null | undefined {
+    ): Expression | null | void {
         return this.concat(index, key, expectedType, bindings)._parse(expr, options);
     }
 
@@ -103,7 +103,7 @@ class ParsingContext {
         options: {
             typeAnnotation?: 'assert' | 'coerce' | 'omit';
         },
-    ): Expression | null | undefined {
+    ): Expression | null | void {
         if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
             expr = ['literal', expr];
         }
@@ -120,7 +120,6 @@ class ParsingContext {
 
         if (Array.isArray(expr)) {
             if (expr.length === 0) {
-                // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
                 return this.error(`Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`);
             }
 
@@ -170,13 +169,10 @@ class ParsingContext {
             // Try to parse as array
             return Coercion.parse(['to-array', expr], this);
         } else if (typeof expr === 'undefined') {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return this.error(`'undefined' value invalid. Use null instead.`);
         } else if (typeof expr === 'object') {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return this.error(`Bare objects invalid. Use ["literal", {...}] instead.`);
         } else {
-            // @ts-expect-error - TS2322 - Type 'void' is not assignable to type 'Expression'.
             return this.error(`Expected an array, but found ${typeof expr} instead.`);
         }
     }

package/format.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 
 import reference from './reference/latest';

package/function/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 
 import * as colorSpaces from '../util/color_spaces';

package/migrate/v8.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 import {eachSource, eachLayer, eachProperty} from '../visit';
 

package/migrate/v9.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 import deref from '../deref';
 

package/migrate.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 
 import migrateToV8 from './migrate/v8';

package/package.json

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

package/read_style.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
 
 import ParsingError from './error/parsing_error';