@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/source/vector_tile_source.js

@@ -1,192 +0,0 @@
-// @flow
-
-import {Event, ErrorEvent, Evented} from '../util/evented';
-
-import {extend, pick} from '../util/util';
-import loadTileJSON from './load_tilejson';
-import {postTurnstileEvent, postMapLoadEvent} from '../util/mapbox';
-import TileBounds from './tile_bounds';
-import {ResourceType} from '../util/ajax';
-import browser from '../util/browser';
-import {cacheEntryPossiblyAdded} from '../util/tile_request_cache';
-
-import type {Source} from './source';
-import type {OverscaledTileID} from './tile_id';
-import type Map from '../ui/map';
-import type Dispatcher from '../util/dispatcher';
-import type Tile from './tile';
-import type {Callback} from '../types/callback';
-import type {Cancelable} from '../types/cancelable';
-import type {VectorSourceSpecification, PromoteIdSpecification} from '../style-spec/types';
-
-class VectorTileSource extends Evented implements Source {
-    type: 'vector';
-    id: string;
-    minzoom: number;
-    maxzoom: number;
-    url: string;
-    scheme: string;
-    tileSize: number;
-    promoteId: ?PromoteIdSpecification;
-
-    _options: VectorSourceSpecification;
-    _collectResourceTiming: boolean;
-    dispatcher: Dispatcher;
-    map: Map;
-    bounds: ?[number, number, number, number];
-    tiles: Array<string>;
-    tileBounds: TileBounds;
-    reparseOverscaled: boolean;
-    isTileClipped: boolean;
-    _tileJSONRequest: ?Cancelable;
-    _loaded: boolean;
-
-    constructor(id: string, options: VectorSourceSpecification & {collectResourceTiming: boolean}, dispatcher: Dispatcher, eventedParent: Evented) {
-        super();
-        this.id = id;
-        this.dispatcher = dispatcher;
-
-        this.type = 'vector';
-        this.minzoom = 0;
-        this.maxzoom = 22;
-        this.scheme = 'xyz';
-        this.tileSize = 512;
-        this.reparseOverscaled = true;
-        this.isTileClipped = true;
-        this._loaded = false;
-
-        extend(this, pick(options, ['url', 'scheme', 'tileSize', 'promoteId']));
-        this._options = extend({type: 'vector'}, options);
-
-        this._collectResourceTiming = options.collectResourceTiming;
-
-        if (this.tileSize !== 512) {
-            throw new Error('vector tile sources must have a tileSize of 512');
-        }
-
-        this.setEventedParent(eventedParent);
-    }
-
-    load() {
-        this._loaded = false;
-        this.fire(new Event('dataloading', {dataType: 'source'}));
-        this._tileJSONRequest = loadTileJSON(this._options, this.map._requestManager, (err, tileJSON) => {
-            this._tileJSONRequest = null;
-            this._loaded = true;
-            if (err) {
-                this.fire(new ErrorEvent(err));
-            } else if (tileJSON) {
-                extend(this, tileJSON);
-                if (tileJSON.bounds) this.tileBounds = new TileBounds(tileJSON.bounds, this.minzoom, this.maxzoom);
-                postTurnstileEvent(tileJSON.tiles, this.map._requestManager._customAccessToken);
-                postMapLoadEvent(tileJSON.tiles, this.map._getMapId(), this.map._requestManager._skuToken, this.map._requestManager._customAccessToken);
-
-                // `content` is included here to prevent a race condition where `Style#_updateSources` is called
-                // before the TileJSON arrives. this makes sure the tiles needed are loaded once TileJSON arrives
-                // ref: https://github.com/mapbox/mapbox-gl-js/pull/4347#discussion_r104418088
-                this.fire(new Event('data', {dataType: 'source', sourceDataType: 'metadata'}));
-                this.fire(new Event('data', {dataType: 'source', sourceDataType: 'content'}));
-            }
-        });
-    }
-
-    loaded(): boolean {
-        return this._loaded;
-    }
-
-    hasTile(tileID: OverscaledTileID) {
-        return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
-    }
-
-    onAdd(map: Map) {
-        this.map = map;
-        this.load();
-    }
-
-    onRemove() {
-        if (this._tileJSONRequest) {
-            this._tileJSONRequest.cancel();
-            this._tileJSONRequest = null;
-        }
-    }
-
-    serialize() {
-        return extend({}, this._options);
-    }
-
-    loadTile(tile: Tile, callback: Callback<void>) {
-        const url = this.map._requestManager.normalizeTileURL(tile.tileID.canonical.url(this.tiles, this.scheme));
-        const params = {
-            request: this.map._requestManager.transformRequest(url, ResourceType.Tile),
-            uid: tile.uid,
-            tileID: tile.tileID,
-            zoom: tile.tileID.overscaledZ,
-            tileSize: this.tileSize * tile.tileID.overscaleFactor(),
-            type: this.type,
-            source: this.id,
-            pixelRatio: browser.devicePixelRatio,
-            showCollisionBoxes: this.map.showCollisionBoxes,
-            promoteId: this.promoteId
-        };
-        params.request.collectResourceTiming = this._collectResourceTiming;
-
-        if (!tile.actor || tile.state === 'expired') {
-            tile.actor = this.dispatcher.getActor();
-            tile.request = tile.actor.send('loadTile', params, done.bind(this));
-        } else if (tile.state === 'loading') {
-            // schedule tile reloading after it has been loaded
-            tile.reloadCallback = callback;
-        } else {
-            tile.request = tile.actor.send('reloadTile', params, done.bind(this));
-        }
-
-        function done(err, data) {
-            delete tile.request;
-
-            if (tile.aborted)
-                return callback(null);
-
-            if (err && err.status !== 404) {
-                return callback(err);
-            }
-
-            if (data && data.resourceTiming)
-                tile.resourceTiming = data.resourceTiming;
-
-            if (this.map._refreshExpiredTiles && data) tile.setExpiryData(data);
-            tile.loadVectorData(data, this.map.painter);
-
-            cacheEntryPossiblyAdded(this.dispatcher);
-
-            callback(null);
-
-            if (tile.reloadCallback) {
-                this.loadTile(tile, tile.reloadCallback);
-                tile.reloadCallback = null;
-            }
-        }
-    }
-
-    abortTile(tile: Tile) {
-        if (tile.request) {
-            tile.request.cancel();
-            delete tile.request;
-        }
-        if (tile.actor) {
-            tile.actor.send('abortTile', {uid: tile.uid, type: this.type, source: this.id}, undefined);
-        }
-    }
-
-    unloadTile(tile: Tile) {
-        tile.unloadVectorData();
-        if (tile.actor) {
-            tile.actor.send('removeTile', {uid: tile.uid, type: this.type, source: this.id}, undefined);
-        }
-    }
-
-    hasTransition() {
-        return false;
-    }
-}
-
-export default VectorTileSource;

package/src/source/vector_tile_worker_source.js

@@ -1,216 +0,0 @@
-// @flow
-
-import {getArrayBuffer} from '../util/ajax';
-
-import vt from '@mapbox/vector-tile';
-import Protobuf from 'pbf';
-import WorkerTile from './worker_tile';
-import {extend} from '../util/util';
-import {RequestPerformance} from '../util/performance';
-
-import type {
-    WorkerSource,
-    WorkerTileParameters,
-    WorkerTileCallback,
-    TileParameters
-} from '../source/worker_source';
-
-import type Actor from '../util/actor';
-import type StyleLayerIndex from '../style/style_layer_index';
-import type {Callback} from '../types/callback';
-
-export type LoadVectorTileResult = {
-    vectorTile: VectorTile;
-    rawData: ArrayBuffer;
-    expires?: any;
-    cacheControl?: any;
-    resourceTiming?: Array<PerformanceResourceTiming>;
-};
-
-/**
- * @callback LoadVectorDataCallback
- * @param error
- * @param vectorTile
- * @private
- */
-export type LoadVectorDataCallback = Callback<?LoadVectorTileResult>;
-
-export type AbortVectorData = () => void;
-export type LoadVectorData = (params: WorkerTileParameters, callback: LoadVectorDataCallback) => ?AbortVectorData;
-
-/**
- * @private
- */
-function loadVectorTile(params: WorkerTileParameters, callback: LoadVectorDataCallback) {
-    const request = getArrayBuffer(params.request, (err: ?Error, data: ?ArrayBuffer, cacheControl: ?string, expires: ?string) => {
-        if (err) {
-            callback(err);
-        } else if (data) {
-            callback(null, {
-                vectorTile: new vt.VectorTile(new Protobuf(data)),
-                rawData: data,
-                cacheControl,
-                expires
-            });
-        }
-    });
-    return () => {
-        request.cancel();
-        callback();
-    };
-}
-
-/**
- * The {@link WorkerSource} implementation that supports {@link VectorTileSource}.
- * This class is designed to be easily reused to support custom source types
- * for data formats that can be parsed/converted into an in-memory VectorTile
- * representation.  To do so, create it with
- * `new VectorTileWorkerSource(actor, styleLayers, customLoadVectorDataFunction)`.
- *
- * @private
- */
-class VectorTileWorkerSource implements WorkerSource {
-    actor: Actor;
-    layerIndex: StyleLayerIndex;
-    availableImages: Array<string>;
-    loadVectorData: LoadVectorData;
-    loading: {[_: string]: WorkerTile };
-    loaded: {[_: string]: WorkerTile };
-
-    /**
-     * @param [loadVectorData] Optional method for custom loading of a VectorTile
-     * object based on parameters passed from the main-thread Source. See
-     * {@link VectorTileWorkerSource#loadTile}. The default implementation simply
-     * loads the pbf at `params.url`.
-     * @private
-     */
-    constructor(actor: Actor, layerIndex: StyleLayerIndex, availableImages: Array<string>, loadVectorData: ?LoadVectorData) {
-        this.actor = actor;
-        this.layerIndex = layerIndex;
-        this.availableImages = availableImages;
-        this.loadVectorData = loadVectorData || loadVectorTile;
-        this.loading = {};
-        this.loaded = {};
-    }
-
-    /**
-     * Implements {@link WorkerSource#loadTile}. Delegates to
-     * {@link VectorTileWorkerSource#loadVectorData} (which by default expects
-     * a `params.url` property) for fetching and producing a VectorTile object.
-     * @private
-     */
-    loadTile(params: WorkerTileParameters, callback: WorkerTileCallback) {
-        const uid = params.uid;
-
-        if (!this.loading)
-            this.loading = {};
-
-        const perf = (params && params.request && params.request.collectResourceTiming) ?
-            new RequestPerformance(params.request) : false;
-
-        const workerTile = this.loading[uid] = new WorkerTile(params);
-        workerTile.abort = this.loadVectorData(params, (err, response) => {
-            delete this.loading[uid];
-
-            if (err || !response) {
-                workerTile.status = 'done';
-                this.loaded[uid] = workerTile;
-                return callback(err);
-            }
-
-            const rawTileData = response.rawData;
-            const cacheControl = {};
-            if (response.expires) cacheControl.expires = response.expires;
-            if (response.cacheControl) cacheControl.cacheControl = response.cacheControl;
-
-            const resourceTiming = {};
-            if (perf) {
-                const resourceTimingData = perf.finish();
-                // it's necessary to eval the result of getEntriesByName() here via parse/stringify
-                // late evaluation in the main thread causes TypeError: illegal invocation
-                if (resourceTimingData)
-                    resourceTiming.resourceTiming = JSON.parse(JSON.stringify(resourceTimingData));
-            }
-
-            workerTile.vectorTile = response.vectorTile;
-            workerTile.parse(response.vectorTile, this.layerIndex, this.availableImages, this.actor, (err, result) => {
-                if (err || !result) return callback(err);
-
-                // Transferring a copy of rawTileData because the worker needs to retain its copy.
-                callback(null, extend({rawTileData: rawTileData.slice(0)}, result, cacheControl, resourceTiming));
-            });
-
-            this.loaded = this.loaded || {};
-            this.loaded[uid] = workerTile;
-        });
-    }
-
-    /**
-     * Implements {@link WorkerSource#reloadTile}.
-     * @private
-     */
-    reloadTile(params: WorkerTileParameters, callback: WorkerTileCallback) {
-        const loaded = this.loaded,
-            uid = params.uid,
-            vtSource = this;
-        if (loaded && loaded[uid]) {
-            const workerTile = loaded[uid];
-            workerTile.showCollisionBoxes = params.showCollisionBoxes;
-
-            const done = (err, data) => {
-                const reloadCallback = workerTile.reloadCallback;
-                if (reloadCallback) {
-                    delete workerTile.reloadCallback;
-                    workerTile.parse(workerTile.vectorTile, vtSource.layerIndex, this.availableImages, vtSource.actor, reloadCallback);
-                }
-                callback(err, data);
-            };
-
-            if (workerTile.status === 'parsing') {
-                workerTile.reloadCallback = done;
-            } else if (workerTile.status === 'done') {
-                // if there was no vector tile data on the initial load, don't try and re-parse tile
-                if (workerTile.vectorTile) {
-                    workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, done);
-                } else {
-                    done();
-                }
-            }
-        }
-    }
-
-    /**
-     * Implements {@link WorkerSource#abortTile}.
-     *
-     * @param params
-     * @param params.uid The UID for this tile.
-     * @private
-     */
-    abortTile(params: TileParameters, callback: WorkerTileCallback) {
-        const loading = this.loading,
-            uid = params.uid;
-        if (loading && loading[uid] && loading[uid].abort) {
-            loading[uid].abort();
-            delete loading[uid];
-        }
-        callback();
-    }
-
-    /**
-     * Implements {@link WorkerSource#removeTile}.
-     *
-     * @param params
-     * @param params.uid The UID for this tile.
-     * @private
-     */
-    removeTile(params: TileParameters, callback: WorkerTileCallback) {
-        const loaded = this.loaded,
-            uid = params.uid;
-        if (loaded && loaded[uid]) {
-            delete loaded[uid];
-        }
-        callback();
-    }
-}
-
-export default VectorTileWorkerSource;

package/src/source/video_source.js

@@ -1,203 +0,0 @@
-// @flow
-
-import {getVideo, ResourceType} from '../util/ajax';
-
-import ImageSource from './image_source';
-import rasterBoundsAttributes from '../data/raster_bounds_attributes';
-import SegmentVector from '../data/segment';
-import Texture from '../render/texture';
-import {ErrorEvent} from '../util/evented';
-import ValidationError from '../style-spec/error/validation_error';
-
-import type Map from '../ui/map';
-import type Dispatcher from '../util/dispatcher';
-import type {Evented} from '../util/evented';
-import type {VideoSourceSpecification} from '../style-spec/types';
-
-/**
- * A data source containing video.
- * (See the [Style Specification](https://www.mapbox.com/mapbox-gl-style-spec/#sources-video) for detailed documentation of options.)
- *
- * @example
- * // add to map
- * map.addSource('some id', {
- *    type: 'video',
- *    url: [
- *        'https://www.mapbox.com/blog/assets/baltimore-smoke.mp4',
- *        'https://www.mapbox.com/blog/assets/baltimore-smoke.webm'
- *    ],
- *    coordinates: [
- *        [-76.54, 39.18],
- *        [-76.52, 39.18],
- *        [-76.52, 39.17],
- *        [-76.54, 39.17]
- *    ]
- * });
- *
- * // update
- * var mySource = map.getSource('some id');
- * mySource.setCoordinates([
- *     [-76.54335737228394, 39.18579907229748],
- *     [-76.52803659439087, 39.1838364847587],
- *     [-76.5295386314392, 39.17683392507606],
- *     [-76.54520273208618, 39.17876344106642]
- * ]);
- *
- * map.removeSource('some id');  // remove
- * @see [Add a video](https://www.mapbox.com/mapbox-gl-js/example/video-on-a-map/)
- */
-class VideoSource extends ImageSource {
-    options: VideoSourceSpecification;
-    urls: Array<string>;
-    video: HTMLVideoElement;
-    roundZoom: boolean;
-
-    /**
-     * @private
-     */
-    constructor(id: string, options: VideoSourceSpecification, dispatcher: Dispatcher, eventedParent: Evented) {
-        super(id, options, dispatcher, eventedParent);
-        this.roundZoom = true;
-        this.type = 'video';
-        this.options = options;
-    }
-
-    load() {
-        this._loaded = false;
-        const options = this.options;
-
-        this.urls = [];
-        for (const url of options.urls) {
-            this.urls.push(this.map._requestManager.transformRequest(url, ResourceType.Source).url);
-        }
-
-        getVideo(this.urls, (err, video) => {
-            this._loaded = true;
-            if (err) {
-                this.fire(new ErrorEvent(err));
-            } else if (video) {
-                this.video = video;
-                this.video.loop = true;
-
-                // Start repainting when video starts playing. hasTransition() will then return
-                // true to trigger additional frames as long as the videos continues playing.
-                this.video.addEventListener('playing', () => {
-                    this.map.triggerRepaint();
-                });
-
-                if (this.map) {
-                    this.video.play();
-                }
-
-                this._finishLoading();
-            }
-        });
-    }
-
-    /**
-     * Pauses the video.
-     */
-    pause() {
-        if (this.video) {
-            this.video.pause();
-        }
-    }
-
-    /**
-     * Plays the video.
-     */
-    play() {
-        if (this.video) {
-            this.video.play();
-        }
-    }
-
-    /**
-     * Sets playback to a timestamp, in seconds.
-     * @private
-     */
-    seek(seconds: number) {
-        if (this.video) {
-            const seekableRange = this.video.seekable;
-            if (seconds < seekableRange.start(0) || seconds > seekableRange.end(0)) {
-                this.fire(new ErrorEvent(new ValidationError(`sources.${this.id}`, null, `Playback for this video can be set only between the ${seekableRange.start(0)} and ${seekableRange.end(0)}-second mark.`)));
-            } else this.video.currentTime = seconds;
-        }
-    }
-
-    /**
-     * Returns the HTML `video` element.
-     *
-     * @returns {HTMLVideoElement} The HTML `video` element.
-     */
-    getVideo() {
-        return this.video;
-    }
-
-    onAdd(map: Map) {
-        if (this.map) return;
-        this.map = map;
-        this.load();
-        if (this.video) {
-            this.video.play();
-            this.setCoordinates(this.coordinates);
-        }
-    }
-
-    /**
-     * Sets the video's coordinates and re-renders the map.
-     *
-     * @method setCoordinates
-     * @instance
-     * @memberof VideoSource
-     * @returns {VideoSource} this
-     */
-    // setCoordinates inherited from ImageSource
-
-    prepare() {
-        if (Object.keys(this.tiles).length === 0 || this.video.readyState < 2) {
-            return; // not enough data for current position
-        }
-
-        const context = this.map.painter.context;
-        const gl = context.gl;
-
-        if (!this.boundsBuffer) {
-            this.boundsBuffer = context.createVertexBuffer(this._boundsArray, rasterBoundsAttributes.members);
-        }
-
-        if (!this.boundsSegments) {
-            this.boundsSegments = SegmentVector.simpleSegment(0, 0, 4, 2);
-        }
-
-        if (!this.texture) {
-            this.texture = new Texture(context, this.video, gl.RGBA);
-            this.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
-        } else if (!this.video.paused) {
-            this.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
-            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, this.video);
-        }
-
-        for (const w in this.tiles) {
-            const tile = this.tiles[w];
-            if (tile.state !== 'loaded') {
-                tile.state = 'loaded';
-                tile.texture = this.texture;
-            }
-        }
-    }
-
-    serialize() {
-        return {
-            type: 'video',
-            urls: this.urls,
-            coordinates: this.coordinates
-        };
-    }
-
-    hasTransition() {
-        return this.video && !this.video.paused;
-    }
-}
-
-export default VideoSource;