@deck.gl/carto 8.9.4 → 8.9.5

package/typed/layers/carto-layer.js

@@ -1,173 +0,0 @@
-import { CompositeLayer, log } from '@deck.gl/core';
-import CartoTileLayer from './carto-tile-layer';
-import H3TileLayer from './h3-tile-layer';
-import QuadkeyTileLayer from './quadkey-tile-layer';
-import { MVTLayer } from '@deck.gl/geo-layers';
-import { GeoJsonLayer } from '@deck.gl/layers';
-import { fetchLayerData, getDataV2, API_VERSIONS } from '../api';
-import { COLUMNS_SUPPORT, FORMATS, GEO_COLUMN_SUPPORT, MAP_TYPES, TILE_FORMATS } from '../api/maps-api-common';
-import { getDefaultCredentials } from '../config';
-import { assert } from '../utils';
-const defaultProps = {
-    // (String, required): data resource to load. table name, sql query or tileset name.
-    data: null,
-    // (Enum (MAP_TYPES), required)
-    type: null,
-    onDataLoad: { type: 'function', value: data => { }, compare: false },
-    onDataError: { type: 'function', value: null, compare: false, optional: true },
-    uniqueIdProperty: 'cartodb_id',
-    // override carto credentials for the layer, set to null to read from default
-    credentials: null,
-    /*********************/
-    /* API v3 PARAMETERS */
-    /**********************/
-    // (String, required): connection name at CARTO platform
-    connection: null,
-    // (String, optional): format of data
-    format: null,
-    // (String, optional): force format of data for tiles
-    formatTiles: null,
-    // (String, optional): clientId identifier used for internal tracing, place here a string to identify the client who is doing the request.
-    clientId: null,
-    // (String, optional): name of the `geo_column` in the CARTO platform. Use this override the default column ('geom'), from which the geometry information should be fetched.
-    geoColumn: null,
-    // (Array<String>, optional): names of columns to fetch. By default, all columns are fetched.
-    columns: { type: 'array', value: null },
-    // (String, optional): aggregration SQL expression. Only used for spatial index datasets
-    aggregationExp: null,
-    // (Number, optional): aggregration resolution level. Only used for spatial index datasets, defaults to 6 for quadkeys, 4 for h3
-    aggregationResLevel: null
-};
-export default class CartoLayer extends CompositeLayer {
-    initializeState() {
-        this.state = {
-            data: null,
-            apiVersion: null
-        };
-    }
-    get isLoaded() {
-        return this.getSubLayers().length > 0 && super.isLoaded;
-    }
-    _checkProps(props) {
-        const { type, credentials, connection, geoColumn, columns } = props;
-        const localCreds = { ...getDefaultCredentials(), ...credentials };
-        const { apiVersion } = localCreds;
-        log.assert(Object.values(API_VERSIONS).includes(apiVersion), `Invalid apiVersion ${apiVersion}. Use API_VERSIONS enum.`);
-        if (apiVersion === API_VERSIONS.V1 || apiVersion === API_VERSIONS.V2) {
-            log.assert(type === MAP_TYPES.QUERY || type === MAP_TYPES.TILESET, `Invalid type ${type}. Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ${apiVersion}`);
-            log.assert(!connection, `Connection prop is not supported for apiVersion ${apiVersion}`);
-            log.assert(!geoColumn, `geoColumn prop is not supported for apiVersion ${apiVersion}`);
-            log.assert(!columns, `columns prop is not supported for apiVersion ${apiVersion}`);
-        }
-        else if (apiVersion === API_VERSIONS.V3) {
-            log.assert(connection, 'Missing mandatory connection parameter');
-            log.assert(Object.values(MAP_TYPES).includes(type), `Invalid type ${type}. Use MAP_TYPES enum.`);
-            if (!COLUMNS_SUPPORT.includes(type)) {
-                log.assert(!columns, `columns prop is only supported for types: ${COLUMNS_SUPPORT.join()}`);
-            }
-            if (!GEO_COLUMN_SUPPORT.includes(type)) {
-                log.assert(!geoColumn, `geoColumn prop is only supported for types: ${GEO_COLUMN_SUPPORT.join()}`);
-            }
-            if (columns) {
-                log.assert(Array.isArray(columns), 'columns prop must be an Array');
-            }
-        }
-    }
-    updateState({ props, oldProps, changeFlags }) {
-        this._checkProps(props);
-        const shouldUpdateData = changeFlags.dataChanged ||
-            props.connection !== oldProps.connection ||
-            props.geoColumn !== oldProps.geoColumn ||
-            props.format !== oldProps.format ||
-            props.formatTiles !== oldProps.formatTiles ||
-            props.type !== oldProps.type ||
-            JSON.stringify(props.columns) !== JSON.stringify(oldProps.columns) ||
-            JSON.stringify(props.credentials) !== JSON.stringify(oldProps.credentials);
-        if (shouldUpdateData) {
-            this.setState({ data: null, apiVersion: null });
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this._updateData();
-        }
-    }
-    async _updateData() {
-        try {
-            const { type, data: source, clientId, credentials, connection, ...rest } = this.props;
-            const localConfig = { ...getDefaultCredentials(), ...credentials };
-            const { apiVersion } = localConfig;
-            let result;
-            if (apiVersion === API_VERSIONS.V1 || apiVersion === API_VERSIONS.V2) {
-                result = {
-                    data: await getDataV2({ type, source, credentials: credentials })
-                };
-            }
-            else {
-                result = await fetchLayerData({
-                    type,
-                    source,
-                    clientId,
-                    credentials: credentials,
-                    connection,
-                    ...rest
-                });
-            }
-            this.setState({ ...result, apiVersion });
-            this.props.onDataLoad?.(result.data, {
-                propName: 'data',
-                layer: this
-            });
-        }
-        catch (err) {
-            if (this.props.onDataError) {
-                this.props.onDataError(err);
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    _getSubLayerAndProps() {
-        assert(this.state);
-        const { data, format, apiVersion } = this.state;
-        const { uniqueIdProperty } = defaultProps;
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { data: _notUsed, ...propsNoData } = this.props;
-        // @ts-expect-error 'uniqueIdProperty' is specified more than once, so this usage will be overwritten.
-        const props = { uniqueIdProperty, ...propsNoData };
-        if (apiVersion === API_VERSIONS.V1 || apiVersion === API_VERSIONS.V2) {
-            return [MVTLayer, props];
-        }
-        if (format === FORMATS.TILEJSON) {
-            /* global URL */
-            const tileUrl = new URL(data.tiles[0]);
-            props.formatTiles =
-                props.formatTiles ||
-                    tileUrl.searchParams.get('formatTiles') ||
-                    TILE_FORMATS.MVT;
-            if (data.scheme === 'h3') {
-                return [H3TileLayer, props];
-            }
-            if (data.scheme === 'quadkey') {
-                return [QuadkeyTileLayer, props];
-            }
-            return props.formatTiles === TILE_FORMATS.MVT ? [MVTLayer, props] : [CartoTileLayer, props];
-        }
-        // It's a geojson layer
-        return [GeoJsonLayer, props];
-    }
-    renderLayers() {
-        assert(this.state);
-        const { data } = this.state;
-        if (!data)
-            return null;
-        const { updateTriggers } = this.props;
-        const [layer, props] = this._getSubLayerAndProps();
-        // eslint-disable-next-line new-cap
-        return new layer(props, this.getSubLayerProps({
-            id: `carto-${layer.layerName}`,
-            data,
-            updateTriggers
-        }));
-    }
-}
-CartoLayer.layerName = 'CartoLayer';
-CartoLayer.defaultProps = defaultProps;

package/typed/layers/carto-tile-layer.js

@@ -1,105 +0,0 @@
-/* global TextDecoder */
-import Protobuf from 'pbf';
-import { log } from '@deck.gl/core';
-import { ClipExtension } from '@deck.gl/extensions';
-import { MVTLayer, _getURLFromTemplate } from '@deck.gl/geo-layers';
-import { GeoJsonLayer } from '@deck.gl/layers';
-import { geojsonToBinary } from '@loaders.gl/gis';
-import { TileReader } from './schema/carto-tile';
-import { TILE_FORMATS } from '../api/maps-api-common';
-function parseJSON(arrayBuffer) {
-    return JSON.parse(new TextDecoder().decode(arrayBuffer));
-}
-function parsePbf(buffer) {
-    const pbf = new Protobuf(buffer);
-    const tile = TileReader.read(pbf);
-    return tile;
-}
-function unpackProperties(properties) {
-    if (!properties || !properties.length) {
-        return [];
-    }
-    return properties.map(item => {
-        const currentRecord = {};
-        item.data.forEach(({ key, value }) => {
-            currentRecord[key] = value;
-        });
-        return currentRecord;
-    });
-}
-function parseCartoTile(arrayBuffer, options) {
-    if (!arrayBuffer)
-        return null;
-    const formatTiles = options && options.cartoTile && options.cartoTile.formatTiles;
-    if (formatTiles === TILE_FORMATS.GEOJSON)
-        return geojsonToBinary(parseJSON(arrayBuffer).features);
-    const tile = parsePbf(arrayBuffer);
-    const { points, lines, polygons } = tile;
-    const data = {
-        points: { ...points, properties: unpackProperties(points.properties) },
-        lines: { ...lines, properties: unpackProperties(lines.properties) },
-        polygons: { ...polygons, properties: unpackProperties(polygons.properties) }
-    };
-    // Note: there is slight, difference in `numericProps` type, however geojson/mvtlayer can cope with this
-    return data;
-}
-const defaultTileFormat = TILE_FORMATS.BINARY;
-const CartoTileLoader = {
-    name: 'CARTO Tile',
-    version: '1',
-    id: 'cartoTile',
-    module: 'carto',
-    extensions: ['pbf'],
-    mimeTypes: ['application/x-protobuf'],
-    category: 'geometry',
-    worker: false,
-    parse: async (arrayBuffer, options) => parseCartoTile(arrayBuffer, options),
-    parseSync: parseCartoTile,
-    options: {
-        cartoTile: {
-            formatTiles: defaultTileFormat
-        }
-    }
-};
-const defaultProps = {
-    ...MVTLayer.defaultProps,
-    formatTiles: defaultTileFormat,
-    loaders: [CartoTileLoader]
-};
-export default class CartoTileLayer extends MVTLayer {
-    getTileData(tile) {
-        const url = _getURLFromTemplate(this.state.data, tile);
-        if (!url) {
-            return Promise.reject('Invalid URL');
-        }
-        let loadOptions = this.getLoadOptions();
-        const { fetch, formatTiles } = this.props;
-        const { signal } = tile;
-        loadOptions = {
-            ...loadOptions,
-            mimeType: 'application/x-protobuf'
-        };
-        if (formatTiles) {
-            log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
-            loadOptions.cartoTile = { formatTiles };
-        }
-        return fetch(url, { propName: 'data', layer: this, loadOptions, signal });
-    }
-    renderSubLayers(props) {
-        if (props.data === null) {
-            return null;
-        }
-        const tileBbox = props.tile.bbox;
-        const { west, south, east, north } = tileBbox;
-        const subLayerProps = {
-            ...props,
-            autoHighlight: false,
-            extensions: [new ClipExtension(), ...(props.extensions || [])],
-            clipBounds: [west, south, east, north]
-        };
-        const subLayer = new GeoJsonLayer(subLayerProps);
-        return subLayer;
-    }
-}
-CartoTileLayer.layerName = 'CartoTileLayer';
-CartoTileLayer.defaultProps = defaultProps;

package/typed/layers/h3-tile-layer.js

@@ -1,47 +0,0 @@
-import { CompositeLayer } from '@deck.gl/core';
-import { H3HexagonLayer } from '@deck.gl/geo-layers';
-import H3Tileset2D from './h3-tileset-2d';
-import SpatialIndexTileLayer from './spatial-index-tile-layer';
-const renderSubLayers = props => {
-    const { data } = props;
-    const { index } = props.tile;
-    if (!data || !data.length)
-        return null;
-    return new H3HexagonLayer(props, {
-        getHexagon: d => d.id,
-        centerHexagon: index,
-        highPrecision: true
-    });
-};
-const defaultProps = {
-    aggregationResLevel: 4
-};
-export default class H3TileLayer extends CompositeLayer {
-    initializeState() {
-        this.setState({ data: null, tileJSON: null });
-    }
-    updateState({ changeFlags }) {
-        if (changeFlags.dataChanged) {
-            let { data } = this.props;
-            const tileJSON = data;
-            data = tileJSON.tiles;
-            this.setState({ data, tileJSON });
-        }
-    }
-    renderLayers() {
-        const { data, tileJSON } = this.state;
-        const maxZoom = parseInt(tileJSON.maxresolution);
-        return [
-            new SpatialIndexTileLayer(this.props, {
-                id: `h3-tile-layer-${this.props.id}`,
-                data,
-                // @ts-expect-error Tileset2D should be generic over TileIndex
-                TilesetClass: H3Tileset2D,
-                renderSubLayers,
-                maxZoom
-            })
-        ];
-    }
-}
-H3TileLayer.layerName = 'H3TileLayer';
-H3TileLayer.defaultProps = defaultProps;

package/typed/layers/h3-tileset-2d.js

@@ -1,85 +0,0 @@
-import { _Tileset2D as Tileset2D } from '@deck.gl/geo-layers';
-import { polyfill, geoToH3, h3GetResolution, h3ToGeoBoundary, h3ToParent, kRing } from 'h3-js';
-function getHexagonsInBoundingBox({ west, north, east, south }, resolution) {
-    if (Math.abs(east - west) > 180) {
-        // This is a known issue in h3-js: polyfill does not work correctly
-        // when longitude span is larger than 180 degrees.
-        return [
-            ...new Set(getHexagonsInBoundingBox({ west, north, east: 0, south }, resolution).concat(getHexagonsInBoundingBox({ west: 0, north, east, south }, resolution)))
-        ];
-    }
-    // `polyfill()` fills based on hexagon center, which means tiles vanish
-    // prematurely. Get more accurate coverage by oversampling
-    const oversample = 2;
-    const h3Indices = polyfill([
-        [
-            [west, north],
-            [west, south],
-            [east, south],
-            [east, north],
-            [west, north]
-        ]
-    ], resolution + oversample, true);
-    return oversample ? [...new Set(h3Indices.map(i => h3ToParent(i, resolution)))] : h3Indices;
-}
-function tileToBoundingBox(index) {
-    const coordinates = h3ToGeoBoundary(index);
-    const latitudes = coordinates.map(c => c[0]);
-    const longitudes = coordinates.map(c => c[1]);
-    const west = Math.min(...longitudes);
-    const south = Math.min(...latitudes);
-    const east = Math.max(...longitudes);
-    const north = Math.max(...latitudes);
-    return { west, south, east, north };
-}
-// Resolution conversion function. Takes a WebMercatorViewport and returns
-// a H3 resolution such that the screen space size of the hexagons is
-// similar
-// Relative scale factor (0 = no biasing, 2 = a few hexagons cover view)
-const BIAS = 2;
-function getHexagonResolution(viewport) {
-    const hexagonScaleFactor = (2 / 3) * viewport.zoom;
-    const latitudeScaleFactor = Math.log(1 / Math.cos((Math.PI * viewport.latitude) / 180));
-    // Clip and bias
-    return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
-}
-export default class H3Tileset2D extends Tileset2D {
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileIndices({ viewport, minZoom, maxZoom }) {
-        const [east, south, west, north] = viewport.getBounds();
-        let z = getHexagonResolution(viewport);
-        let indices;
-        if (typeof minZoom === 'number' && Number.isFinite(minZoom) && z < minZoom) {
-            z = minZoom;
-        }
-        if (typeof maxZoom === 'number' && Number.isFinite(maxZoom) && z > maxZoom) {
-            z = maxZoom;
-            // Once we are at max zoom, getHexagonsInBoundingBox doesn't work, simply
-            // get a ring centered on the hexagon in the viewport center
-            const center = geoToH3(viewport.latitude, viewport.longitude, maxZoom);
-            indices = kRing(center, 1);
-        }
-        else {
-            indices = getHexagonsInBoundingBox({ west, north, east, south }, z);
-        }
-        return indices.map(i => ({ i }));
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileId({ i }) {
-        return i;
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileMetadata({ i }) {
-        return { bbox: tileToBoundingBox(i) };
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getTileZoom({ i }) {
-        return h3GetResolution(i);
-    }
-    // @ts-expect-error Tileset2D should be generic over TileIndex
-    getParentIndex(index) {
-        const resolution = h3GetResolution(index.i);
-        const i = h3ToParent(index.i, resolution - 1);
-        return { i };
-    }
-}

package/typed/layers/quadkey-tile-layer.js

@@ -1,42 +0,0 @@
-import { CompositeLayer } from '@deck.gl/core';
-import { QuadkeyLayer } from '@deck.gl/geo-layers';
-import QuadkeyTileset2D from './quadkey-tileset-2d';
-import SpatialIndexTileLayer from './spatial-index-tile-layer';
-const renderSubLayers = props => {
-    const { data } = props;
-    if (!data || !data.length)
-        return null;
-    return new QuadkeyLayer(props, { getQuadkey: d => d.id });
-};
-const defaultProps = {
-    aggregationResLevel: 6
-};
-export default class QuadkeyTileLayer extends CompositeLayer {
-    initializeState() {
-        this.setState({ data: null, tileJSON: null });
-    }
-    updateState({ changeFlags }) {
-        if (changeFlags.dataChanged) {
-            let { data } = this.props;
-            const tileJSON = data;
-            data = tileJSON.tiles;
-            this.setState({ data, tileJSON });
-        }
-    }
-    renderLayers() {
-        const { data, tileJSON } = this.state;
-        const maxZoom = parseInt(tileJSON?.maxresolution);
-        return [
-            new SpatialIndexTileLayer(this.props, {
-                id: `quadkey-tile-layer-${this.props.id}`,
-                data,
-                // TODO: Tileset2D should be generic over TileIndex type
-                TilesetClass: QuadkeyTileset2D,
-                renderSubLayers,
-                maxZoom
-            })
-        ];
-    }
-}
-QuadkeyTileLayer.layerName = 'QuadkeyTileLayer';
-QuadkeyTileLayer.defaultProps = defaultProps;

package/typed/layers/quadkey-tileset-2d.js

@@ -1,36 +0,0 @@
-import { _Tileset2D as Tileset2D } from '@deck.gl/geo-layers';
-function tileToQuadkey(tile) {
-    let index = '';
-    for (let z = tile.z; z > 0; z--) {
-        let b = 0;
-        const mask = 1 << (z - 1);
-        if ((tile.x & mask) !== 0)
-            b++;
-        if ((tile.y & mask) !== 0)
-            b += 2;
-        index += b.toString();
-    }
-    return { i: index };
-}
-export default class QuadkeyTileset2D extends Tileset2D {
-    // @ts-expect-error for spatial indices, TileSet2d should be parametrized by TileIndexT
-    getTileIndices(opts) {
-        return super.getTileIndices(opts).map(tileToQuadkey);
-    }
-    // @ts-expect-error TileIndex must be generic
-    getTileId({ i }) {
-        return i;
-    }
-    getTileMetadata() {
-        return {};
-    }
-    // @ts-expect-error TileIndex must be generic
-    getTileZoom({ i }) {
-        return i.length;
-    }
-    // @ts-expect-error TileIndex must be generic
-    getParentIndex(index) {
-        const i = index.i.slice(0, -1);
-        return { i };
-    }
-}

package/typed/layers/schema/carto-tile.js

@@ -1,161 +0,0 @@
-class KeyValueObjectReader {
-    static read(pbf, end) {
-        return pbf.readFields(KeyValueObjectReader._readField, { key: '', value: '' }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.key = pbf.readString();
-        else if (tag === 2)
-            obj.value = pbf.readString();
-    }
-}
-class PropertiesReader {
-    static read(pbf, end) {
-        return pbf.readFields(PropertiesReader._readField, { data: [] }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.data.push(KeyValueObjectReader.read(pbf, pbf.readVarint() + pbf.pos));
-    }
-}
-class DoublesReader {
-    static read(pbf, end) {
-        // TODO perhaps we can do better and directly map from the source
-        // ArrayBuffer using ArrayBuffer.slice()
-        const { value, size } = pbf.readFields(DoublesReader._readField, { value: [], size: 0 }, end);
-        return { value: new Float32Array(value), size };
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            pbf.readPackedDouble(obj.value);
-        else if (tag === 2)
-            obj.size = pbf.readVarint(true);
-    }
-}
-class IntsReader {
-    static read(pbf, end) {
-        const { value, size } = pbf.readFields(IntsReader._readField, { value: [], size: 0 }, end);
-        return { value: new Uint32Array(value), size };
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            pbf.readPackedVarint(obj.value);
-        else if (tag === 2)
-            obj.size = pbf.readVarint(true);
-    }
-}
-class NumericPropReader {
-    static read(pbf, end) {
-        return pbf.readFields(NumericPropReader._readField, { value: [] }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            pbf.readPackedDouble(obj.value);
-    }
-}
-class NumericPropKeyValueReader {
-    static read(pbf, end) {
-        return pbf.readFields(NumericPropKeyValueReader._readField, { key: '', value: null }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.key = pbf.readString();
-        else if (tag === 2)
-            obj.value = NumericPropReader.read(pbf, pbf.readVarint() + pbf.pos);
-    }
-}
-class PointsReader {
-    static read(pbf, end) {
-        return pbf.readFields(PointsReader._readField, { positions: null, globalFeatureIds: null, featureIds: null, properties: [], numericProps: {} }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 2)
-            obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 3)
-            obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 4)
-            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
-        else if (tag === 5) {
-            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
-            obj.numericProps[entry.key] = entry.value;
-        }
-    }
-}
-// Lines ========================================
-class LinesReader {
-    static read(pbf, end) {
-        return pbf.readFields(LinesReader._readField, {
-            positions: null,
-            pathIndices: null,
-            globalFeatureIds: null,
-            featureIds: null,
-            properties: [],
-            numericProps: {}
-        }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 2)
-            obj.pathIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 3)
-            obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 4)
-            obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 5)
-            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
-        else if (tag === 6) {
-            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
-            obj.numericProps[entry.key] = entry.value;
-        }
-    }
-}
-class PolygonsReader {
-    static read(pbf, end) {
-        return pbf.readFields(PolygonsReader._readField, {
-            positions: null,
-            polygonIndices: null,
-            globalFeatureIds: null,
-            featureIds: null,
-            primitivePolygonIndices: null,
-            triangles: null,
-            properties: [],
-            numericProps: {}
-        }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.positions = DoublesReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 2)
-            obj.polygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 3)
-            obj.globalFeatureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 4)
-            obj.featureIds = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 5)
-            obj.primitivePolygonIndices = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 6)
-            obj.triangles = IntsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 7)
-            obj.properties.push(PropertiesReader.read(pbf, pbf.readVarint() + pbf.pos));
-        else if (tag === 8) {
-            const entry = NumericPropKeyValueReader.read(pbf, pbf.readVarint() + pbf.pos);
-            obj.numericProps[entry.key] = entry.value;
-        }
-    }
-}
-export class TileReader {
-    static read(pbf, end) {
-        return pbf.readFields(TileReader._readField, { points: null, lines: null, polygons: null }, end);
-    }
-    static _readField(tag, obj, pbf) {
-        if (tag === 1)
-            obj.points = PointsReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 2)
-            obj.lines = LinesReader.read(pbf, pbf.readVarint() + pbf.pos);
-        else if (tag === 3)
-            obj.polygons = PolygonsReader.read(pbf, pbf.readVarint() + pbf.pos);
-    }
-}