Fix tests, add missing interpolation due to merge

src/expression/definitions/interpolate.ts

@@ -2,16 +2,17 @@ import UnitBezier from '@mapbox/unitbezier';
 
 import {array, ArrayType, ColorType, ColorTypeT, NumberType, NumberTypeT, PaddingType, PaddingTypeT, VariableAnchorOffsetCollectionType, VariableAnchorOffsetCollectionTypeT, typeToString, verifyType, ProjectionDefinitionType} from '../types';
 import {findStopLessThanOrEqualTo} from '../stops';
+import {Color} from '../types/color';
+import {interpolateArray, interpolateNumber} from '../../util/interpolate-primitives';
+import {Padding} from '../types/padding';
+import {VariableAnchorOffsetCollection} from '../types/variable_anchor_offset_collection';
+import {ProjectionDefinition} from '../types/projection_definition';
 
 import type {Stops} from '../stops';
 import type {Expression} from '../expression';
 import type {ParsingContext} from '../parsing_context';
 import type {EvaluationContext} from '../evaluation_context';
 import type {ProjectionDefinitionTypeT, StringTypeT, Type} from '../types';
-import {Color} from '../types/color';
-import {interpolateArray, interpolateNumber} from '../../util/interpolate-primitives';
-import {Padding} from '../types/padding';
-import {VariableAnchorOffsetCollection} from '../types/variable_anchor_offset_collection';
 
 export type InterpolationType = {
     name: 'linear';
@@ -186,6 +187,8 @@ export class Interpolate implements Expression {
                         return VariableAnchorOffsetCollection.interpolate(outputLower, outputUpper, t);
                     case 'array':
                         return interpolateArray(outputLower, outputUpper, t);
+                    case 'projectionDefinition':
+                        return ProjectionDefinition.interpolate(outputLower, outputUpper, t);
                 }
             case 'interpolate-hcl':
                 return Color.interpolate(outputLower, outputUpper, t, 'hcl');

src/expression/expression.test.ts

@@ -645,7 +645,15 @@ describe('projection expression', () => {
     })
 
     test('step array', () => {
-        const response = createExpression(['step', ['zoom'], ['literal', ['vertical-perspective', 'mercator', 0.5]], 10, 'mercator']);
+        const response = createExpression(['step', ['zoom'], ['literal', ['vertical-perspective', 'mercator', 0.5]], 10, 'mercator'], { 
+            type: 'projectionDefinition', 
+            transition: false,
+            "property-type": "data-constant",
+            expression: {
+                interpolated: true,
+                parameters: ["zoom"]
+            }
+        });
 
         if (response.result === 'success') {
             expect(response.value.evaluate({zoom: 5})).toStrictEqual(['vertical-perspective', 'mercator', 0.5]);
@@ -656,25 +664,20 @@ describe('projection expression', () => {
         }
     })
 
-    test('interpolate color', () => {
-
-        const response = createExpression(['interpolate', ['linear'], ['zoom'], 8, 'vertical-perspective', 10, 'mercator']);
-
-        if (response.result === 'success') {
-            expect(response.value.evaluate({zoom: 5})).toBe('vertical-perspective');
-            expect(response.value.evaluate({zoom: 9})).toBe(['vertical-perspective', 'mercator', 0.5]);
-            expect(response.value.evaluate({zoom: 11})).toBe('mercator');
-        } else {
-            throw new Error('Failed to parse Interpolate expression');
-        }
-    })
-
     test('interpolate', () => {
-        const response = createExpression(['interpolate', ['linear'], ['zoom'], 8, 'vertical-perspective', 10, 'mercator']);
+        const response = createExpression(['interpolate', ['linear'], ['zoom'], 8, 'vertical-perspective', 10, 'mercator'], { 
+            type: 'projectionDefinition', 
+            transition: false,
+            "property-type": "data-constant",
+            expression: {
+                interpolated: true,
+                parameters: ["zoom"]
+            }
+        });
 
         if (response.result === 'success') {
             expect(response.value.evaluate({zoom: 5})).toBe('vertical-perspective');
-            expect(response.value.evaluate({zoom: 9})).toBe(['vertical-perspective', 'mercator', 0.5]);
+            expect(response.value.evaluate({zoom: 9})).toEqual({from: 'vertical-perspective', to: 'mercator', transition: 0.5});
             expect(response.value.evaluate({zoom: 11})).toBe('mercator');
         } else {
             throw new Error('Failed to parse Interpolate expression');

src/expression/types/projection_definition.ts

@@ -1,5 +1,9 @@
 export class ProjectionDefinition {
-    constructor(public from: string, public to: string, public transition: number){
+    readonly from: string;
+    readonly to: string;
+    readonly transition: number;
+
+    constructor(from: string, to: string, transition: number){
         this.from = from;
         this.to = to;
         this.transition = transition;

src/validate/validate_projection.test.ts

@@ -25,7 +25,7 @@ describe('Validate projection', () => {
     test('Should return errors according to spec violations', () => {
         const errors = validateProjection({validateSpec: validate, value: {type: 1 as any}, styleSpec: v8, style: {} as any});
         expect(errors).toHaveLength(1);
-        expect(errors[0].message).toBe('projection: object expected, number found');
+        expect(errors[0].message).toBe('type: projection expected, invalid type \"number\" found');
     });
 
     test('Should return error when value is null', () => {

test/integration/expression/tests/step/projection/step-array/test.json

@@ -1,6 +1,6 @@
 {
     "propertySpec": {
-      "type": "string",
+      "type": "projectionDefinition",
       "property-type": "data-constant",
       "expression": {
         "interpolated": true,
@@ -31,7 +31,7 @@
         "result": "success",
         "isFeatureConstant": true,
         "isZoomConstant": false,
-        "type": "string"
+        "type": "projectionDefinition"
       },
       "outputs": [
         [