@deck.gl/carto 8.8.0-alpha.4 → 8.8.0-beta.1

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

@@ -0,0 +1,105 @@
+/* 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.d.ts

@@ -0,0 +1,23 @@
+import { CompositeLayer, CompositeLayerProps, Layer, LayersList, UpdateParameters } from '@deck.gl/core/typed';
+/** All properties supported by H3TileLayer. */
+export declare type H3TileLayerProps<DataT = any> = _H3TileLayerProps<DataT> & CompositeLayerProps<DataT>;
+declare type H3HexagonLayerProps<DataT = any> = Record<string, any>;
+/** Properties added by H3TileLayer. */
+declare type _H3TileLayerProps<DataT = any> = H3HexagonLayerProps<DataT> & {
+    aggregationResLevel?: number;
+};
+export default class H3TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT & Required<_H3TileLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        aggregationResLevel: number;
+    };
+    state: {
+        tileJSON: any;
+        data: any;
+    };
+    initializeState(): void;
+    updateState({ changeFlags }: UpdateParameters<this>): void;
+    renderLayers(): Layer | null | LayersList;
+}
+export {};
+//# sourceMappingURL=h3-tile-layer.d.ts.map

package/typed/layers/h3-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"h3-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/h3-tile-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,EACL,UAAU,EACV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAqBvB,+CAA+C;AAC/C,oBAAY,gBAAgB,CAAC,KAAK,GAAG,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAIlG,aAAK,mBAAmB,CAAC,KAAK,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE5D,uCAAuC;AACvC,aAAK,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,mBAAmB,CAAC,KAAK,CAAC,GAAG;IACjE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,WAAW,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,cAAc,CACpF,WAAW,GAAG,QAAQ,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CACjD;IACC,MAAM,CAAC,SAAS,SAAiB;IACjC,MAAM,CAAC,YAAY;;MAAgB;IAEnC,KAAK,EAAG;QACN,QAAQ,EAAE,GAAG,CAAC;QACd,IAAI,EAAE,GAAG,CAAC;KACX,CAAC;IAEF,eAAe,IAAI,IAAI;IAIvB,WAAW,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IASxD,YAAY,IAAI,KAAK,GAAG,IAAI,GAAG,UAAU;CAc1C"}

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

@@ -0,0 +1,47 @@
+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.d.ts

@@ -0,0 +1,18 @@
+import { _Tileset2D as Tileset2D, GeoBoundingBox } from '@deck.gl/geo-layers/typed';
+export declare type H3TileIndex = {
+    i: string;
+};
+export default class H3Tileset2D extends Tileset2D {
+    getTileIndices({ viewport, minZoom, maxZoom }: {
+        viewport: any;
+        minZoom: any;
+        maxZoom: any;
+    }): H3TileIndex[];
+    getTileId({ i }: H3TileIndex): string;
+    getTileMetadata({ i }: H3TileIndex): {
+        bbox: GeoBoundingBox;
+    };
+    getTileZoom({ i }: H3TileIndex): number;
+    getParentIndex(index: H3TileIndex): H3TileIndex;
+}
+//# sourceMappingURL=h3-tileset-2d.d.ts.map

package/typed/layers/h3-tileset-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"h3-tileset-2d.d.ts","sourceRoot":"","sources":["../../src/layers/h3-tileset-2d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,IAAI,SAAS,EAAE,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAG5E,oBAAY,WAAW,GAAG;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AA8DtC,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,SAAS;IAEhD,cAAc,CAAC,EAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAC;;;;KAAA,GAAG,WAAW,EAAE;IAuB3D,SAAS,CAAC,EAAC,CAAC,EAAC,EAAE,WAAW,GAAG,MAAM;IAKnC,eAAe,CAAC,EAAC,CAAC,EAAC,EAAE,WAAW;;;IAKhC,WAAW,CAAC,EAAC,CAAC,EAAC,EAAE,WAAW,GAAG,MAAM;IAKrC,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW;CAKhD"}

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

@@ -0,0 +1,85 @@
+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.d.ts

@@ -0,0 +1,23 @@
+import { CompositeLayer, CompositeLayerProps, Layer, LayersList, UpdateParameters } from '@deck.gl/core/typed';
+import { QuadkeyLayerProps } from '@deck.gl/geo-layers/typed';
+/** All properties supported by QuadkeyTileLayer. */
+export declare type QuadkeyTileLayerProps<DataT = any> = _QuadkeyTileLayerProps<DataT> & CompositeLayerProps<DataT>;
+/** Properties added by QuadkeyTileLayer. */
+declare type _QuadkeyTileLayerProps<DataT> = QuadkeyLayerProps<DataT> & {
+    aggregationResLevel?: number;
+};
+export default class QuadkeyTileLayer<DataT = any, ExtraProps = {}> extends CompositeLayer<ExtraProps & Required<_QuadkeyTileLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        aggregationResLevel: number;
+    };
+    state: {
+        tileJSON: any;
+        data: any;
+    };
+    initializeState(): void;
+    updateState({ changeFlags }: UpdateParameters<this>): void;
+    renderLayers(): Layer | null | LayersList;
+}
+export {};
+//# sourceMappingURL=quadkey-tile-layer.d.ts.map

package/typed/layers/quadkey-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadkey-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/quadkey-tile-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,EACL,UAAU,EACV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAe,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAcpE,oDAAoD;AACpD,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI,sBAAsB,CAAC,KAAK,CAAC,GAC5E,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAE7B,4CAA4C;AAC5C,aAAK,sBAAsB,CAAC,KAAK,IAAI,iBAAiB,CAAC,KAAK,CAAC,GAAG;IAC9D,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,gBAAgB,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE,CAAE,SAAQ,cAAc,CACxF,UAAU,GAAG,QAAQ,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CACrD;IACC,MAAM,CAAC,SAAS,SAAsB;IACtC,MAAM,CAAC,YAAY;;MAAgB;IAEnC,KAAK,EAAG;QACN,QAAQ,EAAE,GAAG,CAAC;QACd,IAAI,EAAE,GAAG,CAAC;KACX,CAAC;IACF,eAAe,IAAI,IAAI;IAIvB,WAAW,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IASxD,YAAY,IAAI,KAAK,GAAG,IAAI,GAAG,UAAU;CAc1C"}

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

@@ -0,0 +1,42 @@
+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.d.ts

@@ -0,0 +1,15 @@
+import { _Tileset2D as Tileset2D } from '@deck.gl/geo-layers/typed';
+declare type QuadkeyTileIndex = {
+    i: string;
+};
+export default class QuadkeyTileset2D extends Tileset2D {
+    getTileIndices(opts: any): QuadkeyTileIndex[];
+    getTileId({ i }: QuadkeyTileIndex): string;
+    getTileMetadata(): {};
+    getTileZoom({ i }: QuadkeyTileIndex): number;
+    getParentIndex(index: QuadkeyTileIndex): {
+        i: string;
+    };
+}
+export {};
+//# sourceMappingURL=quadkey-tileset-2d.d.ts.map

package/typed/layers/quadkey-tileset-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadkey-tileset-2d.d.ts","sourceRoot":"","sources":["../../src/layers/quadkey-tileset-2d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,IAAI,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAE5D,aAAK,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AAapC,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,SAAS;IAErD,cAAc,CAAC,IAAI,KAAA,GAAG,gBAAgB,EAAE;IAKxC,SAAS,CAAC,EAAC,CAAC,EAAC,EAAE,gBAAgB;IAI/B,eAAe;IAKf,WAAW,CAAC,EAAC,CAAC,EAAC,EAAE,gBAAgB;IAKjC,cAAc,CAAC,KAAK,EAAE,gBAAgB;;;CAIvC"}

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

@@ -0,0 +1,36 @@
+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.d.ts

@@ -0,0 +1,44 @@
+interface KeyValueObject {
+    key: string;
+    value: string;
+}
+export interface Properties {
+    data: KeyValueObject[];
+}
+interface Doubles {
+    value: Float32Array;
+    size: number;
+}
+interface Ints {
+    value: Uint32Array;
+    size: number;
+}
+interface NumericProp {
+    value: number[];
+}
+interface Points {
+    positions: Doubles;
+    globalFeatureIds: Ints;
+    featureIds: Ints;
+    properties: Properties[];
+    numericProps: Record<string, NumericProp>;
+}
+interface Lines extends Points {
+    pathIndices: Ints;
+}
+interface Polygons extends Points {
+    polygonIndices: Ints;
+    primitivePolygonIndices: Ints;
+    triangles: Ints;
+}
+export interface Tile {
+    points: Points;
+    lines: Lines;
+    polygons: Polygons;
+}
+export declare class TileReader {
+    static read(pbf: any, end?: number): Tile;
+    static _readField(this: void, tag: number, obj: Tile, pbf: any): void;
+}
+export {};
+//# sourceMappingURL=carto-tile.d.ts.map

package/typed/layers/schema/carto-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carto-tile.d.ts","sourceRoot":"","sources":["../../../src/layers/schema/carto-tile.ts"],"names":[],"mappings":"AACA,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAcD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,cAAc,EAAE,CAAC;CACxB;AAaD,UAAU,OAAO;IACf,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAiBD,UAAU,IAAI;IACZ,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAeD,UAAU,WAAW;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AA6BD,UAAU,MAAM;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,IAAI,CAAC;IACvB,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAC3C;AAsBD,UAAU,KAAM,SAAQ,MAAM;IAC5B,WAAW,EAAE,IAAI,CAAC;CACnB;AAgCD,UAAU,QAAS,SAAQ,MAAM;IAC/B,cAAc,EAAE,IAAI,CAAC;IACrB,uBAAuB,EAAE,IAAI,CAAC;IAC9B,SAAS,EAAE,IAAI,CAAC;CACjB;AAqCD,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,IAAI,CAAC,GAAG,KAAA,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAGpC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAA;CAK1D"}

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

@@ -0,0 +1,161 @@
+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);
+    }
+}

package/typed/layers/spatial-index-tile-layer.d.ts

@@ -0,0 +1,12 @@
+import { PickingInfo } from '@deck.gl/core/typed';
+import { TileLayer, _Tile2DHeader as Tile2DHeader } from '@deck.gl/geo-layers/typed';
+export default class SpatialIndexTileLayer<ExtraProps = {}> extends TileLayer<any, ExtraProps> {
+    static layerName: string;
+    protected _updateAutoHighlight(info: PickingInfo): void;
+    getSubLayerPropsByTile(tile: Tile2DHeader): {
+        highlightedObjectIndex: number;
+        highlightColor: any;
+    };
+    getHighlightedObjectIndex(tile: Tile2DHeader): number;
+}
+//# sourceMappingURL=spatial-index-tile-layer.d.ts.map

package/typed/layers/spatial-index-tile-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-index-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/spatial-index-tile-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,SAAS,EAAE,aAAa,IAAI,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAM7E,MAAM,CAAC,OAAO,OAAO,qBAAqB,CAAC,UAAU,GAAG,EAAE,CAAE,SAAQ,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC;IAC5F,MAAM,CAAC,SAAS,SAA2B;IAE3C,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAsBvD,sBAAsB,CAAC,IAAI,EAAE,YAAY;;;;IAOzC,yBAAyB,CAAC,IAAI,EAAE,YAAY;CAW7C"}