@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/style/style_layer/fill_extrusion_style_layer.js

@@ -1,224 +0,0 @@
-// @flow
-
-import StyleLayer from '../style_layer';
-
-import FillExtrusionBucket from '../../data/bucket/fill_extrusion_bucket';
-import {polygonIntersectsPolygon, polygonIntersectsMultiPolygon} from '../../util/intersection_tests';
-import {translateDistance, translate} from '../query_utils';
-import properties from './fill_extrusion_style_layer_properties';
-import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
-import {vec4} from 'gl-matrix';
-import Point from '@mapbox/point-geometry';
-
-import type {FeatureState} from '../../style-spec/expression';
-import type {BucketParameters} from '../../data/bucket';
-import type {PaintProps} from './fill_extrusion_style_layer_properties';
-import type Transform from '../../geo/transform';
-import type {LayerSpecification} from '../../style-spec/types';
-
-class FillExtrusionStyleLayer extends StyleLayer {
-    _transitionablePaint: Transitionable<PaintProps>;
-    _transitioningPaint: Transitioning<PaintProps>;
-    paint: PossiblyEvaluated<PaintProps>;
-
-    constructor(layer: LayerSpecification) {
-        super(layer, properties);
-    }
-
-    createBucket(parameters: BucketParameters<FillExtrusionStyleLayer>) {
-        return new FillExtrusionBucket(parameters);
-    }
-
-    queryRadius(): number {
-        return translateDistance(this.paint.get('fill-extrusion-translate'));
-    }
-
-    is3D(): boolean {
-        return true;
-    }
-
-    queryIntersectsFeature(queryGeometry: Array<Point>,
-                           feature: VectorTileFeature,
-                           featureState: FeatureState,
-                           geometry: Array<Array<Point>>,
-                           zoom: number,
-                           transform: Transform,
-                           pixelsToTileUnits: number,
-                           pixelPosMatrix: Float32Array): boolean | number {
-
-        const translatedPolygon = translate(queryGeometry,
-            this.paint.get('fill-extrusion-translate'),
-            this.paint.get('fill-extrusion-translate-anchor'),
-            transform.angle, pixelsToTileUnits);
-
-        const height = this.paint.get('fill-extrusion-height').evaluate(feature, featureState);
-        const base = this.paint.get('fill-extrusion-base').evaluate(feature, featureState);
-
-        const projectedQueryGeometry = projectQueryGeometry(translatedPolygon, pixelPosMatrix, transform, 0);
-
-        const projected = projectExtrusion(geometry, base, height, pixelPosMatrix);
-        const projectedBase = projected[0];
-        const projectedTop = projected[1];
-        return checkIntersection(projectedBase, projectedTop, projectedQueryGeometry);
-    }
-}
-
-function dot(a, b) {
-    return a.x * b.x + a.y * b.y;
-}
-
-export function getIntersectionDistance(projectedQueryGeometry: Array<Point>, projectedFace: Array<Point>) {
-
-    if (projectedQueryGeometry.length === 1) {
-        // For point queries calculate the z at which the point intersects the face
-        // using barycentric coordinates.
-
-        // Find the barycentric coordinates of the projected point within the first
-        // triangle of the face, using only the xy plane. It doesn't matter if the
-        // point is outside the first triangle because all the triangles in the face
-        // are in the same plane.
-        //
-        // Check whether points are coincident and use other points if they are.
-        let i = 0;
-        const a = projectedFace[i++];
-        let b;
-        while (!b || a.equals(b)) {
-            b = projectedFace[i++];
-            if (!b) return Infinity;
-        }
-
-        // Loop until point `c` is not colinear with points `a` and `b`.
-        for (; i < projectedFace.length; i++) {
-            const c = projectedFace[i];
-
-            const p = projectedQueryGeometry[0];
-
-            const ab = b.sub(a);
-            const ac = c.sub(a);
-            const ap = p.sub(a);
-
-            const dotABAB = dot(ab, ab);
-            const dotABAC = dot(ab, ac);
-            const dotACAC = dot(ac, ac);
-            const dotAPAB = dot(ap, ab);
-            const dotAPAC = dot(ap, ac);
-            const denom = dotABAB * dotACAC - dotABAC * dotABAC;
-
-            const v = (dotACAC * dotAPAB - dotABAC * dotAPAC) / denom;
-            const w = (dotABAB * dotAPAC - dotABAC * dotAPAB) / denom;
-            const u = 1 - v - w;
-
-            // Use the barycentric weighting along with the original triangle z coordinates to get the point of intersection.
-            const distance = a.z * u + b.z * v + c.z * w;
-
-            if (isFinite(distance)) return distance;
-        }
-
-        return Infinity;
-
-    } else {
-        // The counts as closest is less clear when the query is a box. This
-        // returns the distance to the nearest point on the face, whether it is
-        // within the query or not. It could be more correct to return the
-        // distance to the closest point within the query box but this would be
-        // more complicated and expensive to calculate with little benefit.
-        let closestDistance = Infinity;
-        for (const p of projectedFace) {
-            closestDistance = Math.min(closestDistance, p.z);
-        }
-        return closestDistance;
-    }
-}
-
-function checkIntersection(projectedBase: Array<Point>, projectedTop: Array<Point>, projectedQueryGeometry: Array<Point>) {
-    let closestDistance = Infinity;
-
-    if (polygonIntersectsMultiPolygon(projectedQueryGeometry, projectedTop)) {
-        closestDistance = getIntersectionDistance(projectedQueryGeometry, projectedTop[0]);
-    }
-
-    for (let r = 0; r < projectedTop.length; r++) {
-        const ringTop = projectedTop[r];
-        const ringBase = projectedBase[r];
-        for (let p = 0; p < ringTop.length - 1; p++) {
-            const topA = ringTop[p];
-            const topB = ringTop[p + 1];
-            const baseA = ringBase[p];
-            const baseB = ringBase[p + 1];
-            const face = [topA, topB, baseB, baseA, topA];
-            if (polygonIntersectsPolygon(projectedQueryGeometry, face)) {
-                closestDistance = Math.min(closestDistance, getIntersectionDistance(projectedQueryGeometry, face));
-            }
-        }
-    }
-
-    return closestDistance === Infinity ? false : closestDistance;
-}
-
-/*
- * Project the geometry using matrix `m`. This is essentially doing
- * `vec4.transformMat4([], [p.x, p.y, z, 1], m)` but the multiplication
- * is inlined so that parts of the projection that are the same across
- * different points can only be done once. This produced a measurable
- * performance improvement.
- */
-function projectExtrusion(geometry: Array<Array<Point>>, zBase: number, zTop: number, m: Float32Array) {
-    const projectedBase = [];
-    const projectedTop = [];
-
-    const baseXZ = m[8] * zBase;
-    const baseYZ = m[9] * zBase;
-    const baseZZ = m[10] * zBase;
-    const baseWZ = m[11] * zBase;
-    const topXZ = m[8] * zTop;
-    const topYZ = m[9] * zTop;
-    const topZZ = m[10] * zTop;
-    const topWZ = m[11] * zTop;
-
-    for (const r of geometry) {
-        const ringBase = [];
-        const ringTop = [];
-        for (const p of r) {
-            const x = p.x;
-            const y = p.y;
-
-            const sX = m[0] * x + m[4] * y + m[12];
-            const sY = m[1] * x + m[5] * y + m[13];
-            const sZ = m[2] * x + m[6] * y + m[14];
-            const sW = m[3] * x + m[7] * y + m[15];
-
-            const baseX = sX + baseXZ;
-            const baseY = sY + baseYZ;
-            const baseZ = sZ + baseZZ;
-            const baseW = sW + baseWZ;
-
-            const topX = sX + topXZ;
-            const topY = sY + topYZ;
-            const topZ = sZ + topZZ;
-            const topW = sW + topWZ;
-
-            const b = new Point(baseX / baseW, baseY / baseW);
-            b.z = baseZ / baseW;
-            ringBase.push(b);
-
-            const t = new Point(topX / topW, topY / topW);
-            t.z = topZ / topW;
-            ringTop.push(t);
-        }
-        projectedBase.push(ringBase);
-        projectedTop.push(ringTop);
-    }
-    return [projectedBase, projectedTop];
-}
-
-function projectQueryGeometry(queryGeometry: Array<Point>, pixelPosMatrix: Float32Array, transform: Transform, z: number) {
-    const projectedQueryGeometry = [];
-    for (const p of queryGeometry) {
-        const v = [p.x, p.y, z, 1];
-        vec4.transformMat4(v, v, pixelPosMatrix);
-        projectedQueryGeometry.push(new Point(v[0] / v[3], v[1] / v[3]));
-    }
-    return projectedQueryGeometry;
-}
-
-export default FillExtrusionStyleLayer;

package/src/style/style_layer/fill_extrusion_style_layer_properties.js

@@ -1,50 +0,0 @@
-// This file is generated. Edit build/generate-style-code.js, then run `yarn run codegen`.
-// @flow
-/* eslint-disable */
-
-import styleSpec from '../../style-spec/reference/latest';
-
-import {
-    Properties,
-    DataConstantProperty,
-    DataDrivenProperty,
-    CrossFadedDataDrivenProperty,
-    CrossFadedProperty,
-    ColorRampProperty
-} from '../properties';
-
-import type Color from '../../style-spec/util/color';
-
-import type Formatted from '../../style-spec/expression/types/formatted';
-
-import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
-
-
-export type PaintProps = {|
-    "fill-extrusion-opacity": DataConstantProperty<number>,
-    "fill-extrusion-color": DataDrivenProperty<Color>,
-    "fill-extrusion-translate": DataConstantProperty<[number, number]>,
-    "fill-extrusion-translate-anchor": DataConstantProperty<"map" | "viewport">,
-    "fill-extrusion-pattern": CrossFadedDataDrivenProperty<ResolvedImage>,
-    "fill-extrusion-height": DataDrivenProperty<number>,
-    "fill-extrusion-base": DataDrivenProperty<number>,
-    "fill-extrusion-vertical-gradient": DataConstantProperty<boolean>,
-|};
-
-const paint: Properties<PaintProps> = new Properties({
-    "fill-extrusion-opacity": new DataConstantProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-opacity"]),
-    "fill-extrusion-color": new DataDrivenProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-color"]),
-    "fill-extrusion-translate": new DataConstantProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-translate"]),
-    "fill-extrusion-translate-anchor": new DataConstantProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]),
-    "fill-extrusion-pattern": new CrossFadedDataDrivenProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-pattern"]),
-    "fill-extrusion-height": new DataDrivenProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-height"]),
-    "fill-extrusion-base": new DataDrivenProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-base"]),
-    "fill-extrusion-vertical-gradient": new DataConstantProperty(styleSpec["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]),
-});
-
-// Note: without adding the explicit type annotation, Flow infers weaker types
-// for these objects from their use in the constructor to StyleLayer, as
-// {layout?: Properties<...>, paint: Properties<...>}
-export default ({ paint }: $Exact<{
-  paint: Properties<PaintProps>
-}>);

package/src/style/style_layer/fill_style_layer.js

@@ -1,67 +0,0 @@
-// @flow
-
-import StyleLayer from '../style_layer';
-
-import FillBucket from '../../data/bucket/fill_bucket';
-import {polygonIntersectsMultiPolygon} from '../../util/intersection_tests';
-import {translateDistance, translate} from '../query_utils';
-import properties from './fill_style_layer_properties';
-import {Transitionable, Transitioning, Layout, PossiblyEvaluated} from '../properties';
-
-import type {FeatureState} from '../../style-spec/expression';
-import type {BucketParameters} from '../../data/bucket';
-import type Point from '@mapbox/point-geometry';
-import type {LayoutProps, PaintProps} from './fill_style_layer_properties';
-import type EvaluationParameters from '../evaluation_parameters';
-import type Transform from '../../geo/transform';
-import type {LayerSpecification} from '../../style-spec/types';
-
-class FillStyleLayer extends StyleLayer {
-    _unevaluatedLayout: Layout<LayoutProps>;
-    layout: PossiblyEvaluated<LayoutProps>;
-
-    _transitionablePaint: Transitionable<PaintProps>;
-    _transitioningPaint: Transitioning<PaintProps>;
-    paint: PossiblyEvaluated<PaintProps>;
-
-    constructor(layer: LayerSpecification) {
-        super(layer, properties);
-    }
-
-    recalculate(parameters: EvaluationParameters, availableImages: Array<string>) {
-        super.recalculate(parameters, availableImages);
-
-        const outlineColor = this.paint._values['fill-outline-color'];
-        if (outlineColor.value.kind === 'constant' && outlineColor.value.value === undefined) {
-            this.paint._values['fill-outline-color'] = this.paint._values['fill-color'];
-        }
-    }
-
-    createBucket(parameters: BucketParameters<*>) {
-        return new FillBucket(parameters);
-    }
-
-    queryRadius(): number {
-        return translateDistance(this.paint.get('fill-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('fill-translate'),
-            this.paint.get('fill-translate-anchor'),
-            transform.angle, pixelsToTileUnits);
-        return polygonIntersectsMultiPolygon(translatedPolygon, geometry);
-    }
-
-    isTileClipped() {
-        return true;
-    }
-}
-
-export default FillStyleLayer;

package/src/style/style_layer/fill_style_layer_properties.js

@@ -1,55 +0,0 @@
-// This file is generated. Edit build/generate-style-code.js, then run `yarn run codegen`.
-// @flow
-/* eslint-disable */
-
-import styleSpec from '../../style-spec/reference/latest';
-
-import {
-    Properties,
-    DataConstantProperty,
-    DataDrivenProperty,
-    CrossFadedDataDrivenProperty,
-    CrossFadedProperty,
-    ColorRampProperty
-} from '../properties';
-
-import type Color from '../../style-spec/util/color';
-
-import type Formatted from '../../style-spec/expression/types/formatted';
-
-import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
-
-export type LayoutProps = {|
-    "fill-sort-key": DataDrivenProperty<number>,
-|};
-
-const layout: Properties<LayoutProps> = new Properties({
-    "fill-sort-key": new DataDrivenProperty(styleSpec["layout_fill"]["fill-sort-key"]),
-});
-
-export type PaintProps = {|
-    "fill-antialias": DataConstantProperty<boolean>,
-    "fill-opacity": DataDrivenProperty<number>,
-    "fill-color": DataDrivenProperty<Color>,
-    "fill-outline-color": DataDrivenProperty<Color>,
-    "fill-translate": DataConstantProperty<[number, number]>,
-    "fill-translate-anchor": DataConstantProperty<"map" | "viewport">,
-    "fill-pattern": CrossFadedDataDrivenProperty<ResolvedImage>,
-|};
-
-const paint: Properties<PaintProps> = new Properties({
-    "fill-antialias": new DataConstantProperty(styleSpec["paint_fill"]["fill-antialias"]),
-    "fill-opacity": new DataDrivenProperty(styleSpec["paint_fill"]["fill-opacity"]),
-    "fill-color": new DataDrivenProperty(styleSpec["paint_fill"]["fill-color"]),
-    "fill-outline-color": new DataDrivenProperty(styleSpec["paint_fill"]["fill-outline-color"]),
-    "fill-translate": new DataConstantProperty(styleSpec["paint_fill"]["fill-translate"]),
-    "fill-translate-anchor": new DataConstantProperty(styleSpec["paint_fill"]["fill-translate-anchor"]),
-    "fill-pattern": new CrossFadedDataDrivenProperty(styleSpec["paint_fill"]["fill-pattern"]),
-});
-
-// Note: without adding the explicit type annotation, Flow infers weaker types
-// for these objects from their use in the constructor to StyleLayer, as
-// {layout?: Properties<...>, paint: Properties<...>}
-export default ({ paint, layout }: $Exact<{
-  paint: Properties<PaintProps>, layout: Properties<LayoutProps>
-}>);

package/src/style/style_layer/heatmap_style_layer.js

@@ -1,69 +0,0 @@
-// @flow
-
-import StyleLayer from '../style_layer';
-
-import HeatmapBucket from '../../data/bucket/heatmap_bucket';
-import {RGBAImage} from '../../util/image';
-import properties from './heatmap_style_layer_properties';
-import renderColorRamp from '../../util/color_ramp';
-import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
-
-import type Texture from '../../render/texture';
-import type Framebuffer from '../../gl/framebuffer';
-import type {PaintProps} from './heatmap_style_layer_properties';
-import type {LayerSpecification} from '../../style-spec/types';
-
-class HeatmapStyleLayer extends StyleLayer {
-
-    heatmapFbo: ?Framebuffer;
-    colorRamp: RGBAImage;
-    colorRampTexture: ?Texture;
-
-    _transitionablePaint: Transitionable<PaintProps>;
-    _transitioningPaint: Transitioning<PaintProps>;
-    paint: PossiblyEvaluated<PaintProps>;
-
-    createBucket(options: any) {
-        return new HeatmapBucket(options);
-    }
-
-    constructor(layer: LayerSpecification) {
-        super(layer, properties);
-
-        // make sure color ramp texture is generated for default heatmap color too
-        this._updateColorRamp();
-    }
-
-    _handleSpecialPaintPropertyUpdate(name: string) {
-        if (name === 'heatmap-color') {
-            this._updateColorRamp();
-        }
-    }
-
-    _updateColorRamp() {
-        const expression = this._transitionablePaint._values['heatmap-color'].value.expression;
-        this.colorRamp = renderColorRamp(expression, 'heatmapDensity');
-        this.colorRampTexture = null;
-    }
-
-    resize() {
-        if (this.heatmapFbo) {
-            this.heatmapFbo.destroy();
-            this.heatmapFbo = null;
-        }
-    }
-
-    queryRadius(): number {
-        return 0;
-    }
-
-    queryIntersectsFeature(): boolean  {
-        return false;
-    }
-
-    hasOffscreenPass() {
-        return this.paint.get('heatmap-opacity') !== 0 && this.visibility !== 'none';
-    }
-}
-
-export default HeatmapStyleLayer;

package/src/style/style_layer/heatmap_style_layer_properties.js

@@ -1,44 +0,0 @@
-// This file is generated. Edit build/generate-style-code.js, then run `yarn run codegen`.
-// @flow
-/* eslint-disable */
-
-import styleSpec from '../../style-spec/reference/latest';
-
-import {
-    Properties,
-    DataConstantProperty,
-    DataDrivenProperty,
-    CrossFadedDataDrivenProperty,
-    CrossFadedProperty,
-    ColorRampProperty
-} from '../properties';
-
-import type Color from '../../style-spec/util/color';
-
-import type Formatted from '../../style-spec/expression/types/formatted';
-
-import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
-
-
-export type PaintProps = {|
-    "heatmap-radius": DataDrivenProperty<number>,
-    "heatmap-weight": DataDrivenProperty<number>,
-    "heatmap-intensity": DataConstantProperty<number>,
-    "heatmap-color": ColorRampProperty,
-    "heatmap-opacity": DataConstantProperty<number>,
-|};
-
-const paint: Properties<PaintProps> = new Properties({
-    "heatmap-radius": new DataDrivenProperty(styleSpec["paint_heatmap"]["heatmap-radius"]),
-    "heatmap-weight": new DataDrivenProperty(styleSpec["paint_heatmap"]["heatmap-weight"]),
-    "heatmap-intensity": new DataConstantProperty(styleSpec["paint_heatmap"]["heatmap-intensity"]),
-    "heatmap-color": new ColorRampProperty(styleSpec["paint_heatmap"]["heatmap-color"]),
-    "heatmap-opacity": new DataConstantProperty(styleSpec["paint_heatmap"]["heatmap-opacity"]),
-});
-
-// Note: without adding the explicit type annotation, Flow infers weaker types
-// for these objects from their use in the constructor to StyleLayer, as
-// {layout?: Properties<...>, paint: Properties<...>}
-export default ({ paint }: $Exact<{
-  paint: Properties<PaintProps>
-}>);

package/src/style/style_layer/hillshade_style_layer.js

@@ -1,25 +0,0 @@
-// @flow
-
-import StyleLayer from '../style_layer';
-
-import properties from './hillshade_style_layer_properties';
-import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
-
-import type {PaintProps} from './hillshade_style_layer_properties';
-import type {LayerSpecification} from '../../style-spec/types';
-
-class HillshadeStyleLayer extends StyleLayer {
-    _transitionablePaint: Transitionable<PaintProps>;
-    _transitioningPaint: Transitioning<PaintProps>;
-    paint: PossiblyEvaluated<PaintProps>;
-
-    constructor(layer: LayerSpecification) {
-        super(layer, properties);
-    }
-
-    hasOffscreenPass() {
-        return this.paint.get('hillshade-exaggeration') !== 0 && this.visibility !== 'none';
-    }
-}
-
-export default HillshadeStyleLayer;

package/src/style/style_layer/hillshade_style_layer_properties.js

@@ -1,46 +0,0 @@
-// This file is generated. Edit build/generate-style-code.js, then run `yarn run codegen`.
-// @flow
-/* eslint-disable */
-
-import styleSpec from '../../style-spec/reference/latest';
-
-import {
-    Properties,
-    DataConstantProperty,
-    DataDrivenProperty,
-    CrossFadedDataDrivenProperty,
-    CrossFadedProperty,
-    ColorRampProperty
-} from '../properties';
-
-import type Color from '../../style-spec/util/color';
-
-import type Formatted from '../../style-spec/expression/types/formatted';
-
-import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
-
-
-export type PaintProps = {|
-    "hillshade-illumination-direction": DataConstantProperty<number>,
-    "hillshade-illumination-anchor": DataConstantProperty<"map" | "viewport">,
-    "hillshade-exaggeration": DataConstantProperty<number>,
-    "hillshade-shadow-color": DataConstantProperty<Color>,
-    "hillshade-highlight-color": DataConstantProperty<Color>,
-    "hillshade-accent-color": DataConstantProperty<Color>,
-|};
-
-const paint: Properties<PaintProps> = new Properties({
-    "hillshade-illumination-direction": new DataConstantProperty(styleSpec["paint_hillshade"]["hillshade-illumination-direction"]),
-    "hillshade-illumination-anchor": new DataConstantProperty(styleSpec["paint_hillshade"]["hillshade-illumination-anchor"]),
-    "hillshade-exaggeration": new DataConstantProperty(styleSpec["paint_hillshade"]["hillshade-exaggeration"]),
-    "hillshade-shadow-color": new DataConstantProperty(styleSpec["paint_hillshade"]["hillshade-shadow-color"]),
-    "hillshade-highlight-color": new DataConstantProperty(styleSpec["paint_hillshade"]["hillshade-highlight-color"]),
-    "hillshade-accent-color": new DataConstantProperty(styleSpec["paint_hillshade"]["hillshade-accent-color"]),
-});
-
-// Note: without adding the explicit type annotation, Flow infers weaker types
-// for these objects from their use in the constructor to StyleLayer, as
-// {layout?: Properties<...>, paint: Properties<...>}
-export default ({ paint }: $Exact<{
-  paint: Properties<PaintProps>
-}>);

package/src/style/style_layer/layer_properties.js.ejs

@@ -1,69 +0,0 @@
-<%
-  const type = locals.type;
-  const layoutProperties = locals.layoutProperties;
-  const paintProperties = locals.paintProperties;
--%>
-// This file is generated. Edit build/generate-style-code.js, then run `yarn run codegen`.
-// @flow
-/* eslint-disable */
-
-import styleSpec from '../../style-spec/reference/latest';
-
-import {
-    Properties,
-    DataConstantProperty,
-    DataDrivenProperty,
-    CrossFadedDataDrivenProperty,
-    CrossFadedProperty,
-    ColorRampProperty
-} from '../properties';
-
-import type Color from '../../style-spec/util/color';
-
-import type Formatted from '../../style-spec/expression/types/formatted';
-
-import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
-<%
-const overridables = paintProperties.filter(p => p.overridable)
-if (overridables.length) { -%>
-
-import {
-    <%= overridables.reduce((imports, prop) => { imports.push(runtimeType(prop)); return imports; }, []).join(',\n\t'); -%>
-
-} from '../../style-spec/expression/types';
-<% } -%>
-
-<% if (layoutProperties.length) { -%>
-export type LayoutProps = {|
-<% for (const property of layoutProperties) { -%>
-    "<%= property.name %>": <%- propertyType(property) %>,
-<% } -%>
-|};
-
-const layout: Properties<LayoutProps> = new Properties({
-<% for (const property of layoutProperties) { -%>
-    "<%= property.name %>": <%- propertyValue(property, 'layout') %>,
-<% } -%>
-});
-<% } -%>
-<% if(paintProperties.length){ %>
-export type PaintProps = {|
-<% for (const property of paintProperties) { -%>
-    "<%= property.name %>": <%- propertyType(property) %>,
-<% } -%>
-|};
-<% } else{ %>
-export type PaintProps = {};
-<% } %>
-const paint: Properties<PaintProps> = new Properties({
-<% for (const property of paintProperties) { -%>
-    "<%= property.name %>": <%- propertyValue(property, 'paint') %>,
-<% } -%>
-});
-
-// Note: without adding the explicit type annotation, Flow infers weaker types
-// for these objects from their use in the constructor to StyleLayer, as
-// {layout?: Properties<...>, paint: Properties<...>}
-export default ({ paint<% if (layoutProperties.length) { %>, layout<% } %> }: $Exact<{
-  paint: Properties<PaintProps><% if (layoutProperties.length) { %>, layout: Properties<LayoutProps><% } %>
-}>);