@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/style/style_layer.js

@@ -1,281 +0,0 @@
-// @flow
-
-import {endsWith, filterObject} from '../util/util';
-
-import styleSpec from '../style-spec/reference/latest';
-import {
-    validateStyle,
-    validateLayoutProperty,
-    validatePaintProperty,
-    emitValidationErrors
-} from './validate_style';
-import {Evented} from '../util/evented';
-import {Layout, Transitionable, Transitioning, Properties, PossiblyEvaluatedPropertyValue} from './properties';
-import {supportsPropertyExpression} from '../style-spec/util/properties';
-
-import type {FeatureState} from '../style-spec/expression';
-import type {Bucket} from '../data/bucket';
-import type Point from '@mapbox/point-geometry';
-import type {FeatureFilter} from '../style-spec/feature_filter';
-import type {TransitionParameters, PropertyValue} from './properties';
-import type EvaluationParameters, {CrossfadeParameters} from './evaluation_parameters';
-import type Transform from '../geo/transform';
-import type {
-    LayerSpecification,
-    FilterSpecification
-} from '../style-spec/types';
-import type {CustomLayerInterface} from './style_layer/custom_style_layer';
-import type Map from '../ui/map';
-import type {StyleSetterOptions} from './style';
-
-const TRANSITION_SUFFIX = '-transition';
-
-class StyleLayer extends Evented {
-    id: string;
-    metadata: mixed;
-    type: string;
-    source: string;
-    sourceLayer: ?string;
-    minzoom: ?number;
-    maxzoom: ?number;
-    filter: FilterSpecification | void;
-    visibility: 'visible' | 'none' | void;
-    _crossfadeParameters: CrossfadeParameters;
-
-    _unevaluatedLayout: Layout<any>;
-    +layout: mixed;
-
-    _transitionablePaint: Transitionable<any>;
-    _transitioningPaint: Transitioning<any>;
-    +paint: mixed;
-
-    _featureFilter: FeatureFilter;
-
-    +queryRadius: (bucket: Bucket) => number;
-    +queryIntersectsFeature: (queryGeometry: Array<Point>,
-                              feature: VectorTileFeature,
-                              featureState: FeatureState,
-                              geometry: Array<Array<Point>>,
-                              zoom: number,
-                              transform: Transform,
-                              pixelsToTileUnits: number,
-                              pixelPosMatrix: Float32Array) => boolean | number;
-
-    +onAdd: ?(map: Map) => void;
-    +onRemove: ?(map: Map) => void;
-
-    constructor(layer: LayerSpecification | CustomLayerInterface, properties: $ReadOnly<{layout?: Properties<*>, paint?: Properties<*>}>) {
-        super();
-
-        this.id = layer.id;
-        this.type = layer.type;
-        this._featureFilter = {filter: () => true, needGeometry: false};
-
-        if (layer.type === 'custom') return;
-
-        layer = ((layer: any): LayerSpecification);
-
-        this.metadata = layer.metadata;
-        this.minzoom = layer.minzoom;
-        this.maxzoom = layer.maxzoom;
-
-        if (layer.type !== 'background') {
-            this.source = layer.source;
-            this.sourceLayer = layer['source-layer'];
-            this.filter = layer.filter;
-        }
-
-        if (properties.layout) {
-            this._unevaluatedLayout = new Layout(properties.layout);
-        }
-
-        if (properties.paint) {
-            this._transitionablePaint = new Transitionable(properties.paint);
-
-            for (const property in layer.paint) {
-                this.setPaintProperty(property, layer.paint[property], {validate: false});
-            }
-            for (const property in layer.layout) {
-                this.setLayoutProperty(property, layer.layout[property], {validate: false});
-            }
-
-            this._transitioningPaint = this._transitionablePaint.untransitioned();
-        }
-    }
-
-    getCrossfadeParameters() {
-        return this._crossfadeParameters;
-    }
-
-    getLayoutProperty(name: string) {
-        if (name === 'visibility') {
-            return this.visibility;
-        }
-
-        return this._unevaluatedLayout.getValue(name);
-    }
-
-    setLayoutProperty(name: string, value: any, options: StyleSetterOptions = {}) {
-        if (value !== null && value !== undefined) {
-            const key = `layers.${this.id}.layout.${name}`;
-            if (this._validate(validateLayoutProperty, key, name, value, options)) {
-                return;
-            }
-        }
-
-        if (name === 'visibility') {
-            this.visibility = value;
-            return;
-        }
-
-        this._unevaluatedLayout.setValue(name, value);
-    }
-
-    getPaintProperty(name: string) {
-        if (endsWith(name, TRANSITION_SUFFIX)) {
-            return this._transitionablePaint.getTransition(name.slice(0, -TRANSITION_SUFFIX.length));
-        } else {
-            return this._transitionablePaint.getValue(name);
-        }
-    }
-
-    setPaintProperty(name: string, value: mixed, options: StyleSetterOptions = {}) {
-        if (value !== null && value !== undefined) {
-            const key = `layers.${this.id}.paint.${name}`;
-            if (this._validate(validatePaintProperty, key, name, value, options)) {
-                return false;
-            }
-        }
-
-        if (endsWith(name, TRANSITION_SUFFIX)) {
-            this._transitionablePaint.setTransition(name.slice(0, -TRANSITION_SUFFIX.length), (value: any) || undefined);
-            return false;
-        } else {
-            const transitionable = this._transitionablePaint._values[name];
-            const isCrossFadedProperty = transitionable.property.specification["property-type"] === 'cross-faded-data-driven';
-            const wasDataDriven = transitionable.value.isDataDriven();
-            const oldValue = transitionable.value;
-
-            this._transitionablePaint.setValue(name, value);
-            this._handleSpecialPaintPropertyUpdate(name);
-
-            const newValue = this._transitionablePaint._values[name].value;
-            const isDataDriven = newValue.isDataDriven();
-
-            // if a cross-faded value is changed, we need to make sure the new icons get added to each tile's iconAtlas
-            // so a call to _updateLayer is necessary, and we return true from this function so it gets called in
-            // Style#setPaintProperty
-            return isDataDriven || wasDataDriven || isCrossFadedProperty || this._handleOverridablePaintPropertyUpdate(name, oldValue, newValue);
-        }
-    }
-
-    _handleSpecialPaintPropertyUpdate(_: string) {
-        // No-op; can be overridden by derived classes.
-    }
-
-    // eslint-disable-next-line no-unused-vars
-    _handleOverridablePaintPropertyUpdate<T, R>(name: string, oldValue: PropertyValue<T, R>, newValue: PropertyValue<T, R>): boolean {
-        // No-op; can be overridden by derived classes.
-        return false;
-    }
-
-    isHidden(zoom: number) {
-        if (this.minzoom && zoom < this.minzoom) return true;
-        if (this.maxzoom && zoom >= this.maxzoom) return true;
-        return this.visibility === 'none';
-    }
-
-    updateTransitions(parameters: TransitionParameters) {
-        this._transitioningPaint = this._transitionablePaint.transitioned(parameters, this._transitioningPaint);
-    }
-
-    hasTransition() {
-        return this._transitioningPaint.hasTransition();
-    }
-
-    recalculate(parameters: EvaluationParameters, availableImages: Array<string>) {
-        if (parameters.getCrossfadeParameters) {
-            this._crossfadeParameters = parameters.getCrossfadeParameters();
-        }
-
-        if (this._unevaluatedLayout) {
-            (this: any).layout = this._unevaluatedLayout.possiblyEvaluate(parameters, availableImages);
-        }
-
-        (this: any).paint = this._transitioningPaint.possiblyEvaluate(parameters, availableImages);
-    }
-
-    serialize() {
-        const output: any = {
-            'id': this.id,
-            'type': this.type,
-            'source': this.source,
-            'source-layer': this.sourceLayer,
-            'metadata': this.metadata,
-            'minzoom': this.minzoom,
-            'maxzoom': this.maxzoom,
-            'filter': this.filter,
-            'layout': this._unevaluatedLayout && this._unevaluatedLayout.serialize(),
-            'paint': this._transitionablePaint && this._transitionablePaint.serialize()
-        };
-
-        if (this.visibility) {
-            output.layout = output.layout || {};
-            output.layout.visibility = this.visibility;
-        }
-
-        return filterObject(output, (value, key) => {
-            return value !== undefined &&
-                !(key === 'layout' && !Object.keys(value).length) &&
-                !(key === 'paint' && !Object.keys(value).length);
-        });
-    }
-
-    _validate(validate: Function, key: string, name: string, value: mixed, options: StyleSetterOptions = {}) {
-        if (options && options.validate === false) {
-            return false;
-        }
-        return emitValidationErrors(this, validate.call(validateStyle, {
-            key,
-            layerType: this.type,
-            objectKey: name,
-            value,
-            styleSpec,
-            // Workaround for https://github.com/mapbox/mapbox-gl-js/issues/2407
-            style: {glyphs: true, sprite: true}
-        }));
-    }
-
-    is3D() {
-        return false;
-    }
-
-    isTileClipped() {
-        return false;
-    }
-
-    hasOffscreenPass() {
-        return false;
-    }
-
-    resize() {
-        // noop
-    }
-
-    isStateDependent() {
-        for (const property in (this: any).paint._values) {
-            const value = (this: any).paint.get(property);
-            if (!(value instanceof PossiblyEvaluatedPropertyValue) || !supportsPropertyExpression(value.property.specification)) {
-                continue;
-            }
-
-            if ((value.value.kind === 'source' || value.value.kind === 'composite') &&
-                value.value.isStateDependent) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-
-export default StyleLayer;

package/src/style/style_layer_index.js

@@ -1,80 +0,0 @@
-// @flow
-
-import StyleLayer from './style_layer';
-import createStyleLayer from './create_style_layer';
-
-import {values} from '../util/util';
-import featureFilter from '../style-spec/feature_filter';
-import groupByLayout from '../style-spec/group_by_layout';
-
-import type {TypedStyleLayer} from './style_layer/typed_style_layer';
-import type {LayerSpecification} from '../style-spec/types';
-
-export type LayerConfigs = {[_: string]: LayerSpecification };
-export type Family<Layer: TypedStyleLayer> = Array<Layer>;
-
-class StyleLayerIndex {
-    familiesBySource: { [source: string]: { [sourceLayer: string]: Array<Family<*>> } };
-    keyCache: { [source: string]: string };
-
-    _layerConfigs: LayerConfigs;
-    _layers: {[_: string]: StyleLayer };
-
-    constructor(layerConfigs: ?Array<LayerSpecification>) {
-        this.keyCache = {};
-        if (layerConfigs) {
-            this.replace(layerConfigs);
-        }
-    }
-
-    replace(layerConfigs: Array<LayerSpecification>) {
-        this._layerConfigs = {};
-        this._layers = {};
-        this.update(layerConfigs, []);
-    }
-
-    update(layerConfigs: Array<LayerSpecification>, removedIds: Array<string>) {
-        for (const layerConfig of layerConfigs) {
-            this._layerConfigs[layerConfig.id] = layerConfig;
-
-            const layer = this._layers[layerConfig.id] = createStyleLayer(layerConfig);
-            layer._featureFilter = featureFilter(layer.filter);
-            if (this.keyCache[layerConfig.id])
-                delete this.keyCache[layerConfig.id];
-        }
-        for (const id of removedIds) {
-            delete this.keyCache[id];
-            delete this._layerConfigs[id];
-            delete this._layers[id];
-        }
-
-        this.familiesBySource = {};
-
-        const groups = groupByLayout(values(this._layerConfigs), this.keyCache);
-
-        for (const layerConfigs of groups) {
-            const layers = layerConfigs.map((layerConfig) => this._layers[layerConfig.id]);
-
-            const layer = layers[0];
-            if (layer.visibility === 'none') {
-                continue;
-            }
-
-            const sourceId = layer.source || '';
-            let sourceGroup = this.familiesBySource[sourceId];
-            if (!sourceGroup) {
-                sourceGroup = this.familiesBySource[sourceId] = {};
-            }
-
-            const sourceLayerId = layer.sourceLayer || '_geojsonTileLayer';
-            let sourceLayerFamilies = sourceGroup[sourceLayerId];
-            if (!sourceLayerFamilies) {
-                sourceLayerFamilies = sourceGroup[sourceLayerId] = [];
-            }
-
-            sourceLayerFamilies.push(layers);
-        }
-    }
-}
-
-export default StyleLayerIndex;

package/src/style/validate_style.js

@@ -1,42 +0,0 @@
-// @flow
-import validateStyleMin from '../style-spec/validate_style.min';
-import {ErrorEvent} from '../util/evented';
-
-import type {Evented} from '../util/evented';
-
-type ValidationError = {
-    message: string,
-    line: number,
-    identifier?: string
-};
-
-export type Validator = (Object) => $ReadOnlyArray<ValidationError>;
-
-type ValidateStyle = {
-    (Object, ?Object): $ReadOnlyArray<ValidationError>,
-    source: Validator,
-    layer: Validator,
-    light: Validator,
-    filter: Validator,
-    paintProperty: Validator,
-    layoutProperty: Validator
-};
-
-export const validateStyle = (validateStyleMin: ValidateStyle);
-
-export const validateSource = validateStyle.source;
-export const validateLight = validateStyle.light;
-export const validateFilter = validateStyle.filter;
-export const validatePaintProperty = validateStyle.paintProperty;
-export const validateLayoutProperty = validateStyle.layoutProperty;
-
-export function emitValidationErrors(emitter: Evented, errors: ?$ReadOnlyArray<{message: string, identifier?: string}>): boolean {
-    let hasErrors = false;
-    if (errors && errors.length) {
-        for (const error of errors) {
-            emitter.fire(new ErrorEvent(new Error(error.message)));
-            hasErrors = true;
-        }
-    }
-    return hasErrors;
-}

package/src/style/zoom_history.js

@@ -1,44 +0,0 @@
-// @flow
-
-class ZoomHistory {
-    lastZoom: number;
-    lastFloorZoom: number;
-    lastIntegerZoom: number;
-    lastIntegerZoomTime: number;
-    first: boolean;
-
-    constructor() {
-        this.first = true;
-    }
-
-    update(z: number, now: number) {
-        const floorZ = Math.floor(z);
-
-        if (this.first) {
-            this.first = false;
-            this.lastIntegerZoom = floorZ;
-            this.lastIntegerZoomTime = 0;
-            this.lastZoom = z;
-            this.lastFloorZoom = floorZ;
-            return true;
-        }
-
-        if (this.lastFloorZoom > floorZ) {
-            this.lastIntegerZoom = floorZ + 1;
-            this.lastIntegerZoomTime = now;
-        } else if (this.lastFloorZoom < floorZ) {
-            this.lastIntegerZoom = floorZ;
-            this.lastIntegerZoomTime = now;
-        }
-
-        if (z !== this.lastZoom) {
-            this.lastZoom = z;
-            this.lastFloorZoom = floorZ;
-            return true;
-        }
-
-        return false;
-    }
-}
-
-export default ZoomHistory;

package/src/style-spec/.eslintrc

@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "flowtype/require-valid-file-annotation": [0]
-  }
-}