@scoova/mgl 1.0.0

package/src/style/style_layer/line_style_layer.test.ts

@@ -0,0 +1,50 @@
+import {createStyleLayer} from '../create_style_layer';
+import {extend} from '../../util/util';
+import {LineStyleLayer} from './line_style_layer';
+
+describe('LineStyleLayer', () => {
+    function createLineLayer(layer?) {
+        return extend({
+            type: 'line',
+            source: 'line',
+            id: 'line',
+            paint: {
+                'line-color': 'red',
+                'line-width': 14,
+                'line-gradient': [
+                    'interpolate',
+                    ['linear'],
+                    ['line-progress'],
+                    0,
+                    'blue',
+                    1,
+                    'red'
+                ]
+            }
+        }, layer);
+    }
+
+    test('updating with valid line-gradient updates this.gradientVersion', () => {
+        const lineLayer = createStyleLayer(createLineLayer()) as LineStyleLayer;
+        const gradientVersion = lineLayer.gradientVersion;
+
+        lineLayer.setPaintProperty('line-gradient', [
+            'interpolate',
+            ['linear'],
+            ['line-progress'],
+            0,
+            'red',
+            1,
+            'blue'
+        ]);
+        expect(lineLayer.gradientVersion).toBeGreaterThan(gradientVersion);
+    });
+
+    test('updating with invalid line-gradient updates this.gradientVersion', () => {
+        const lineLayer = createStyleLayer(createLineLayer()) as LineStyleLayer;
+        const gradientVersion = lineLayer.gradientVersion;
+
+        lineLayer.setPaintProperty('line-gradient', null);
+        expect(lineLayer.gradientVersion).toBeGreaterThan(gradientVersion);
+    });
+});

package/src/style/style_layer/line_style_layer.ts

@@ -0,0 +1,131 @@
+import Point from '@mapbox/point-geometry';
+
+import {StyleLayer} from '../style_layer';
+import {LineBucket} from '../../data/bucket/line_bucket';
+import {polygonIntersectsBufferedMultiLine} from '../../util/intersection_tests';
+import {getMaximumPaintValue, translateDistance, translate, offsetLine} from '../query_utils';
+import properties, {LineLayoutPropsPossiblyEvaluated, LinePaintPropsPossiblyEvaluated} from './line_style_layer_properties.g';
+import {extend} from '../../util/util';
+import {EvaluationParameters} from '../evaluation_parameters';
+import {Transitionable, Transitioning, Layout, PossiblyEvaluated, DataDrivenProperty} from '../properties';
+
+import {isZoomExpression, Step} from '@maplibre/maplibre-gl-style-spec';
+import type {FeatureState, LayerSpecification} from '@maplibre/maplibre-gl-style-spec';
+import type {Bucket, BucketParameters} from '../../data/bucket';
+import type {LineLayoutProps, LinePaintProps} from './line_style_layer_properties.g';
+import type {Transform} from '../../geo/transform';
+import type {VectorTileFeature} from '@mapbox/vector-tile';
+
+export class LineFloorwidthProperty extends DataDrivenProperty<number> {
+    useIntegerZoom: true;
+
+    possiblyEvaluate(value, parameters) {
+        parameters = new EvaluationParameters(Math.floor(parameters.zoom), {
+            now: parameters.now,
+            fadeDuration: parameters.fadeDuration,
+            zoomHistory: parameters.zoomHistory,
+            transition: parameters.transition
+        });
+        return super.possiblyEvaluate(value, parameters);
+    }
+
+    evaluate(value, globals, feature, featureState) {
+        globals = extend({}, globals, {zoom: Math.floor(globals.zoom)});
+        return super.evaluate(value, globals, feature, featureState);
+    }
+}
+
+let lineFloorwidthProperty: LineFloorwidthProperty;
+
+export class LineStyleLayer extends StyleLayer {
+    _unevaluatedLayout: Layout<LineLayoutProps>;
+    layout: PossiblyEvaluated<LineLayoutProps, LineLayoutPropsPossiblyEvaluated>;
+
+    gradientVersion: number;
+    stepInterpolant: boolean;
+
+    _transitionablePaint: Transitionable<LinePaintProps>;
+    _transitioningPaint: Transitioning<LinePaintProps>;
+    paint: PossiblyEvaluated<LinePaintProps, LinePaintPropsPossiblyEvaluated>;
+
+    constructor(layer: LayerSpecification) {
+        super(layer, properties);
+        this.gradientVersion = 0;
+        if (!lineFloorwidthProperty) {
+            lineFloorwidthProperty =
+                new LineFloorwidthProperty(properties.paint.properties['line-width'].specification);
+            lineFloorwidthProperty.useIntegerZoom = true;
+        }
+    }
+
+    _handleSpecialPaintPropertyUpdate(name: string) {
+        if (name === 'line-gradient') {
+            const expression = this.gradientExpression();
+            if (isZoomExpression(expression)) {
+                this.stepInterpolant = expression._styleExpression.expression instanceof Step;
+            } else {
+                this.stepInterpolant = false;
+            }
+            this.gradientVersion = (this.gradientVersion + 1) % Number.MAX_SAFE_INTEGER;
+        }
+    }
+
+    gradientExpression() {
+        return this._transitionablePaint._values['line-gradient'].value.expression;
+    }
+
+    recalculate(parameters: EvaluationParameters, availableImages: Array<string>) {
+        super.recalculate(parameters, availableImages);
+        (this.paint._values as any)['line-floorwidth'] =
+            lineFloorwidthProperty.possiblyEvaluate(this._transitioningPaint._values['line-width'].value, parameters);
+    }
+
+    createBucket(parameters: BucketParameters<any>) {
+        return new LineBucket(parameters);
+    }
+
+    queryRadius(bucket: Bucket): number {
+        const lineBucket: LineBucket = (bucket as any);
+        const width = getLineWidth(
+            getMaximumPaintValue('line-width', this, lineBucket),
+            getMaximumPaintValue('line-gap-width', this, lineBucket));
+        const offset = getMaximumPaintValue('line-offset', this, lineBucket);
+        return width / 2 + Math.abs(offset) + translateDistance(this.paint.get('line-translate'));
+    }
+
+    queryIntersectsFeature(
+        queryGeometry: Array<Point>,
+        feature: VectorTileFeature,
+        featureState: FeatureState,
+        geometry: Array<Array<Point>>,
+        zoom: number,
+        transform: Transform,
+        pixelsToTileUnits: number
+    ): boolean {
+        const translatedPolygon = translate(queryGeometry,
+            this.paint.get('line-translate'),
+            this.paint.get('line-translate-anchor'),
+            transform.angle, pixelsToTileUnits);
+        const halfWidth = pixelsToTileUnits / 2 * getLineWidth(
+            this.paint.get('line-width').evaluate(feature, featureState),
+            this.paint.get('line-gap-width').evaluate(feature, featureState));
+        const lineOffset = this.paint.get('line-offset').evaluate(feature, featureState);
+        if (lineOffset) {
+            geometry = offsetLine(geometry, lineOffset * pixelsToTileUnits);
+        }
+
+        return polygonIntersectsBufferedMultiLine(translatedPolygon, geometry, halfWidth);
+    }
+
+    isTileClipped() {
+        return true;
+    }
+}
+
+function getLineWidth(lineWidth, lineGapWidth) {
+    if (lineGapWidth > 0) {
+        return lineGapWidth + 2 * lineWidth;
+    } else {
+        return lineWidth;
+    }
+}

package/src/style/style_layer/line_style_layer_properties.g.ts

@@ -0,0 +1,88 @@
+// This file is generated. Edit build/generate-style-code.ts, then run 'npm run codegen'.
+/* eslint-disable */
+
+import {latest as styleSpec} from '@maplibre/maplibre-gl-style-spec';
+
+import {
+    Properties,
+    DataConstantProperty,
+    DataDrivenProperty,
+    CrossFadedDataDrivenProperty,
+    CrossFadedProperty,
+    ColorRampProperty,
+    PossiblyEvaluatedPropertyValue,
+    CrossFaded
+} from '../properties';
+
+import type {Color, Formatted, Padding, ResolvedImage, VariableAnchorOffsetCollection} from '@maplibre/maplibre-gl-style-spec';
+import {StylePropertySpecification} from '@maplibre/maplibre-gl-style-spec';
+
+export type LineLayoutProps = {
+    "line-cap": DataConstantProperty<"butt" | "round" | "square">,
+    "line-join": DataDrivenProperty<"bevel" | "round" | "miter">,
+    "line-miter-limit": DataConstantProperty<number>,
+    "line-round-limit": DataConstantProperty<number>,
+    "line-sort-key": DataDrivenProperty<number>,
+};
+
+export type LineLayoutPropsPossiblyEvaluated = {
+    "line-cap": "butt" | "round" | "square",
+    "line-join": PossiblyEvaluatedPropertyValue<"bevel" | "round" | "miter">,
+    "line-miter-limit": number,
+    "line-round-limit": number,
+    "line-sort-key": PossiblyEvaluatedPropertyValue<number>,
+};
+
+let layout: Properties<LineLayoutProps>;
+const getLayout = () => layout = layout || new Properties({
+    "line-cap": new DataConstantProperty(styleSpec["layout_line"]["line-cap"] as any as StylePropertySpecification),
+    "line-join": new DataDrivenProperty(styleSpec["layout_line"]["line-join"] as any as StylePropertySpecification),
+    "line-miter-limit": new DataConstantProperty(styleSpec["layout_line"]["line-miter-limit"] as any as StylePropertySpecification),
+    "line-round-limit": new DataConstantProperty(styleSpec["layout_line"]["line-round-limit"] as any as StylePropertySpecification),
+    "line-sort-key": new DataDrivenProperty(styleSpec["layout_line"]["line-sort-key"] as any as StylePropertySpecification),
+});
+
+export type LinePaintProps = {
+    "line-opacity": DataDrivenProperty<number>,
+    "line-color": DataDrivenProperty<Color>,
+    "line-translate": DataConstantProperty<[number, number]>,
+    "line-translate-anchor": DataConstantProperty<"map" | "viewport">,
+    "line-width": DataDrivenProperty<number>,
+    "line-gap-width": DataDrivenProperty<number>,
+    "line-offset": DataDrivenProperty<number>,
+    "line-blur": DataDrivenProperty<number>,
+    "line-dasharray": CrossFadedProperty<Array<number>>,
+    "line-pattern": CrossFadedDataDrivenProperty<ResolvedImage>,
+    "line-gradient": ColorRampProperty,
+};
+
+export type LinePaintPropsPossiblyEvaluated = {
+    "line-opacity": PossiblyEvaluatedPropertyValue<number>,
+    "line-color": PossiblyEvaluatedPropertyValue<Color>,
+    "line-translate": [number, number],
+    "line-translate-anchor": "map" | "viewport",
+    "line-width": PossiblyEvaluatedPropertyValue<number>,
+    "line-gap-width": PossiblyEvaluatedPropertyValue<number>,
+    "line-offset": PossiblyEvaluatedPropertyValue<number>,
+    "line-blur": PossiblyEvaluatedPropertyValue<number>,
+    "line-dasharray": CrossFaded<Array<number>>,
+    "line-pattern": PossiblyEvaluatedPropertyValue<CrossFaded<ResolvedImage>>,
+    "line-gradient": ColorRampProperty,
+};
+
+let paint: Properties<LinePaintProps>;
+const getPaint = () => paint = paint || new Properties({
+    "line-opacity": new DataDrivenProperty(styleSpec["paint_line"]["line-opacity"] as any as StylePropertySpecification),
+    "line-color": new DataDrivenProperty(styleSpec["paint_line"]["line-color"] as any as StylePropertySpecification),
+    "line-translate": new DataConstantProperty(styleSpec["paint_line"]["line-translate"] as any as StylePropertySpecification),
+    "line-translate-anchor": new DataConstantProperty(styleSpec["paint_line"]["line-translate-anchor"] as any as StylePropertySpecification),
+    "line-width": new DataDrivenProperty(styleSpec["paint_line"]["line-width"] as any as StylePropertySpecification),
+    "line-gap-width": new DataDrivenProperty(styleSpec["paint_line"]["line-gap-width"] as any as StylePropertySpecification),
+    "line-offset": new DataDrivenProperty(styleSpec["paint_line"]["line-offset"] as any as StylePropertySpecification),
+    "line-blur": new DataDrivenProperty(styleSpec["paint_line"]["line-blur"] as any as StylePropertySpecification),
+    "line-dasharray": new CrossFadedProperty(styleSpec["paint_line"]["line-dasharray"] as any as StylePropertySpecification),
+    "line-pattern": new CrossFadedDataDrivenProperty(styleSpec["paint_line"]["line-pattern"] as any as StylePropertySpecification),
+    "line-gradient": new ColorRampProperty(styleSpec["paint_line"]["line-gradient"] as any as StylePropertySpecification),
+});
+
+export default ({ get paint() { return getPaint() }, get layout() { return getLayout() } });

package/src/style/style_layer/overlap_mode.test.ts

@@ -0,0 +1,57 @@
+import {getOverlapMode} from './overlap_mode';
+import {SymbolStyleLayer} from './symbol_style_layer';
+import {ZoomHistory} from '../zoom_history';
+import {EvaluationParameters} from '../evaluation_parameters';
+
+function createSymbolLayer(layerProperties) {
+    const layer = new SymbolStyleLayer(layerProperties);
+    layer.recalculate({zoom: 0, zoomHistory: {} as ZoomHistory} as EvaluationParameters, []);
+    return layer;
+}
+
+describe('getOverlapMode', () => {
+    test('defaults - no props set', () => {
+        const props = {};
+        const layer = createSymbolLayer(props);
+
+        expect(getOverlapMode(layer.layout, 'icon-overlap', 'icon-allow-overlap')).toBe('never');
+        expect(getOverlapMode(layer.layout, 'text-overlap', 'text-allow-overlap')).toBe('never');
+    });
+
+    test('-allow-overlap set', () => {
+        const props = {layout: {'icon-allow-overlap': false, 'text-allow-overlap': true}};
+        const layer = createSymbolLayer(props);
+
+        expect(getOverlapMode(layer.layout, 'icon-overlap', 'icon-allow-overlap')).toBe('never');
+        expect(getOverlapMode(layer.layout, 'text-overlap', 'text-allow-overlap')).toBe('always');
+    });
+
+    test('-overlap set', () => {
+        let props = {layout: {'icon-overlap': 'never', 'text-overlap': 'always'}};
+        let layer = createSymbolLayer(props);
+
+        expect(getOverlapMode(layer.layout, 'icon-overlap', 'icon-allow-overlap')).toBe('never');
+        expect(getOverlapMode(layer.layout, 'text-overlap', 'text-allow-overlap')).toBe('always');
+
+        props = {layout: {'icon-overlap': 'always', 'text-overlap': 'cooperative'}};
+        layer = createSymbolLayer(props);
+
+        expect(getOverlapMode(layer.layout, 'icon-overlap', 'icon-allow-overlap')).toBe('always');
+        expect(getOverlapMode(layer.layout, 'text-overlap', 'text-allow-overlap')).toBe('cooperative');
+    });
+
+    test('-overlap beats -allow-overlap', () => {
+        const props = {
+            layout: {
+                'icon-overlap': 'never',
+                'icon-allow-overlap': true,
+                'text-overlap': 'cooperative',
+                'text-allow-overlap': false
+            }
+        };
+        const layer = createSymbolLayer(props);
+
+        expect(getOverlapMode(layer.layout, 'icon-overlap', 'icon-allow-overlap')).toBe('never');
+        expect(getOverlapMode(layer.layout, 'text-overlap', 'text-allow-overlap')).toBe('cooperative');
+    });
+});

package/src/style/style_layer/overlap_mode.ts

@@ -0,0 +1,25 @@
+import {SymbolLayoutPropsPossiblyEvaluated} from './symbol_style_layer_properties.g';
+import type {SymbolLayoutProps} from './symbol_style_layer_properties.g';
+import {PossiblyEvaluated} from '../properties';
+
+/**
+ * The overlap mode for properties like `icon-overlap`and `text-overlap`
+ */
+export type OverlapMode = 'never' | 'always' | 'cooperative';
+
+export function getOverlapMode(layout: PossiblyEvaluated<SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated>, overlapProp: 'icon-overlap', allowOverlapProp: 'icon-allow-overlap'): OverlapMode;
+export function getOverlapMode(layout: PossiblyEvaluated<SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated>, overlapProp: 'text-overlap', allowOverlapProp: 'text-allow-overlap'): OverlapMode;
+export function getOverlapMode(layout: PossiblyEvaluated<SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated>, overlapProp: 'icon-overlap' | 'text-overlap', allowOverlapProp: 'icon-allow-overlap' | 'text-allow-overlap'): OverlapMode {
+    let result: OverlapMode = 'never';
+    const overlap = layout.get(overlapProp);
+
+    if (overlap) {
+        // if -overlap is set, use it
+        result = overlap;
+    } else if (layout.get(allowOverlapProp)) {
+        // fall back to -allow-overlap, with false='never', true='always'
+        result = 'always';
+    }
+
+    return result;
+}

package/src/style/style_layer/raster_style_layer.ts

@@ -0,0 +1,17 @@
+import {StyleLayer} from '../style_layer';
+
+import properties, {RasterPaintPropsPossiblyEvaluated} from './raster_style_layer_properties.g';
+import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
+
+import type {RasterPaintProps} from './raster_style_layer_properties.g';
+import type {LayerSpecification} from '@maplibre/maplibre-gl-style-spec';
+
+export class RasterStyleLayer extends StyleLayer {
+    _transitionablePaint: Transitionable<RasterPaintProps>;
+    _transitioningPaint: Transitioning<RasterPaintProps>;
+    paint: PossiblyEvaluated<RasterPaintProps, RasterPaintPropsPossiblyEvaluated>;
+
+    constructor(layer: LayerSpecification) {
+        super(layer, properties);
+    }
+}

package/src/style/style_layer/raster_style_layer_properties.g.ts

@@ -0,0 +1,55 @@
+// This file is generated. Edit build/generate-style-code.ts, then run 'npm run codegen'.
+/* eslint-disable */
+
+import {latest as styleSpec} from '@maplibre/maplibre-gl-style-spec';
+
+import {
+    Properties,
+    DataConstantProperty,
+    DataDrivenProperty,
+    CrossFadedDataDrivenProperty,
+    CrossFadedProperty,
+    ColorRampProperty,
+    PossiblyEvaluatedPropertyValue,
+    CrossFaded
+} from '../properties';
+
+import type {Color, Formatted, Padding, ResolvedImage, VariableAnchorOffsetCollection} from '@maplibre/maplibre-gl-style-spec';
+import {StylePropertySpecification} from '@maplibre/maplibre-gl-style-spec';
+
+
+export type RasterPaintProps = {
+    "raster-opacity": DataConstantProperty<number>,
+    "raster-hue-rotate": DataConstantProperty<number>,
+    "raster-brightness-min": DataConstantProperty<number>,
+    "raster-brightness-max": DataConstantProperty<number>,
+    "raster-saturation": DataConstantProperty<number>,
+    "raster-contrast": DataConstantProperty<number>,
+    "raster-resampling": DataConstantProperty<"linear" | "nearest">,
+    "raster-fade-duration": DataConstantProperty<number>,
+};
+
+export type RasterPaintPropsPossiblyEvaluated = {
+    "raster-opacity": number,
+    "raster-hue-rotate": number,
+    "raster-brightness-min": number,
+    "raster-brightness-max": number,
+    "raster-saturation": number,
+    "raster-contrast": number,
+    "raster-resampling": "linear" | "nearest",
+    "raster-fade-duration": number,
+};
+
+let paint: Properties<RasterPaintProps>;
+const getPaint = () => paint = paint || new Properties({
+    "raster-opacity": new DataConstantProperty(styleSpec["paint_raster"]["raster-opacity"] as any as StylePropertySpecification),
+    "raster-hue-rotate": new DataConstantProperty(styleSpec["paint_raster"]["raster-hue-rotate"] as any as StylePropertySpecification),
+    "raster-brightness-min": new DataConstantProperty(styleSpec["paint_raster"]["raster-brightness-min"] as any as StylePropertySpecification),
+    "raster-brightness-max": new DataConstantProperty(styleSpec["paint_raster"]["raster-brightness-max"] as any as StylePropertySpecification),
+    "raster-saturation": new DataConstantProperty(styleSpec["paint_raster"]["raster-saturation"] as any as StylePropertySpecification),
+    "raster-contrast": new DataConstantProperty(styleSpec["paint_raster"]["raster-contrast"] as any as StylePropertySpecification),
+    "raster-resampling": new DataConstantProperty(styleSpec["paint_raster"]["raster-resampling"] as any as StylePropertySpecification),
+    "raster-fade-duration": new DataConstantProperty(styleSpec["paint_raster"]["raster-fade-duration"] as any as StylePropertySpecification),
+});
+
+export default ({ get paint() { return getPaint() } });

package/src/style/style_layer/symbol_style_layer.ts

@@ -0,0 +1,195 @@
+import {StyleLayer} from '../style_layer';
+
+import {SymbolBucket, SymbolFeature} from '../../data/bucket/symbol_bucket';
+import {resolveTokens} from '../../util/resolve_tokens';
+import properties, {SymbolLayoutPropsPossiblyEvaluated, SymbolPaintPropsPossiblyEvaluated} from './symbol_style_layer_properties.g';
+
+import {
+    Transitionable,
+    Transitioning,
+    Layout,
+    PossiblyEvaluated,
+    PossiblyEvaluatedPropertyValue,
+    PropertyValue
+} from '../properties';
+
+import {
+    isExpression,
+    StyleExpression,
+    ZoomConstantExpression,
+    ZoomDependentExpression,
+    FormattedType,
+    typeOf,
+    Formatted,
+    FormatExpression,
+    Literal} from '@maplibre/maplibre-gl-style-spec';
+
+import type {BucketParameters} from '../../data/bucket';
+import type {SymbolLayoutProps, SymbolPaintProps} from './symbol_style_layer_properties.g';
+import type {EvaluationParameters} from '../evaluation_parameters';
+import type {Expression, Feature, SourceExpression, LayerSpecification} from '@maplibre/maplibre-gl-style-spec';
+import type {CanonicalTileID} from '../../source/tile_id';
+import {FormatSectionOverride} from '../format_section_override';
+
+export class SymbolStyleLayer extends StyleLayer {
+    _unevaluatedLayout: Layout<SymbolLayoutProps>;
+    layout: PossiblyEvaluated<SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated>;
+
+    _transitionablePaint: Transitionable<SymbolPaintProps>;
+    _transitioningPaint: Transitioning<SymbolPaintProps>;
+    paint: PossiblyEvaluated<SymbolPaintProps, SymbolPaintPropsPossiblyEvaluated>;
+
+    constructor(layer: LayerSpecification) {
+        super(layer, properties);
+    }
+
+    recalculate(parameters: EvaluationParameters, availableImages: Array<string>) {
+        super.recalculate(parameters, availableImages);
+
+        if (this.layout.get('icon-rotation-alignment') === 'auto') {
+            if (this.layout.get('symbol-placement') !== 'point') {
+                this.layout._values['icon-rotation-alignment'] = 'map';
+            } else {
+                this.layout._values['icon-rotation-alignment'] = 'viewport';
+            }
+        }
+
+        if (this.layout.get('text-rotation-alignment') === 'auto') {
+            if (this.layout.get('symbol-placement') !== 'point') {
+                this.layout._values['text-rotation-alignment'] = 'map';
+            } else {
+                this.layout._values['text-rotation-alignment'] = 'viewport';
+            }
+        }
+
+        // If unspecified, `*-pitch-alignment` inherits `*-rotation-alignment`
+        if (this.layout.get('text-pitch-alignment') === 'auto') {
+            this.layout._values['text-pitch-alignment'] = this.layout.get('text-rotation-alignment') === 'map' ? 'map' : 'viewport';
+        }
+        if (this.layout.get('icon-pitch-alignment') === 'auto') {
+            this.layout._values['icon-pitch-alignment'] = this.layout.get('icon-rotation-alignment');
+        }
+
+        if (this.layout.get('symbol-placement') === 'point') {
+            const writingModes = this.layout.get('text-writing-mode');
+            if (writingModes) {
+                // remove duplicates, preserving order
+                const deduped = [];
+                for (const m of writingModes) {
+                    if (deduped.indexOf(m) < 0) deduped.push(m);
+                }
+                this.layout._values['text-writing-mode'] = deduped;
+            } else {
+                this.layout._values['text-writing-mode'] = ['horizontal'];
+            }
+        }
+
+        this._setPaintOverrides();
+    }
+
+    getValueAndResolveTokens(name: any, feature: Feature, canonical: CanonicalTileID, availableImages: Array<string>) {
+        const value = this.layout.get(name).evaluate(feature, {}, canonical, availableImages);
+        const unevaluated = this._unevaluatedLayout._values[name];
+        if (!unevaluated.isDataDriven() && !isExpression(unevaluated.value) && value) {
+            return resolveTokens(feature.properties, value);
+        }
+
+        return value;
+    }
+
+    createBucket(parameters: BucketParameters<any>) {
+        return new SymbolBucket(parameters);
+    }
+
+    queryRadius(): number {
+        return 0;
+    }
+
+    queryIntersectsFeature(): boolean {
+        throw new Error('Should take a different path in FeatureIndex');
+    }
+
+    _setPaintOverrides() {
+        for (const overridable of properties.paint.overridableProperties) {
+            if (!SymbolStyleLayer.hasPaintOverride(this.layout, overridable)) {
+                continue;
+            }
+            const overridden = this.paint.get(overridable as keyof SymbolPaintPropsPossiblyEvaluated) as PossiblyEvaluatedPropertyValue<number>;
+            const override = new FormatSectionOverride(overridden);
+            const styleExpression = new StyleExpression(override, overridden.property.specification);
+            let expression = null;
+            if (overridden.value.kind === 'constant' || overridden.value.kind === 'source') {
+                expression = new ZoomConstantExpression('source', styleExpression) as SourceExpression;
+            } else {
+                expression = new ZoomDependentExpression('composite',
+                    styleExpression,
+                    overridden.value.zoomStops);
+            }
+            this.paint._values[overridable] = new PossiblyEvaluatedPropertyValue(overridden.property,
+                expression,
+                overridden.parameters);
+        }
+    }
+
+    _handleOverridablePaintPropertyUpdate<T, R>(name: string, oldValue: PropertyValue<T, R>, newValue: PropertyValue<T, R>): boolean {
+        if (!this.layout || oldValue.isDataDriven() || newValue.isDataDriven()) {
+            return false;
+        }
+        return SymbolStyleLayer.hasPaintOverride(this.layout, name);
+    }
+
+    static hasPaintOverride(layout: PossiblyEvaluated<SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated>, propertyName: string): boolean {
+        const textField = layout.get('text-field');
+        const property = properties.paint.properties[propertyName];
+        let hasOverrides = false;
+
+        const checkSections = (sections) => {
+            for (const section of sections) {
+                if (property.overrides && property.overrides.hasOverride(section)) {
+                    hasOverrides = true;
+                    return;
+                }
+            }
+        };
+
+        if (textField.value.kind === 'constant' && textField.value.value instanceof Formatted) {
+            checkSections(textField.value.value.sections);
+        } else if (textField.value.kind === 'source') {
+
+            const checkExpression = (expression: Expression) => {
+                if (hasOverrides) return;
+
+                if (expression instanceof Literal && typeOf(expression.value) === FormattedType) {
+                    const formatted: Formatted = (expression.value as any);
+                    checkSections(formatted.sections);
+                } else if (expression instanceof FormatExpression) {
+                    checkSections(expression.sections);
+                } else {
+                    expression.eachChild(checkExpression);
+                }
+            };
+
+            const expr: ZoomConstantExpression<'source'> = (textField.value as any);
+            if (expr._styleExpression) {
+                checkExpression(expr._styleExpression.expression);
+            }
+        }
+
+        return hasOverrides;
+    }
+}
+
+export type SymbolPadding = [number, number, number, number];
+
+export function getIconPadding(layout: PossiblyEvaluated<SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated>, feature: SymbolFeature, canonical: CanonicalTileID, pixelRatio = 1): SymbolPadding {
+    // Support text-padding in addition to icon-padding? Unclear how to apply asymmetric text-padding to the radius for collision circles.
+    const result = layout.get('icon-padding').evaluate(feature, {}, canonical);
+    const values = result && result.values;
+
+    return [
+        values[0] * pixelRatio,
+        values[1] * pixelRatio,
+        values[2] * pixelRatio,
+        values[3] * pixelRatio,
+    ];
+}