maplibre-gl 2.2.0-pre.3 → 2.2.1

package/src/style-spec/feature_filter/convert.ts

@@ -1,17 +1,8 @@
 import {isExpressionFilter} from './index';
 
-import type {FilterSpecification} from '../types.g';
+import type {ExpressionFilterSpecification, ExpressionInputType, ExpressionSpecification, FilterSpecification, LegacyFilterSpecification} from '../types.g';
 
-type ExpectedTypes = {[_: string]: 'string' | 'number' | 'boolean'};
-
-/**
- * Convert the given legacy filter to (the JSON representation of) an
- * equivalent expression
- * @private
- */
-export default function convertFilter(filter: FilterSpecification): unknown {
-    return _convertFilter(filter, {});
-}
+type ExpectedTypes = {[_: string]: ExpressionInputType};
 
 /*
  * Convert the given filter to an expression, storing the expected types for
@@ -61,51 +52,58 @@ export default function convertFilter(filter: FilterSpecification): unknown {
  * false (legacy filter semantics) are equivalent: they cause the filter to
  * produce a `false` result.
  */
-function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes): unknown {
-    if (isExpressionFilter(filter)) { return filter; }
-
+export default function convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes = {}): ExpressionFilterSpecification {
+    if (isExpressionFilter(filter)) return filter;
     if (!filter) return true;
-    const op = filter[0];
-    if (filter.length <= 1) return (op !== 'any');
-
-    let converted;
-
-    if (
-        op === '==' ||
-        op === '!=' ||
-        op === '<' ||
-        op === '>' ||
-        op === '<=' ||
-        op === '>='
-    ) {
-        const [, property, value] = filter;
-        converted = convertComparisonOp(property as string, value, op, expectedTypes);
-    } else if (op === 'any') {
-        const children = (filter).slice(1).map((f: FilterSpecification) => {
-            const types = {};
-            const child = _convertFilter(f, types);
-            const typechecks = runtimeTypeChecks(types);
-            return typechecks === true ? child : ['case', typechecks, child, false];
-        });
-        return ['any'].concat(children as string[]);
-    } else if (op === 'all') {
-        const children = (filter).slice(1).map(f => _convertFilter(f as FilterSpecification, expectedTypes));
-        return children.length > 1 ? ['all'].concat(children as string[]) : [].concat(...children);
-    } else if (op === 'none') {
-        return ['!', _convertFilter(['any'].concat(filter.slice(1) as string[]) as string[], {})];
-    } else if (op === 'in') {
-        converted = convertInOp(filter[1] as string, filter.slice(2));
-    } else if (op === '!in') {
-        converted = convertInOp(filter[1] as string, filter.slice(2), true);
-    } else if (op === 'has') {
-        converted = convertHasOp(filter[1] as string);
-    } else if (op === '!has') {
-        converted = ['!', convertHasOp(filter[1] as string)];
-    } else {
-        converted = true;
-    }
 
-    return converted;
+    const legacyFilter = filter as LegacyFilterSpecification;
+    const legacyOp = legacyFilter[0];
+    if (filter.length <= 1) return (legacyOp !== 'any');
+
+    switch (legacyOp) {
+        case '==':
+        case '!=':
+        case '<':
+        case '>':
+        case '<=':
+        case '>=': {
+            const [, property, value] = filter;
+            return convertComparisonOp(property as string, value, legacyOp, expectedTypes);
+        }
+        case 'any': {
+            const [, ...conditions] = legacyFilter;
+            const children = conditions.map((f: LegacyFilterSpecification) => {
+                const types = {};
+                const child = convertFilter(f, types);
+                const typechecks = runtimeTypeChecks(types);
+                return typechecks === true ? child : ['case', typechecks, child, false] as ExpressionSpecification;
+            });
+            return ['any', ...children];
+        }
+        case 'all': {
+            const [, ...conditions] = legacyFilter;
+            const children = conditions.map(f => convertFilter(f, expectedTypes));
+            return children.length > 1 ? ['all', ...children] : children[0];
+        }
+        case 'none': {
+            const [, ...conditions] = legacyFilter;
+            return ['!', convertFilter(['any', ...conditions], {})];
+        }
+        case 'in': {
+            const [, property, ...values] = legacyFilter;
+            return convertInOp(property, values);
+        }
+        case '!in': {
+            const [, property, ...values] = legacyFilter;
+            return convertInOp(property, values, true);
+        }
+        case 'has':
+            return convertHasOp(legacyFilter[1]);
+        case '!has':
+            return ['!', convertHasOp(legacyFilter[1])];
+        default:
+            return true;
+    }
 }
 
 // Given a set of feature properties and an expected type for each one,
@@ -116,7 +114,7 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
 //   ['==', ['typeof', ['get', 'name'], 'string']],
 //   ['==', ['typeof', ['get', 'population'], 'number]]
 // ]
-function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
+function runtimeTypeChecks(expectedTypes: ExpectedTypes): ExpressionFilterSpecification {
     const conditions = [];
     for (const property in expectedTypes) {
         const get = property === '$id' ? ['id'] : ['get', property];
@@ -124,13 +122,13 @@ function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
     }
     if (conditions.length === 0) return true;
     if (conditions.length === 1) return conditions[0];
-    return ['all'].concat(conditions);
+    return ['all', ...conditions];
 }
 
-function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null) {
+function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null): ExpressionFilterSpecification {
     let get;
     if (property === '$type') {
-        return [op, ['geometry-type'], value];
+        return [op, ['geometry-type'], value] as ExpressionFilterSpecification;
     } else if (property === '$id') {
         get = ['id'];
     } else {
@@ -156,13 +154,13 @@ function convertComparisonOp(property: string, value: any, op: string, expectedT
         ];
     }
 
-    return [op, get, value];
+    return [op, get, value] as ExpressionFilterSpecification;
 }
 
-function convertInOp(property: string, values: Array<any>, negate = false) {
+function convertInOp(property: string, values: Array<any>, negate = false): ExpressionFilterSpecification {
     if (values.length === 0) return negate;
 
-    let get;
+    let get: ExpressionSpecification;
     if (property === '$type') {
         get = ['geometry-type'];
     } else if (property === '$id') {
@@ -190,12 +188,14 @@ function convertInOp(property: string, values: Array<any>, negate = false) {
         return ['match', get, uniqueValues, !negate, negate];
     }
 
-    return [ negate ? 'all' : 'any' as any].concat(
-        values.map(v => [negate ? '!=' : '==', get, v])
-    );
+    if (negate) {
+        return ['all', ...values.map(v => ['!=', get, v] as ExpressionSpecification)];
+    } else {
+        return ['any', ...values.map(v => ['==', get, v] as ExpressionSpecification)];
+    }
 }
 
-function convertHasOp(property: string) {
+function convertHasOp(property: string): ExpressionFilterSpecification {
     if (property === '$type') {
         return true;
     } else if (property === '$id') {

package/src/style-spec/feature_filter/feature_filter.test.ts

@@ -5,10 +5,39 @@ import Point from '@mapbox/point-geometry';
 import MercatorCoordinate from '../../geo/mercator_coordinate';
 import EXTENT from '../../data/extent';
 import {CanonicalTileID} from '../../source/tile_id';
-import {FilterSpecification} from '../types.g';
+import {ExpressionFilterSpecification, FilterSpecification} from '../types.g';
 import {Feature} from '../expression';
 
 describe('filter', () => {
+    test('exprssions transpilation test', () => {
+        function compileTimeCheck(_: ExpressionFilterSpecification) {
+            expect(true).toBeTruthy();
+        }
+        compileTimeCheck(['any']);
+        compileTimeCheck(['at', 2, ['array', 1, 2, 3]]);
+        compileTimeCheck(['case', ['has', 'color'], ['get', 'color'], 'white']);
+        compileTimeCheck(['case', ['all', ['has', 'point_count'], ['<', ['get', 'point_count'], 3]], ['get', 'cluster_routes'], '']);
+        compileTimeCheck(['interpolate', ['linear'], ['get', 'point_count'], 2, 18.0, 10, 24.0]);
+        compileTimeCheck(['case', ['has', 'point_count'], ['interpolate', ['linear'], ['get', 'point_count'], 2, 18.0, 10, 24.0], 12.0]);
+        compileTimeCheck([
+            'case',
+            ['has', 'point_count'], ['interpolate', ['linear'], ['get', 'point_count'], 2, '#ccc', 10, '#444'],
+            ['has', 'priorityValue'], ['interpolate', ['linear'], ['get', 'priorityValue'], 0, '#ff9', 1, '#f66'],
+            '#fcaf3e'
+        ]);
+        compileTimeCheck([
+            'case',
+            ['==', ['get', 'CAPITAL'], 1], 'city-capital',
+            ['>=', ['get', 'POPULATION'], 1000000], 'city-1M',
+            ['>=', ['get', 'POPULATION'], 500000], 'city-500k',
+            ['>=', ['get', 'POPULATION'], 100000], 'city-100k',
+            'city'
+        ]);
+        compileTimeCheck(['match', ['get', 'TYPE'], ['TARGETPOINT:HOSPITAL'], true, false]);
+        compileTimeCheck(['match', ['get', 'TYPE'], ['ADIZ', 'AMA', 'AWY', 'CLASS', 'NO-FIR', 'OCA', 'OTA', 'P', 'RAS', 'RCA', 'UTA', 'UTA-P'], true, false]);
+        compileTimeCheck(['==', ['get', 'MILITARYAIRPORT'], 1]);
+    });
+
     test('expression, zoom', () => {
         const f = createFilter(['>=', ['number', ['get', 'x']], ['zoom']]).filter;
         expect(f({zoom: 1}, {properties: {x: 0}} as any as Feature)).toBe(false);
@@ -52,6 +81,18 @@ describe('filter', () => {
         expect(createFilter(['any', false, false]).filter(undefined, undefined)).toBe(false);
     });
 
+    test('expression, literal', () => {
+        expect(createFilter(['literal', true]).filter(undefined, undefined)).toBe(true);
+        expect(createFilter(['literal', false]).filter(undefined, undefined)).toBe(false);
+    });
+
+    test('expression, match', () => {
+        const match = createFilter(['match', ['get', 'x'], ['a', 'b', 'c'], true, false]).filter;
+        expect(match(undefined, {properties: {x: 'a'}} as any as Feature)).toBe(true);
+        expect(match(undefined, {properties: {x: 'c'}} as any as Feature)).toBe(true);
+        expect(match(undefined, {properties: {x: 'd'}} as any as Feature)).toBe(false);
+    });
+
     test('expression, type error', () => {
         expect(() => {
             createFilter(['==', ['number', ['get', 'x']], ['string', ['get', 'y']]]);
@@ -77,7 +118,7 @@ describe('filter', () => {
         };
         const withinFilter =  createFilter(['within', {'type': 'Polygon', 'coordinates': [[[0, 0], [5, 0], [5, 5], [0, 5], [0, 0]]]}]);
         expect(withinFilter.needGeometry).toBe(true);
-        const canonical = {z: 3, x: 3, y:3} as CanonicalTileID;
+        const canonical = {z: 3, x: 3, y: 3} as CanonicalTileID;
         expect(
             withinFilter.filter({zoom: 3}, {type: 1, geometry: [[getPointFromLngLat(2, 2, canonical)]]} as Feature, canonical)
         ).toBe(true);
@@ -179,14 +220,14 @@ describe('convert legacy filters to expressions', () => {
                 ['LineString', 'Point', 'Polygon'],
                 true,
                 false
-            ] as FilterSpecification,
+            ],
             [
                 'match',
                 ['get', 'type'],
                 ['island'],
                 true,
                 false
-            ] as FilterSpecification
+            ]
         ];
 
         const converted = convertFilter(filter);

package/src/style-spec/feature_filter/index.ts

@@ -2,6 +2,7 @@ import {createExpression} from '../expression';
 import type {GlobalProperties, Feature} from '../expression';
 import type {CanonicalTileID} from '../../source/tile_id';
 import {StylePropertySpecification} from '../style-spec';
+import {ExpressionFilterSpecification} from '../types.g';
 
 type FilterExpression = (
     globalProperties: GlobalProperties,
@@ -17,7 +18,7 @@ export type FeatureFilter = {
 export default createFilter;
 export {isExpressionFilter};
 
-function isExpressionFilter(filter: any) {
+function isExpressionFilter(filter: any): filter is ExpressionFilterSpecification {
     if (filter === true || filter === false) {
         return true;
     }

package/src/style-spec/function/index.test.ts

@@ -1,6 +1,7 @@
 import {createFunction} from './index';
 import Color from '../util/color';
 import Formatted from '../expression/types/formatted';
+import Padding from '../util/padding';
 
 describe('binary search', () => {
     test('will eventually terminate.', () => {
@@ -235,6 +236,19 @@ describe('exponential function', () => {
         expect(params).toEqual(paramsCopy);
     });
 
+    test('padding', () => {
+        const f = createFunction({
+            type: 'exponential',
+            stops: [[1, 2], [11, [2, 5, 2, 7]]]
+        }, {
+            type: 'padding'
+        }).evaluate;
+
+        expect(f({zoom: 0}, undefined)).toEqual(new Padding([2, 2, 2, 2]));
+        expect(f({zoom: 5}, undefined)).toEqual(new Padding([2, 3.2, 2, 4]));
+        expect(f({zoom: 11}, undefined)).toEqual(new Padding([2, 5, 2, 7]));
+    });
+
     test('property present', () => {
         const f = createFunction({
             property: 'foo',
@@ -532,11 +546,24 @@ describe('interval function', () => {
         }).evaluate;
 
         expect(f({zoom: 0}, undefined)).toEqual(new Color(1, 0, 0, 1));
-        expect(f({zoom: 0}, undefined)).toEqual(new Color(1, 0, 0, 1));
+        expect(f({zoom: 10}, undefined)).toEqual(new Color(1, 0, 0, 1));
         expect(f({zoom: 11}, undefined)).toEqual(new Color(0, 0, 1, 1));
 
     });
 
+    test('padding', () => {
+        const f = createFunction({
+            type: 'interval',
+            stops: [[1, 2], [11, 4]]
+        }, {
+            type: 'padding'
+        }).evaluate;
+
+        expect(f({zoom: 0}, undefined)).toEqual(new Padding([2, 2, 2, 2]));
+        expect(f({zoom: 10}, undefined)).toEqual(new Padding([2, 2, 2, 2]));
+        expect(f({zoom: 11}, undefined)).toEqual(new Padding([4, 4, 4, 4]));
+    });
+
     test('property present', () => {
         const f = createFunction({
             property: 'foo',
@@ -746,6 +773,47 @@ describe('categorical function', () => {
 
     });
 
+    test('padding', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'categorical',
+            stops: [[0, 2], [1, 4]]
+        }, {
+            type: 'padding'
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {foo: 0}})).toEqual(new Padding([2, 2, 2, 2]));
+        expect(f({zoom: 1}, {properties: {foo: 1}})).toEqual(new Padding([4, 4, 4, 4]));
+    });
+
+    test('padding function default', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'categorical',
+            stops: [[0, 2], [1, 4]],
+            default: 6
+        }, {
+            type: 'padding'
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {}})).toEqual(new Padding([6, 6, 6, 6]));
+        expect(f({zoom: 0}, {properties: {foo: 3}})).toEqual(new Padding([6, 6, 6, 6]));
+    });
+
+    test('padding spec default', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'categorical',
+            stops: [[0, 2], [1, 4]]
+        }, {
+            type: 'padding',
+            default: 6
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {}})).toEqual(new Padding([6, 6, 6, 6]));
+        expect(f({zoom: 0}, {properties: {foo: 3}})).toEqual(new Padding([6, 6, 6, 6]));
+    });
+
     test('boolean', () => {
         const f = createFunction({
             property: 'foo',
@@ -853,6 +921,54 @@ describe('identity function', () => {
 
     });
 
+    test('padding', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'identity'
+        }, {
+            type: 'padding'
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {foo: 3}})).toEqual(new Padding([3, 3, 3, 3]));
+        expect(f({zoom: 1}, {properties: {foo: [3, 4]}})).toEqual(new Padding([3, 4, 3, 4]));
+    });
+
+    test('padding function default', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'identity',
+            default: [1, 2, 3, 4]
+        }, {
+            type: 'padding'
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {}})).toEqual(new Padding([1, 2, 3, 4]));
+    });
+
+    test('padding spec default', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'identity'
+        }, {
+            type: 'padding',
+            default: [1, 2, 3, 4]
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {}})).toEqual(new Padding([1, 2, 3, 4]));
+    });
+
+    test('padding invalid', () => {
+        const f = createFunction({
+            property: 'foo',
+            type: 'identity'
+        }, {
+            type: 'padding',
+            default: [1, 2, 3, 4]
+        }).evaluate;
+
+        expect(f({zoom: 0}, {properties: {foo: 'invalid'}})).toEqual(new Padding([1, 2, 3, 4]));
+    });
+
     test('property type mismatch, function default', () => {
         const f = createFunction({
             property: 'foo',

package/src/style-spec/function/index.ts

@@ -9,6 +9,7 @@ import Formatted from '../expression/types/formatted';
 import ResolvedImage from '../expression/types/resolved_image';
 import {supportsInterpolation} from '../util/properties';
 import {findStopLessThanOrEqualTo} from '../expression/stops';
+import Padding from '../util/padding';
 
 export function isFunction(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -25,19 +26,21 @@ export function createFunction(parameters, propertySpec) {
     const zoomDependent = zoomAndFeatureDependent || !featureDependent;
     const type = parameters.type || (supportsInterpolation(propertySpec) ? 'exponential' : 'interval');
 
-    if (isColor) {
+    if (isColor || propertySpec.type === 'padding') {
+        const parseFn = isColor ? Color.parse : Padding.parse;
+
         parameters = extend({}, parameters);
 
         if (parameters.stops) {
             parameters.stops = parameters.stops.map((stop) => {
-                return [stop[0], Color.parse(stop[1])];
+                return [stop[0], parseFn(stop[1])];
             });
         }
 
         if (parameters.default) {
-            parameters.default = Color.parse(parameters.default);
+            parameters.default = parseFn(parameters.default);
         } else {
-            parameters.default = Color.parse(propertySpec.default);
+            parameters.default = parseFn(propertySpec.default);
         }
     }
 
@@ -198,14 +201,23 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
 }
 
 function evaluateIdentityFunction(parameters, propertySpec, input) {
-    if (propertySpec.type === 'color') {
-        input = Color.parse(input);
-    } else if (propertySpec.type === 'formatted') {
-        input = Formatted.fromString(input.toString());
-    } else if (propertySpec.type === 'resolvedImage') {
-        input = ResolvedImage.fromString(input.toString());
-    } else if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
-        input = undefined;
+    switch (propertySpec.type) {
+        case 'color':
+            input = Color.parse(input);
+            break;
+        case 'formatted':
+            input = Formatted.fromString(input.toString());
+            break;
+        case 'resolvedImage':
+            input = ResolvedImage.fromString(input.toString());
+            break;
+        case 'padding':
+            input = Padding.parse(input);
+            break;
+        default:
+            if (getType(input) !== propertySpec.type && (propertySpec.type !== 'enum' || !propertySpec.values[input])) {
+                input = undefined;
+            }
     }
     return coalesce(input, parameters.default, propertySpec.default);
 }

package/src/style-spec/migrate/expressions.ts

@@ -15,7 +15,7 @@ export default function expressions(style: StyleSpecification) {
 
     eachLayer(style, (layer: LayerSpecification & { filter?: FilterSpecification }) => {
         if (layer.filter) {
-            layer.filter = (convertFilter(layer.filter) as any);
+            layer.filter = convertFilter(layer.filter);
         }
     });
 

package/src/style-spec/migrate/v8.test.ts

@@ -1,3 +1,5 @@
+// @ts-nocheck
+
 import migrate from './v8';
 
 describe('migrate v8', () => {

package/src/style-spec/migrate/v9.test.ts

@@ -1,3 +1,5 @@
+// @ts-nocheck
+
 import migrate from './v9';
 
 describe('migrate v9', () => {
@@ -5,7 +7,7 @@ describe('migrate v9', () => {
         const input = {
             version: 8,
             sources: {
-                a: {type: 'vector', tiles: [ 'http://dev/null' ]}
+                a: {type: 'vector', tiles: ['http://dev/null']}
             },
             layers: [{
                 id: 'parent',
@@ -21,7 +23,7 @@ describe('migrate v9', () => {
         expect(migrate(input)).toEqual({
             version: 9,
             sources: {
-                a: {type: 'vector', tiles: [ 'http://dev/null' ]}
+                a: {type: 'vector', tiles: ['http://dev/null']}
             },
             layers: [{
                 id: 'parent',
@@ -42,7 +44,7 @@ describe('migrate v9', () => {
         const input = {
             version: 8,
             sources: {
-                a: {type: 'vector', tiles: [ 'http://dev/null' ]}
+                a: {type: 'vector', tiles: ['http://dev/null']}
             },
             layers: [{
                 id: 'a',
@@ -61,7 +63,7 @@ describe('migrate v9', () => {
         expect(migrate(input)).toEqual({
             version: 9,
             sources: {
-                a: {type: 'vector', tiles: [ 'http://dev/null' ]}
+                a: {type: 'vector', tiles: ['http://dev/null']}
             },
             layers: [{
                 id: 'a',

package/src/style-spec/migrate.test.ts

@@ -1,3 +1,5 @@
+// @ts-nocheck
+
 import migrate from './migrate';
 import * as spec from './style-spec';
 import v8 from './reference/v8.json';
@@ -102,7 +104,7 @@ describe('migrate', () => {
         });
         expect(migrated.layers[0].layout['icon-image']).toEqual([
             'match',
-            ['get', 'type' ],
+            ['get', 'type'],
             'park',
             'some-icon',
             ''

package/src/style-spec/package.json

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

package/src/style-spec/reference/latest.ts

@@ -1,3 +1,3 @@
 
-import spec from './v8.json';
-export default spec;
+import spec from './v8.json' assert {type: 'json'};
+export default spec as any;

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

@@ -1466,11 +1466,10 @@
       "property-type": "data-driven"
     },
     "icon-padding": {
-      "type": "number",
-      "default": 2,
-      "minimum": 0,
+      "type": "padding",
+      "default": [2],
       "units": "pixels",
-      "doc": "Size of the additional area around the icon bounding box used for detecting symbol collisions.",
+      "doc": "Size of additional area round the icon bounding box used for detecting symbol collisions. Values are declared using CSS margin shorthand syntax: a single value applies to all four sides; two values apply to [top/bottom, left/right]; three values apply to [top, left/right, bottom]; four values apply to [top, right, bottom, left]. For backwards compatibility, a single bare number is accepted, and treated the same as a one-element array - padding applied to all sides.",
       "requires": [
         "icon-image"
       ],
@@ -1480,15 +1479,19 @@
           "android": "2.0.1",
           "ios": "2.0.0",
           "macos": "0.1.0"
+        },
+        "data-driven styling": {
+          "js": "2.2.0"
         }
       },
       "expression": {
         "interpolated": true,
         "parameters": [
-          "zoom"
+          "zoom",
+          "feature"
         ]
       },
-      "property-type": "data-constant"
+      "property-type": "data-driven"
     },
     "icon-keep-upright": {
       "type": "boolean",

package/src/style-spec/style-spec.test.ts

@@ -67,7 +67,8 @@ function validSchema(k, v, obj, ref, version, kind) {
         'property-type',
         'formatted',
         'resolvedImage',
-        'promoteId'
+        'promoteId',
+        'padding'
     ]);
     const keys = [
         'default',