@mapgis/mapbox-gl 16.0.0 → 16.2.0

package/src/source/worker.js

@@ -1,237 +0,0 @@
-// @flow
-
-import Actor from '../util/actor';
-
-import StyleLayerIndex from '../style/style_layer_index';
-import VectorTileWorkerSource from './vector_tile_worker_source';
-import RasterDEMTileWorkerSource from './raster_dem_tile_worker_source';
-import RasterTileSourceOffline from './raster_tile_offline_source';
-import GeoJSONWorkerSource from './geojson_worker_source';
-import assert from 'assert';
-import {plugin as globalRTLTextPlugin} from './rtl_text_plugin';
-import {enforceCacheSizeLimit} from '../util/tile_request_cache';
-
-import type {
-    WorkerSource,
-    WorkerTileParameters,
-    WorkerDEMTileParameters,
-    WorkerTileCallback,
-    WorkerDEMTileCallback,
-    TileParameters
-} from '../source/worker_source';
-
-import type {WorkerGlobalScopeInterface} from '../util/web_worker';
-import type {Callback} from '../types/callback';
-import type {LayerSpecification} from '../style-spec/types';
-import type {PluginState} from './rtl_text_plugin';
-
-/**
- * @private
- */
-export default class Worker {
-    self: WorkerGlobalScopeInterface;
-    actor: Actor;
-    layerIndexes: {[_: string]: StyleLayerIndex };
-    availableImages: {[_: string]: Array<string> };
-    workerSourceTypes: {[_: string]: Class<WorkerSource> };
-    workerSources: {[_: string]: {[_: string]: {[_: string]: WorkerSource } } };
-    demWorkerSources: {[_: string]: {[_: string]: RasterDEMTileWorkerSource } };
-    referrer: ?string;
-
-    constructor(self: WorkerGlobalScopeInterface) {
-        this.self = self;
-        this.actor = new Actor(self, this);
-
-        this.layerIndexes = {};
-        this.availableImages = {};
-
-        this.workerSourceTypes = {
-            vector: VectorTileWorkerSource,
-            mbtiles: VectorTileWorkerSource,
-            geojson: GeoJSONWorkerSource,
-            rasteroffline: RasterTileSourceOffline
-        };
-
-        // [mapId][sourceType][sourceName] => worker source instance
-        this.workerSources = {};
-        this.demWorkerSources = {};
-
-        this.self.registerWorkerSource = (name: string, WorkerSource: Class<WorkerSource>) => {
-            if (this.workerSourceTypes[name]) {
-                throw new Error(`Worker source with name "${name}" already registered.`);
-            }
-            this.workerSourceTypes[name] = WorkerSource;
-        };
-
-        // This is invoked by the RTL text plugin when the download via the `importScripts` call has finished, and the code has been parsed.
-        this.self.registerRTLTextPlugin = (rtlTextPlugin: {applyArabicShaping: Function, processBidirectionalText: Function, processStyledBidirectionalText?: Function}) => {
-            if (globalRTLTextPlugin.isParsed()) {
-                throw new Error('RTL text plugin already registered.');
-            }
-            globalRTLTextPlugin['applyArabicShaping'] = rtlTextPlugin.applyArabicShaping;
-            globalRTLTextPlugin['processBidirectionalText'] = rtlTextPlugin.processBidirectionalText;
-            globalRTLTextPlugin['processStyledBidirectionalText'] = rtlTextPlugin.processStyledBidirectionalText;
-        };
-    }
-
-    setReferrer(mapID: string, referrer: string) {
-        this.referrer = referrer;
-    }
-
-    setImages(mapId: string, images: Array<string>, callback: WorkerTileCallback) {
-        this.availableImages[mapId] = images;
-        callback();
-    }
-
-    setLayers(mapId: string, layers: Array<LayerSpecification>, callback: WorkerTileCallback) {
-        this.getLayerIndex(mapId).replace(layers);
-        callback();
-    }
-
-    updateLayers(mapId: string, params: {layers: Array<LayerSpecification>, removedIds: Array<string>}, callback: WorkerTileCallback) {
-        this.getLayerIndex(mapId).update(params.layers, params.removedIds);
-        callback();
-    }
-
-    loadTile(mapId: string, params: WorkerTileParameters & {type: string}, callback: WorkerTileCallback) {
-        assert(params.type);
-        this.getWorkerSource(mapId, params.type, params.source).loadTile(params, callback);
-    }
-
-    loadDEMTile(mapId: string, params: WorkerDEMTileParameters, callback: WorkerDEMTileCallback) {
-        this.getDEMWorkerSource(mapId, params.source).loadTile(params, callback);
-    }
-
-    reloadTile(mapId: string, params: WorkerTileParameters & {type: string}, callback: WorkerTileCallback) {
-        assert(params.type);
-        this.getWorkerSource(mapId, params.type, params.source).reloadTile(params, callback);
-    }
-
-    abortTile(mapId: string, params: TileParameters & {type: string}, callback: WorkerTileCallback) {
-        assert(params.type);
-        this.getWorkerSource(mapId, params.type, params.source).abortTile(params, callback);
-    }
-
-    removeTile(mapId: string, params: TileParameters & {type: string}, callback: WorkerTileCallback) {
-        assert(params.type);
-        this.getWorkerSource(mapId, params.type, params.source).removeTile(params, callback);
-    }
-
-    removeDEMTile(mapId: string, params: TileParameters) {
-        this.getDEMWorkerSource(mapId, params.source).removeTile(params);
-    }
-
-    removeSource(mapId: string, params: {source: string} & {type: string}, callback: WorkerTileCallback) {
-        assert(params.type);
-        assert(params.source);
-
-        if (!this.workerSources[mapId] ||
-            !this.workerSources[mapId][params.type] ||
-            !this.workerSources[mapId][params.type][params.source]) {
-            return;
-        }
-
-        const worker = this.workerSources[mapId][params.type][params.source];
-        delete this.workerSources[mapId][params.type][params.source];
-
-        if (worker.removeSource !== undefined) {
-            worker.removeSource(params, callback);
-        } else {
-            callback();
-        }
-    }
-
-    /**
-     * Load a {@link WorkerSource} script at params.url.  The script is run
-     * (using importScripts) with `registerWorkerSource` in scope, which is a
-     * function taking `(name, workerSourceObject)`.
-     *  @private
-     */
-    loadWorkerSource(map: string, params: { url: string }, callback: Callback<void>) {
-        try {
-            this.self.importScripts(params.url);
-            callback();
-        } catch (e) {
-            callback(e.toString());
-        }
-    }
-
-    syncRTLPluginState(map: string, state: PluginState, callback: Callback<boolean>) {
-        try {
-            globalRTLTextPlugin.setState(state);
-            const pluginURL = globalRTLTextPlugin.getPluginURL();
-            if (
-                globalRTLTextPlugin.isLoaded() &&
-                !globalRTLTextPlugin.isParsed() &&
-                pluginURL != null // Not possible when `isLoaded` is true, but keeps flow happy
-            ) {
-                this.self.importScripts(pluginURL);
-                const complete = globalRTLTextPlugin.isParsed();
-                const error = complete ? undefined : new Error(`RTL Text Plugin failed to import scripts from ${pluginURL}`);
-                callback(error, complete);
-            }
-        } catch (e) {
-            callback(e.toString());
-        }
-    }
-
-    getAvailableImages(mapId: string) {
-        let availableImages = this.availableImages[mapId];
-
-        if (!availableImages) {
-            availableImages = [];
-        }
-
-        return availableImages;
-    }
-
-    getLayerIndex(mapId: string) {
-        let layerIndexes = this.layerIndexes[mapId];
-        if (!layerIndexes) {
-            layerIndexes = this.layerIndexes[mapId] = new StyleLayerIndex();
-        }
-        return layerIndexes;
-    }
-
-    getWorkerSource(mapId: string, type: string, source: string) {
-        if (!this.workerSources[mapId])
-            this.workerSources[mapId] = {};
-        if (!this.workerSources[mapId][type])
-            this.workerSources[mapId][type] = {};
-
-        if (!this.workerSources[mapId][type][source]) {
-            // use a wrapped actor so that we can attach a target mapId param
-            // to any messages invoked by the WorkerSource
-            const actor = {
-                send: (type, data, callback) => {
-                    this.actor.send(type, data, callback, mapId);
-                }
-            };
-            this.workerSources[mapId][type][source] = new (this.workerSourceTypes[type]: any)((actor: any), this.getLayerIndex(mapId), this.getAvailableImages(mapId));
-        }
-
-        return this.workerSources[mapId][type][source];
-    }
-
-    getDEMWorkerSource(mapId: string, source: string) {
-        if (!this.demWorkerSources[mapId])
-            this.demWorkerSources[mapId] = {};
-
-        if (!this.demWorkerSources[mapId][source]) {
-            this.demWorkerSources[mapId][source] = new RasterDEMTileWorkerSource();
-        }
-
-        return this.demWorkerSources[mapId][source];
-    }
-
-    enforceCacheSizeLimit(mapId: string, limit: number) {
-        enforceCacheSizeLimit(limit);
-    }
-}
-
-/* global self, WorkerGlobalScope */
-if (typeof WorkerGlobalScope !== 'undefined' &&
-    typeof self !== 'undefined' &&
-    self instanceof WorkerGlobalScope) {
-    self.worker = new Worker(self);
-}

package/src/source/worker_source.js

@@ -1,106 +0,0 @@
-// @flow
-
-import type {RequestParameters} from '../util/ajax';
-import type {RGBAImage, AlphaImage} from '../util/image';
-import type {GlyphPositions} from '../render/glyph_atlas';
-import type ImageAtlas from '../render/image_atlas';
-import type {OverscaledTileID} from './tile_id';
-import type {Bucket} from '../data/bucket';
-import type FeatureIndex from '../data/feature_index';
-import type {CollisionBoxArray} from '../data/array_types';
-import type DEMData from '../data/dem_data';
-import type {StyleGlyph} from '../style/style_glyph';
-import type {StyleImage} from '../style/style_image';
-import type {PromoteIdSpecification} from '../style-spec/types';
-import window from '../util/window';
-const {ImageBitmap} = window;
-
-export type TileParameters = {
-    source: string,
-    uid: string,
-};
-
-export type WorkerTileParameters = TileParameters & {
-    tileID: OverscaledTileID,
-    request: RequestParameters,
-    zoom: number,
-    maxZoom: number,
-    tileSize: number,
-    promoteId: ?PromoteIdSpecification,
-    pixelRatio: number,
-    showCollisionBoxes: boolean,
-    collectResourceTiming?: boolean,
-    returnDependencies?: boolean
-};
-
-export type WorkerDEMTileParameters = TileParameters & {
-    coord: { z: number, x: number, y: number, w: number },
-    rawImageData: RGBAImage | ImageBitmap,
-    encoding: "mapbox" | "terrarium"
-};
-
-export type WorkerTileResult = {
-    buckets: Array<Bucket>,
-    imageAtlas: ImageAtlas,
-    glyphAtlasImage: AlphaImage,
-    featureIndex: FeatureIndex,
-    collisionBoxArray: CollisionBoxArray,
-    rawTileData?: ArrayBuffer,
-    resourceTiming?: Array<PerformanceResourceTiming>,
-    // Only used for benchmarking:
-    glyphMap?: {[_: string]: {[_: number]: ?StyleGlyph}} | null,
-    iconMap?: {[_: string]: StyleImage} | null,
-    glyphPositions?: GlyphPositions | null
-};
-
-export type WorkerTileCallback = (error: ?Error, result: ?WorkerTileResult) => void;
-export type WorkerDEMTileCallback = (err: ?Error, result: ?DEMData) => void;
-
-/**
- * May be implemented by custom source types to provide code that can be run on
- * the WebWorkers. In addition to providing a custom
- * {@link WorkerSource#loadTile}, any other methods attached to a `WorkerSource`
- * implementation may also be targeted by the {@link Source} via
- * `dispatcher.getActor().send('source-type.methodname', params, callback)`.
- *
- * @see {@link Map#addSourceType}
- * @private
- *
- * @class WorkerSource
- * @param actor
- * @param layerIndex
- */
-export interface WorkerSource {
-    // Disabled due to https://github.com/facebook/flow/issues/5208
-    // constructor(actor: Actor, layerIndex: StyleLayerIndex): WorkerSource;
-
-    /**
-     * Loads a tile from the given params and parse it into buckets ready to send
-     * back to the main thread for rendering.  Should call the callback with:
-     * `{ buckets, featureIndex, collisionIndex, rawTileData}`.
-     */
-    loadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
-
-    /**
-     * Re-parses a tile that has already been loaded.  Yields the same data as
-     * {@link WorkerSource#loadTile}.
-     */
-    reloadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
-
-    /**
-     * Aborts loading a tile that is in progress.
-     */
-    abortTile(params: TileParameters, callback: WorkerTileCallback): void;
-
-    /**
-     * Removes this tile from any local caches.
-     */
-    removeTile(params: TileParameters, callback: WorkerTileCallback): void;
-
-    /**
-     * Tells the WorkerSource to abort in-progress tasks and release resources.
-     * The foreground Source is responsible for ensuring that 'removeSource' is
-     * the last message sent to the WorkerSource.
-     */
-    removeSource?: (params: {source: string}, callback: WorkerTileCallback) => void;
-}

package/src/source/worker_tile.js

@@ -1,224 +0,0 @@
-// @flow
-
-import FeatureIndex from '../data/feature_index';
-
-import {performSymbolLayout} from '../symbol/symbol_layout';
-import {CollisionBoxArray} from '../data/array_types';
-import DictionaryCoder from '../util/dictionary_coder';
-import SymbolBucket from '../data/bucket/symbol_bucket';
-import LineBucket from '../data/bucket/line_bucket';
-import FillBucket from '../data/bucket/fill_bucket';
-import FillExtrusionBucket from '../data/bucket/fill_extrusion_bucket';
-import {warnOnce, mapObject, values} from '../util/util';
-import assert from 'assert';
-import ImageAtlas from '../render/image_atlas';
-import GlyphAtlas from '../render/glyph_atlas';
-import EvaluationParameters from '../style/evaluation_parameters';
-import {OverscaledTileID} from './tile_id';
-
-import type {Bucket} from '../data/bucket';
-import type Actor from '../util/actor';
-import type StyleLayer from '../style/style_layer';
-import type StyleLayerIndex from '../style/style_layer_index';
-import type {StyleImage} from '../style/style_image';
-import type {StyleGlyph} from '../style/style_glyph';
-import type {
-    WorkerTileParameters,
-    WorkerTileCallback,
-} from '../source/worker_source';
-import type {PromoteIdSpecification} from '../style-spec/types';
-
-class WorkerTile {
-    tileID: OverscaledTileID;
-    uid: string;
-    zoom: number;
-    pixelRatio: number;
-    tileSize: number;
-    source: string;
-    promoteId: ?PromoteIdSpecification;
-    overscaling: number;
-    showCollisionBoxes: boolean;
-    collectResourceTiming: boolean;
-    returnDependencies: boolean;
-
-    status: 'parsing' | 'done';
-    data: VectorTile;
-    collisionBoxArray: CollisionBoxArray;
-
-    abort: ?() => void;
-    reloadCallback: WorkerTileCallback;
-    vectorTile: VectorTile;
-
-    constructor(params: WorkerTileParameters) {
-        this.tileID = new OverscaledTileID(params.tileID.overscaledZ, params.tileID.wrap, params.tileID.canonical.z, params.tileID.canonical.x, params.tileID.canonical.y);
-        this.uid = params.uid;
-        this.zoom = params.zoom;
-        this.pixelRatio = params.pixelRatio;
-        this.tileSize = params.tileSize;
-        this.source = params.source;
-        this.overscaling = this.tileID.overscaleFactor();
-        this.showCollisionBoxes = params.showCollisionBoxes;
-        this.collectResourceTiming = !!params.collectResourceTiming;
-        this.returnDependencies = !!params.returnDependencies;
-        this.promoteId = params.promoteId;
-    }
-
-    parse(data: VectorTile, layerIndex: StyleLayerIndex, availableImages: Array<string>, actor: Actor, callback: WorkerTileCallback) {
-        this.status = 'parsing';
-        this.data = data;
-
-        this.collisionBoxArray = new CollisionBoxArray();
-        const sourceLayerCoder = new DictionaryCoder(Object.keys(data.layers).sort());
-
-        const featureIndex = new FeatureIndex(this.tileID, this.promoteId);
-        featureIndex.bucketLayerIDs = [];
-
-        const buckets: {[_: string]: Bucket} = {};
-
-        const options = {
-            featureIndex,
-            iconDependencies: {},
-            patternDependencies: {},
-            glyphDependencies: {},
-            availableImages
-        };
-
-        const layerFamilies = layerIndex.familiesBySource[this.source];
-        for (const sourceLayerId in layerFamilies) {
-            const sourceLayer = data.layers[sourceLayerId];
-            if (!sourceLayer) {
-                continue;
-            }
-
-            if (sourceLayer.version === 1) {
-                warnOnce(`Vector tile source "${this.source}" layer "${sourceLayerId}" ` +
-                    `does not use vector tile spec v2 and therefore may have some rendering errors.`);
-            }
-
-            const sourceLayerIndex = sourceLayerCoder.encode(sourceLayerId);
-            const features = [];
-            for (let index = 0; index < sourceLayer.length; index++) {
-                const feature = sourceLayer.feature(index);
-                const id = featureIndex.getId(feature, sourceLayerId);
-                features.push({feature, id, index, sourceLayerIndex});
-            }
-
-            for (const family of layerFamilies[sourceLayerId]) {
-                const layer = family[0];
-
-                assert(layer.source === this.source);
-                if (layer.minzoom && this.zoom < Math.floor(layer.minzoom)) continue;
-                if (layer.maxzoom && this.zoom >= layer.maxzoom) continue;
-                if (layer.visibility === 'none') continue;
-
-                recalculateLayers(family, this.zoom, availableImages);
-
-                const bucket = buckets[layer.id] = layer.createBucket({
-                    index: featureIndex.bucketLayerIDs.length,
-                    layers: family,
-                    zoom: this.zoom,
-                    pixelRatio: this.pixelRatio,
-                    overscaling: this.overscaling,
-                    collisionBoxArray: this.collisionBoxArray,
-                    sourceLayerIndex,
-                    sourceID: this.source
-                });
-
-                bucket.populate(features, options, this.tileID.canonical);
-                featureIndex.bucketLayerIDs.push(family.map((l) => l.id));
-            }
-        }
-
-        let error: ?Error;
-        let glyphMap: ?{[_: string]: {[_: number]: ?StyleGlyph}};
-        let iconMap: ?{[_: string]: StyleImage};
-        let patternMap: ?{[_: string]: StyleImage};
-
-        const stacks = mapObject(options.glyphDependencies, (glyphs) => Object.keys(glyphs).map(Number));
-        if (Object.keys(stacks).length) {
-            actor.send('getGlyphs', {uid: this.uid, stacks}, (err, result) => {
-                if (!error) {
-                    error = err;
-                    glyphMap = result;
-                    maybePrepare.call(this);
-                }
-            });
-        } else {
-            glyphMap = {};
-        }
-
-        const icons = Object.keys(options.iconDependencies);
-        if (icons.length) {
-            actor.send('getImages', {icons, source: this.source, tileID: this.tileID, type: 'icons'}, (err, result) => {
-                if (!error) {
-                    error = err;
-                    iconMap = result;
-                    maybePrepare.call(this);
-                }
-            });
-        } else {
-            iconMap = {};
-        }
-
-        const patterns = Object.keys(options.patternDependencies);
-        if (patterns.length) {
-            actor.send('getImages', {icons: patterns, source: this.source, tileID: this.tileID, type: 'patterns'}, (err, result) => {
-                if (!error) {
-                    error = err;
-                    patternMap = result;
-                    maybePrepare.call(this);
-                }
-            });
-        } else {
-            patternMap = {};
-        }
-
-        maybePrepare.call(this);
-
-        function maybePrepare() {
-            if (error) {
-                return callback(error);
-            } else if (glyphMap && iconMap && patternMap) {
-                const glyphAtlas = new GlyphAtlas(glyphMap);
-                const imageAtlas = new ImageAtlas(iconMap, patternMap);
-
-                for (const key in buckets) {
-                    const bucket = buckets[key];
-                    if (bucket instanceof SymbolBucket) {
-                        recalculateLayers(bucket.layers, this.zoom, availableImages);
-                        performSymbolLayout(bucket, glyphMap, glyphAtlas.positions, iconMap, imageAtlas.iconPositions, this.showCollisionBoxes, this.tileID.canonical);
-                    } else if (bucket.hasPattern &&
-                        (bucket instanceof LineBucket ||
-                         bucket instanceof FillBucket ||
-                         bucket instanceof FillExtrusionBucket)) {
-                        recalculateLayers(bucket.layers, this.zoom, availableImages);
-                        bucket.addFeatures(options, this.tileID.canonical, imageAtlas.patternPositions);
-                    }
-                }
-
-                this.status = 'done';
-                callback(null, {
-                    buckets: values(buckets).filter(b => !b.isEmpty()),
-                    featureIndex,
-                    collisionBoxArray: this.collisionBoxArray,
-                    glyphAtlasImage: glyphAtlas.image,
-                    imageAtlas,
-                    // Only used for benchmarking:
-                    glyphMap: this.returnDependencies ? glyphMap : null,
-                    iconMap: this.returnDependencies ? iconMap : null,
-                    glyphPositions: this.returnDependencies ? glyphAtlas.positions : null
-                });
-            }
-        }
-    }
-}
-
-function recalculateLayers(layers: $ReadOnlyArray<StyleLayer>, zoom: number, availableImages: Array<string>) {
-    // Layers are shared and may have been used by a WorkerTile with a different zoom.
-    const parameters = new EvaluationParameters(zoom);
-    for (const layer of layers) {
-        layer.recalculate(parameters, availableImages);
-    }
-}
-
-export default WorkerTile;

package/src/style/create_style_layer.js

@@ -1,36 +0,0 @@
-// @flow
-
-import circle from './style_layer/circle_style_layer';
-import heatmap from './style_layer/heatmap_style_layer';
-import hillshade from './style_layer/hillshade_style_layer';
-import fill from './style_layer/fill_style_layer';
-import fillExtrusion from './style_layer/fill_extrusion_style_layer';
-import line from './style_layer/line_style_layer';
-import symbol from './style_layer/symbol_style_layer';
-import background from './style_layer/background_style_layer';
-import raster from './style_layer/raster_style_layer';
-import CustomStyleLayer from './style_layer/custom_style_layer';
-import type {CustomLayerInterface} from './style_layer/custom_style_layer';
-
-import type {LayerSpecification} from '../style-spec/types';
-
-const subclasses = {
-    circle,
-    heatmap,
-    hillshade,
-    fill,
-    'fill-extrusion': fillExtrusion,
-    line,
-    symbol,
-    background,
-    raster
-};
-
-export default function createStyleLayer(layer: LayerSpecification | CustomLayerInterface) {
-    if (layer.type === 'custom') {
-        return new CustomStyleLayer(layer);
-    } else {
-        return new subclasses[layer.type](layer);
-    }
-}
-

package/src/style/evaluation_parameters.js

@@ -1,62 +0,0 @@
-// @flow
-
-import ZoomHistory from './zoom_history';
-import {isStringInSupportedScript} from '../util/script_detection';
-import {plugin as rtlTextPlugin} from '../source/rtl_text_plugin';
-
-import type {TransitionSpecification} from '../style-spec/types';
-
-export type CrossfadeParameters = {
-    fromScale: number,
-    toScale: number,
-    t: number
-};
-
-class EvaluationParameters {
-    zoom: number;
-    now: number;
-    fadeDuration: number;
-    zoomHistory: ZoomHistory;
-    transition: TransitionSpecification;
-
-    // "options" may also be another EvaluationParameters to copy, see CrossFadedProperty.possiblyEvaluate
-    constructor(zoom: number, options?: *) {
-        this.zoom = zoom;
-
-        if (options) {
-            this.now = options.now;
-            this.fadeDuration = options.fadeDuration;
-            this.zoomHistory = options.zoomHistory;
-            this.transition = options.transition;
-        } else {
-            this.now = 0;
-            this.fadeDuration = 0;
-            this.zoomHistory = new ZoomHistory();
-            this.transition = {};
-        }
-    }
-
-    isSupportedScript(str: string): boolean {
-        return isStringInSupportedScript(str, rtlTextPlugin.isLoaded());
-    }
-
-    crossFadingFactor() {
-        if (this.fadeDuration === 0) {
-            return 1;
-        } else {
-            return Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);
-        }
-    }
-
-    getCrossfadeParameters(): CrossfadeParameters {
-        const z = this.zoom;
-        const fraction = z - Math.floor(z);
-        const t = this.crossFadingFactor();
-
-        return z > this.zoomHistory.lastIntegerZoom ?
-            {fromScale: 2, toScale: 1, t: fraction + (1 - fraction) * t} :
-            {fromScale: 0.5, toScale: 1, t: 1 - (1 - t) * fraction};
-    }
-}
-
-export default EvaluationParameters;