@deck.gl/geo-layers 8.8.4 → 8.8.7

package/typed/tile-layer/tileset-2d.js

@@ -1,399 +0,0 @@
-import Tile2DHeader from './tile-2d-header';
-import { getTileIndices, tileToBoundingBox } from './utils';
-import { RequestScheduler } from '@loaders.gl/loader-utils';
-import { Matrix4 } from '@math.gl/core';
-// bit masks
-const TILE_STATE_VISITED = 1;
-const TILE_STATE_VISIBLE = 2;
-/*
-   show cached parent tile if children are loading
-   +-----------+       +-----+            +-----+-----+
-   |           |       |     |            |     |     |
-   |           |       |     |            |     |     |
-   |           |  -->  +-----+-----+  ->  +-----+-----+
-   |           |             |     |      |     |     |
-   |           |             |     |      |     |     |
-   +-----------+             +-----+      +-----+-----+
-
-   show cached children tiles when parent is loading
-   +-------+----       +------------
-   |       |           |
-   |       |           |
-   |       |           |
-   +-------+----  -->  |
-   |       |           |
- */
-export const STRATEGY_NEVER = 'never';
-export const STRATEGY_REPLACE = 'no-overlap';
-export const STRATEGY_DEFAULT = 'best-available';
-const DEFAULT_CACHE_SCALE = 5;
-const STRATEGIES = {
-    [STRATEGY_DEFAULT]: updateTileStateDefault,
-    [STRATEGY_REPLACE]: updateTileStateReplace,
-    [STRATEGY_NEVER]: () => { }
-};
-/**
- * Manages loading and purging of tile data. This class caches recently visited tiles
- * and only creates new tiles if they are present.
- */
-export default class Tileset2D {
-    /**
-     * Takes in a function that returns tile data, a cache size, and a max and a min zoom level.
-     * Cache size defaults to 5 * number of tiles in the current viewport
-     */
-    constructor(opts) {
-        this.opts = opts;
-        this.onTileLoad = tile => {
-            this.opts.onTileLoad(tile);
-            if (this.opts.maxCacheByteSize) {
-                this._cacheByteSize += tile.byteLength;
-                this._resizeCache();
-            }
-        };
-        this._requestScheduler = new RequestScheduler({
-            maxRequests: opts.maxRequests,
-            throttleRequests: opts.maxRequests > 0
-        });
-        // Maps tile id in string {z}-{x}-{y} to a Tile object
-        this._cache = new Map();
-        this._tiles = [];
-        this._dirty = false;
-        this._cacheByteSize = 0;
-        // Cache the last processed viewport
-        this._viewport = null;
-        this._selectedTiles = null;
-        this._frameNumber = 0;
-        this._modelMatrix = new Matrix4();
-        this._modelMatrixInverse = new Matrix4();
-        this.setOptions(opts);
-    }
-    /* Public API */
-    get tiles() {
-        return this._tiles;
-    }
-    get selectedTiles() {
-        return this._selectedTiles;
-    }
-    get isLoaded() {
-        return this._selectedTiles !== null && this._selectedTiles.every(tile => tile.isLoaded);
-    }
-    get needsReload() {
-        return this._selectedTiles !== null && this._selectedTiles.some(tile => tile.needsReload);
-    }
-    setOptions(opts) {
-        Object.assign(this.opts, opts);
-        if (Number.isFinite(opts.maxZoom)) {
-            this._maxZoom = Math.floor(opts.maxZoom);
-        }
-        if (Number.isFinite(opts.minZoom)) {
-            this._minZoom = Math.ceil(opts.minZoom);
-        }
-    }
-    // Clean up any outstanding tile requests.
-    finalize() {
-        for (const tile of this._cache.values()) {
-            if (tile.isLoading) {
-                tile.abort();
-            }
-        }
-        this._cache.clear();
-        this._tiles = [];
-        this._selectedTiles = null;
-    }
-    reloadAll() {
-        for (const id of this._cache.keys()) {
-            const tile = this._cache.get(id);
-            if (!this._selectedTiles || !this._selectedTiles.includes(tile)) {
-                this._cache.delete(id);
-            }
-            else {
-                tile.setNeedsReload();
-            }
-        }
-    }
-    /**
-     * Update the cache with the given viewport and model matrix and triggers callback onUpdate.
-     */
-    update(viewport, { zRange, modelMatrix } = {}) {
-        const modelMatrixAsMatrix4 = new Matrix4(modelMatrix);
-        const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
-        if (!this._viewport || !viewport.equals(this._viewport) || isModelMatrixNew) {
-            if (isModelMatrixNew) {
-                this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert();
-                this._modelMatrix = modelMatrixAsMatrix4;
-            }
-            this._viewport = viewport;
-            const tileIndices = this.getTileIndices({
-                viewport,
-                maxZoom: this._maxZoom,
-                minZoom: this._minZoom,
-                zRange,
-                modelMatrix: this._modelMatrix,
-                modelMatrixInverse: this._modelMatrixInverse
-            });
-            this._selectedTiles = tileIndices.map(index => this._getTile(index, true));
-            if (this._dirty) {
-                // Some new tiles are added
-                this._rebuildTree();
-            }
-            // Check for needed reloads explicitly even if the view/matrix has not changed.
-        }
-        else if (this.needsReload) {
-            this._selectedTiles = this._selectedTiles.map(tile => this._getTile(tile.index, true));
-        }
-        // Update tile states
-        const changed = this.updateTileStates();
-        this._pruneRequests();
-        if (this._dirty) {
-            // cache size is either the user defined maxSize or 5 * number of current tiles in the viewport.
-            this._resizeCache();
-        }
-        if (changed) {
-            this._frameNumber++;
-        }
-        return this._frameNumber;
-    }
-    /* Public interface for subclassing */
-    /** Returns array of tile indices in the current viewport */
-    getTileIndices({ viewport, maxZoom, minZoom, zRange, modelMatrix, modelMatrixInverse }) {
-        const { tileSize, extent, zoomOffset } = this.opts;
-        return getTileIndices({
-            viewport,
-            maxZoom,
-            minZoom,
-            zRange,
-            tileSize,
-            extent: extent,
-            modelMatrix,
-            modelMatrixInverse,
-            zoomOffset
-        });
-    }
-    /** Returns unique string key for a tile index */
-    getTileId(index) {
-        return `${index.x}-${index.y}-${index.z}`;
-    }
-    /** Returns a zoom level for a tile index */
-    getTileZoom(index) {
-        return index.z;
-    }
-    /** Returns additional metadata to add to tile, bbox by default */
-    getTileMetadata(index) {
-        const { tileSize } = this.opts;
-        // @ts-expect-error
-        return { bbox: tileToBoundingBox(this._viewport, index.x, index.y, index.z, tileSize) };
-    }
-    /** Returns index of the parent tile */
-    getParentIndex(index) {
-        const x = Math.floor(index.x / 2);
-        const y = Math.floor(index.y / 2);
-        const z = index.z - 1;
-        return { x, y, z };
-    }
-    // Returns true if any tile's visibility changed
-    updateTileStates() {
-        const refinementStrategy = this.opts.refinementStrategy || STRATEGY_DEFAULT;
-        const visibilities = new Array(this._cache.size);
-        let i = 0;
-        // Reset state
-        for (const tile of this._cache.values()) {
-            // save previous state
-            visibilities[i++] = tile.isVisible;
-            tile.isSelected = false;
-            tile.isVisible = false;
-        }
-        // @ts-expect-error called only when _selectedTiles is already defined
-        for (const tile of this._selectedTiles) {
-            tile.isSelected = true;
-            tile.isVisible = true;
-        }
-        // Strategy-specific state logic
-        (typeof refinementStrategy === 'function'
-            ? refinementStrategy
-            : STRATEGIES[refinementStrategy])(Array.from(this._cache.values()));
-        i = 0;
-        // Check if any visibility has changed
-        for (const tile of this._cache.values()) {
-            if (visibilities[i++] !== tile.isVisible) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /* Private methods */
-    _pruneRequests() {
-        const { maxRequests } = this.opts;
-        const abortCandidates = [];
-        let ongoingRequestCount = 0;
-        for (const tile of this._cache.values()) {
-            // Keep track of all the ongoing requests
-            if (tile.isLoading) {
-                ongoingRequestCount++;
-                if (!tile.isSelected && !tile.isVisible) {
-                    abortCandidates.push(tile);
-                }
-            }
-        }
-        while (maxRequests > 0 && ongoingRequestCount > maxRequests && abortCandidates.length > 0) {
-            // There are too many ongoing requests, so abort some that are unselected
-            const tile = abortCandidates.shift();
-            tile.abort();
-            ongoingRequestCount--;
-        }
-    }
-    // This needs to be called every time some tiles have been added/removed from cache
-    _rebuildTree() {
-        const { _cache } = this;
-        // Reset states
-        for (const tile of _cache.values()) {
-            tile.parent = null;
-            if (tile.children) {
-                tile.children.length = 0;
-            }
-        }
-        // Rebuild tree
-        for (const tile of _cache.values()) {
-            const parent = this._getNearestAncestor(tile);
-            tile.parent = parent;
-            if (parent?.children) {
-                parent.children.push(tile);
-            }
-        }
-    }
-    /**
-     * Clear tiles that are not visible when the cache is full
-     */
-    /* eslint-disable complexity */
-    _resizeCache() {
-        const { _cache, opts } = this;
-        const maxCacheSize = opts.maxCacheSize ||
-            // @ts-expect-error called only when selectedTiles is initialized
-            (opts.maxCacheByteSize ? Infinity : DEFAULT_CACHE_SCALE * this.selectedTiles.length);
-        const maxCacheByteSize = opts.maxCacheByteSize || Infinity;
-        const overflown = _cache.size > maxCacheSize || this._cacheByteSize > maxCacheByteSize;
-        if (overflown) {
-            for (const [id, tile] of _cache) {
-                if (!tile.isVisible) {
-                    // delete tile
-                    this._cacheByteSize -= opts.maxCacheByteSize ? tile.byteLength : 0;
-                    _cache.delete(id);
-                    this.opts.onTileUnload(tile);
-                }
-                if (_cache.size <= maxCacheSize && this._cacheByteSize <= maxCacheByteSize) {
-                    break;
-                }
-            }
-            this._rebuildTree();
-            this._dirty = true;
-        }
-        if (this._dirty) {
-            // sort by zoom level so that smaller tiles are displayed on top
-            this._tiles = Array.from(this._cache.values()).sort((t1, t2) => t1.zoom - t2.zoom);
-            this._dirty = false;
-        }
-    }
-    _getTile(index, create) {
-        const id = this.getTileId(index);
-        let tile = this._cache.get(id);
-        let needsReload = false;
-        if (!tile && create) {
-            tile = new Tile2DHeader(index);
-            Object.assign(tile, this.getTileMetadata(tile.index));
-            Object.assign(tile, { id, zoom: this.getTileZoom(tile.index) });
-            needsReload = true;
-            this._cache.set(id, tile);
-            this._dirty = true;
-        }
-        else if (tile && tile.needsReload) {
-            needsReload = true;
-        }
-        if (tile && needsReload) {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            tile.loadData({
-                getData: this.opts.getTileData,
-                requestScheduler: this._requestScheduler,
-                onLoad: this.onTileLoad,
-                onError: this.opts.onTileError
-            });
-        }
-        return tile;
-    }
-    _getNearestAncestor(tile) {
-        const { _minZoom = 0 } = this;
-        let index = tile.index;
-        while (this.getTileZoom(index) > _minZoom) {
-            index = this.getParentIndex(index);
-            const parent = this._getTile(index);
-            if (parent) {
-                return parent;
-            }
-        }
-        return null;
-    }
-}
-/* -- Refinement strategies --*/
-/* eslint-disable max-depth */
-// For all the selected && pending tiles:
-// - pick the closest ancestor as placeholder
-// - if no ancestor is visible, pick the closest children as placeholder
-function updateTileStateDefault(allTiles) {
-    for (const tile of allTiles) {
-        tile.state = 0;
-    }
-    for (const tile of allTiles) {
-        if (tile.isSelected && !getPlaceholderInAncestors(tile)) {
-            getPlaceholderInChildren(tile);
-        }
-    }
-    for (const tile of allTiles) {
-        tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE);
-    }
-}
-// Until a selected tile and all its selected siblings are loaded, use the closest ancestor as placeholder
-function updateTileStateReplace(allTiles) {
-    for (const tile of allTiles) {
-        tile.state = 0;
-    }
-    for (const tile of allTiles) {
-        if (tile.isSelected) {
-            getPlaceholderInAncestors(tile);
-        }
-    }
-    // Always process parents first
-    const sortedTiles = Array.from(allTiles).sort((t1, t2) => t1.zoom - t2.zoom);
-    for (const tile of sortedTiles) {
-        tile.isVisible = Boolean(tile.state & TILE_STATE_VISIBLE);
-        if (tile.children && (tile.isVisible || tile.state & TILE_STATE_VISITED)) {
-            // If the tile is rendered, or if the tile has been explicitly hidden, hide all of its children
-            for (const child of tile.children) {
-                child.state = TILE_STATE_VISITED;
-            }
-        }
-        else if (tile.isSelected) {
-            getPlaceholderInChildren(tile);
-        }
-    }
-}
-// Walk up the tree until we find one ancestor that is loaded. Returns true if successful.
-function getPlaceholderInAncestors(startTile) {
-    let tile = startTile;
-    while (tile) {
-        if (tile.isLoaded || tile.content) {
-            tile.state |= TILE_STATE_VISIBLE;
-            return true;
-        }
-        tile = tile.parent;
-    }
-    return false;
-}
-// Recursively set children as placeholder
-function getPlaceholderInChildren(tile) {
-    for (const child of tile.children) {
-        if (child.isLoaded || child.content) {
-            child.state |= TILE_STATE_VISIBLE;
-        }
-        else {
-            getPlaceholderInChildren(child);
-        }
-    }
-}

package/typed/tile-layer/types.js

@@ -1 +0,0 @@
-export {};

package/typed/tile-layer/utils.js

@@ -1,197 +0,0 @@
-import { getOSMTileIndices } from './tile-2d-traversal';
-const TILE_SIZE = 512;
-const DEFAULT_EXTENT = [-Infinity, -Infinity, Infinity, Infinity];
-export const urlType = {
-    type: 'url',
-    value: null,
-    validate: (value, propType) => (propType.optional && value === null) ||
-        typeof value === 'string' ||
-        (Array.isArray(value) && value.every(url => typeof url === 'string')),
-    equals: (value1, value2) => {
-        if (value1 === value2) {
-            return true;
-        }
-        if (!Array.isArray(value1) || !Array.isArray(value2)) {
-            return false;
-        }
-        const len = value1.length;
-        if (len !== value2.length) {
-            return false;
-        }
-        for (let i = 0; i < len; i++) {
-            if (value1[i] !== value2[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-};
-function transformBox(bbox, modelMatrix) {
-    const transformedCoords = [
-        // top-left
-        modelMatrix.transformAsPoint([bbox[0], bbox[1]]),
-        // top-right
-        modelMatrix.transformAsPoint([bbox[2], bbox[1]]),
-        // bottom-left
-        modelMatrix.transformAsPoint([bbox[0], bbox[3]]),
-        // bottom-right
-        modelMatrix.transformAsPoint([bbox[2], bbox[3]])
-    ];
-    const transformedBox = [
-        // Minimum x coord
-        Math.min(...transformedCoords.map(i => i[0])),
-        // Minimum y coord
-        Math.min(...transformedCoords.map(i => i[1])),
-        // Max x coord
-        Math.max(...transformedCoords.map(i => i[0])),
-        // Max y coord
-        Math.max(...transformedCoords.map(i => i[1]))
-    ];
-    return transformedBox;
-}
-function stringHash(s) {
-    return Math.abs(s.split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0));
-}
-export function getURLFromTemplate(template, tile) {
-    if (!template || !template.length) {
-        return null;
-    }
-    const { index, id } = tile;
-    if (Array.isArray(template)) {
-        const i = stringHash(id) % template.length;
-        template = template[i];
-    }
-    let url = template;
-    for (const key of Object.keys(index)) {
-        const regex = new RegExp(`{${key}}`, 'g');
-        url = url.replace(regex, String(index[key]));
-    }
-    // Back-compatible support for {-y}
-    if (Number.isInteger(index.y) && Number.isInteger(index.z)) {
-        url = url.replace(/\{-y\}/g, String(Math.pow(2, index.z) - index.y - 1));
-    }
-    return url;
-}
-/**
- * gets the bounding box of a viewport
- */
-function getBoundingBox(viewport, zRange, extent) {
-    let bounds;
-    if (zRange && zRange.length === 2) {
-        const [minZ, maxZ] = zRange;
-        const bounds0 = viewport.getBounds({ z: minZ });
-        const bounds1 = viewport.getBounds({ z: maxZ });
-        bounds = [
-            Math.min(bounds0[0], bounds1[0]),
-            Math.min(bounds0[1], bounds1[1]),
-            Math.max(bounds0[2], bounds1[2]),
-            Math.max(bounds0[3], bounds1[3])
-        ];
-    }
-    else {
-        bounds = viewport.getBounds();
-    }
-    if (!viewport.isGeospatial) {
-        return [
-            // Top corner should not be more then bottom corner in either direction
-            Math.max(Math.min(bounds[0], extent[2]), extent[0]),
-            Math.max(Math.min(bounds[1], extent[3]), extent[1]),
-            // Bottom corner should not be less then top corner in either direction
-            Math.min(Math.max(bounds[2], extent[0]), extent[2]),
-            Math.min(Math.max(bounds[3], extent[1]), extent[3])
-        ];
-    }
-    return [
-        Math.max(bounds[0], extent[0]),
-        Math.max(bounds[1], extent[1]),
-        Math.min(bounds[2], extent[2]),
-        Math.min(bounds[3], extent[3])
-    ];
-}
-function getIndexingCoords(bbox, scale, modelMatrixInverse) {
-    if (modelMatrixInverse) {
-        const transformedTileIndex = transformBox(bbox, modelMatrixInverse).map(i => (i * scale) / TILE_SIZE);
-        return transformedTileIndex;
-    }
-    return bbox.map(i => (i * scale) / TILE_SIZE);
-}
-function getScale(z, tileSize) {
-    return (Math.pow(2, z) * TILE_SIZE) / tileSize;
-}
-// https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Lon..2Flat._to_tile_numbers_2
-export function osmTile2lngLat(x, y, z) {
-    const scale = getScale(z, TILE_SIZE);
-    const lng = (x / scale) * 360 - 180;
-    const n = Math.PI - (2 * Math.PI * y) / scale;
-    const lat = (180 / Math.PI) * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
-    return [lng, lat];
-}
-function tile2XY(x, y, z, tileSize) {
-    const scale = getScale(z, tileSize);
-    return [(x / scale) * TILE_SIZE, (y / scale) * TILE_SIZE];
-}
-export function tileToBoundingBox(viewport, x, y, z, tileSize = TILE_SIZE) {
-    if (viewport.isGeospatial) {
-        const [west, north] = osmTile2lngLat(x, y, z);
-        const [east, south] = osmTile2lngLat(x + 1, y + 1, z);
-        return { west, north, east, south };
-    }
-    const [left, top] = tile2XY(x, y, z, tileSize);
-    const [right, bottom] = tile2XY(x + 1, y + 1, z, tileSize);
-    return { left, top, right, bottom };
-}
-function getIdentityTileIndices(viewport, z, tileSize, extent, modelMatrixInverse) {
-    const bbox = getBoundingBox(viewport, null, extent);
-    const scale = getScale(z, tileSize);
-    const [minX, minY, maxX, maxY] = getIndexingCoords(bbox, scale, modelMatrixInverse);
-    const indices = [];
-    /*
-        |  TILE  |  TILE  |  TILE  |
-          |(minX)            |(maxX)
-     */
-    for (let x = Math.floor(minX); x < maxX; x++) {
-        for (let y = Math.floor(minY); y < maxY; y++) {
-            indices.push({ x, y, z });
-        }
-    }
-    return indices;
-}
-/**
- * Returns all tile indices in the current viewport. If the current zoom level is smaller
- * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
- * return tiles that are on maxZoom.
- */
-// eslint-disable-next-line complexity
-export function getTileIndices({ viewport, maxZoom, minZoom, zRange, extent, tileSize = TILE_SIZE, modelMatrix, modelMatrixInverse, zoomOffset = 0 }) {
-    let z = viewport.isGeospatial
-        ? Math.round(viewport.zoom + Math.log2(TILE_SIZE / tileSize)) + zoomOffset
-        : Math.ceil(viewport.zoom) + zoomOffset;
-    if (typeof minZoom === 'number' && Number.isFinite(minZoom) && z < minZoom) {
-        if (!extent) {
-            return [];
-        }
-        z = minZoom;
-    }
-    if (typeof maxZoom === 'number' && Number.isFinite(maxZoom) && z > maxZoom) {
-        z = maxZoom;
-    }
-    let transformedExtent = extent;
-    if (modelMatrix && modelMatrixInverse && extent && !viewport.isGeospatial) {
-        transformedExtent = transformBox(extent, modelMatrix);
-    }
-    return viewport.isGeospatial
-        ? getOSMTileIndices(viewport, z, zRange, extent)
-        : getIdentityTileIndices(viewport, z, tileSize, transformedExtent || DEFAULT_EXTENT, modelMatrixInverse);
-}
-/**
- * Returns true if s is a valid URL template
- */
-export function isURLTemplate(s) {
-    return /(?=.*{z})(?=.*{x})(?=.*({y}|{-y}))/.test(s);
-}
-export function isGeoBoundingBox(v) {
-    return (Number.isFinite(v.west) &&
-        Number.isFinite(v.north) &&
-        Number.isFinite(v.east) &&
-        Number.isFinite(v.south));
-}

package/typed/trips-layer/trips-layer.js

@@ -1,92 +0,0 @@
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-import { PathLayer } from '@deck.gl/layers';
-const defaultProps = {
-    fadeTrail: true,
-    trailLength: { type: 'number', value: 120, min: 0 },
-    currentTime: { type: 'number', value: 0, min: 0 },
-    getTimestamps: { type: 'accessor', value: null }
-};
-export default class TripsLayer extends PathLayer {
-    getShaders() {
-        const shaders = super.getShaders();
-        shaders.inject = {
-            'vs:#decl': `\
-uniform float trailLength;
-attribute float instanceTimestamps;
-attribute float instanceNextTimestamps;
-varying float vTime;
-`,
-            // Timestamp of the vertex
-            'vs:#main-end': `\
-vTime = instanceTimestamps + (instanceNextTimestamps - instanceTimestamps) * vPathPosition.y / vPathLength;
-`,
-            'fs:#decl': `\
-uniform bool fadeTrail;
-uniform float trailLength;
-uniform float currentTime;
-varying float vTime;
-`,
-            // Drop the segments outside of the time window
-            'fs:#main-start': `\
-if(vTime > currentTime || (fadeTrail && (vTime < currentTime - trailLength))) {
-  discard;
-}
-`,
-            // Fade the color (currentTime - 100%, end of trail - 0%)
-            'fs:DECKGL_FILTER_COLOR': `\
-if(fadeTrail) {
-  color.a *= 1.0 - (currentTime - vTime) / trailLength;
-}
-`
-        };
-        return shaders;
-    }
-    initializeState() {
-        super.initializeState();
-        const attributeManager = this.getAttributeManager();
-        attributeManager.addInstanced({
-            timestamps: {
-                size: 1,
-                accessor: 'getTimestamps',
-                shaderAttributes: {
-                    instanceTimestamps: {
-                        vertexOffset: 0
-                    },
-                    instanceNextTimestamps: {
-                        vertexOffset: 1
-                    }
-                }
-            }
-        });
-    }
-    draw(params) {
-        const { fadeTrail, trailLength, currentTime } = this.props;
-        params.uniforms = {
-            ...params.uniforms,
-            fadeTrail,
-            trailLength,
-            currentTime
-        };
-        super.draw(params);
-    }
-}
-TripsLayer.layerName = 'TripsLayer';
-TripsLayer.defaultProps = defaultProps;