@deck.gl/carto 8.8.0-alpha.5 → 8.8.0-beta.2

package/typed/layers/carto-layer.d.ts

@@ -0,0 +1,96 @@
+import { CompositeLayer, Layer, CompositeLayerProps, LayerProps, ChangeFlags } from '@deck.gl/core/typed';
+import { Format, MapType, TileFormat } from '../api/maps-api-common';
+import { Credentials } from '../config';
+/** All properties supported by CartoLayer. */
+export declare type CartoLayerProps<DataT = any> = _CartoLayerProps & CompositeLayerProps<DataT>;
+/** Properties added by CartoLayer. */
+declare type _CartoLayerProps = {
+    /**
+     * Either a SQL query or a name of dataset/tileset.
+     */
+    data: string;
+    /**
+     * Data type.
+     *
+     * Possible values are:
+     *  * `MAP_TYPES.QUERY`, if data is a SQL query.
+     *  * `MAP_TYPES.TILESET`, if data is a tileset name.
+     *  * `MAP_TYPES.TABLE`, if data is a dataset name. Only supported with API v3.
+     */
+    type: MapType;
+    /**
+     * Name of the connection registered in the CARTO workspace.
+     *
+     * Required when apiVersion is `API_VERSIONS.V3`.
+     */
+    connection?: string;
+    /**
+     * Use to override the default data format.
+     *
+     * Only supported when apiVersion is `API_VERSIONS.V3`.
+     *
+     * Possible values are: `FORMATS.GEOJSON`, `FORMATS.JSON` and `FORMATS.TILEJSON`.
+     */
+    format?: Format;
+    /**
+     * Use to override the default tile data format.
+     *
+     * Only supported when apiVersion is `API_VERSIONS.V3` and format is `FORMATS.TILEJSON`.
+     *
+     * Possible values are: `TILE_FORMATS.BINARY`, `TILE_FORMATS.GEOJSON` and `TILE_FORMATS.MVT`.
+     */
+    formatTiles?: TileFormat;
+    /**
+     * Name of the geo_column in the CARTO platform.
+     *
+     * Use this override the default column (`'geom'`), from which the geometry information should be fetched.
+     *
+     * Only supported when apiVersion is `API_VERSIONS.V3` and type is `MAP_TYPES.TABLE`.
+     */
+    geoColumn?: string;
+    /**
+     * Names of columns to fetch.
+     *
+     * By default, all columns are fetched
+     *
+     * Only supported when apiVersion is `API_VERSIONS.V3` and type is `MAP_TYPES.TABLE`.
+     */
+    columns?: string[];
+    /**
+     * A string pointing to a unique attribute at the result of the query.
+     *
+     * A unique attribute is needed for highlighting with vector tiles when a feature is split across two or more tiles.
+     */
+    uniqueIdProperty?: string;
+    /**
+     * Optional. Overrides the configuration to connect with CARTO.
+     *
+     * @see Credentials
+     */
+    credentials?: Credentials;
+    /**
+     * Called when the request to the CARTO Maps API failed.
+     *
+     * By default the Error is thrown.
+     */
+    onDataError?: (err: unknown) => void;
+    clientId?: string;
+};
+export default class CartoLayer<ExtraProps = {}> extends CompositeLayer<Required<_CartoLayerProps> & ExtraProps> {
+    static layerName: string;
+    static defaultProps: any;
+    initializeState(): void;
+    get isLoaded(): boolean;
+    _checkProps(props: CartoLayerProps): void;
+    updateState({ props, oldProps, changeFlags }: {
+        props: CartoLayerProps;
+        oldProps: CartoLayerProps;
+        context: any;
+        changeFlags: ChangeFlags;
+    }): void;
+    _updateData(): Promise<void>;
+    _getSubLayerAndProps(): [any, LayerProps];
+    renderLayers(): Layer | null;
+}
+export {};
+//# sourceMappingURL=carto-layer.d.ts.map

package/typed/layers/carto-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carto-layer.d.ts","sourceRoot":"","sources":["../../src/layers/carto-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,EAEL,mBAAmB,EACnB,UAAU,EACV,WAAW,EACZ,MAAM,eAAe,CAAC;AAOvB,OAAO,EAEL,MAAM,EAGN,OAAO,EAEP,UAAU,EAEX,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAGL,WAAW,EAEZ,MAAM,WAAW,CAAC;AA4CnB,8CAA8C;AAC9C,oBAAY,eAAe,CAAC,KAAK,GAAG,GAAG,IAAI,gBAAgB,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEzF,sCAAsC;AACtC,aAAK,gBAAgB,GAAG;IACtB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;OAOG;IACH,IAAI,EAAE,OAAO,CAAC;IAEd;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,UAAU,CAAC;IAEzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IAErC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,UAAU,GAAG,EAAE,CAAE,SAAQ,cAAc,CACrE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,UAAU,CACxC;IACC,MAAM,CAAC,SAAS,SAAgB;IAChC,MAAM,CAAC,YAAY,MAAuB;IAE1C,eAAe,IAAI,IAAI;IAOvB,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAuCzC,WAAW,CAAC,EACV,KAAK,EACL,QAAQ,EACR,WAAW,EACZ,EAAE;QACD,KAAK,EAAE,eAAe,CAAC;QACvB,QAAQ,EAAE,eAAe,CAAC;QAC1B,OAAO,EAAE,GAAG,CAAC;QACb,WAAW,EAAE,WAAW,CAAC;KAC1B,GAAG,IAAI;IAmBF,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAqClC,oBAAoB,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC;IAqCzC,YAAY,IAAI,KAAK,GAAG,IAAI;CAqB7B"}

package/typed/layers/carto-layer.js

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

@@ -0,0 +1,30 @@
+import { DefaultProps } from '@deck.gl/core/typed';
+import { MVTLayer, MVTLayerProps, TileLayer, _Tile2DHeader, _TileLoadProps as TileLoadProps } from '@deck.gl/geo-layers/typed';
+import { GeoJsonLayer } from '@deck.gl/layers/typed';
+import { TileFormat } from '../api/maps-api-common';
+import type { Feature } from 'geojson';
+/** All properties supported by CartoTileLayer. */
+export declare type CartoTileLayerProps<DataT extends Feature = Feature> = _CartoTileLayerProps & MVTLayerProps<DataT>;
+/** Properties added by CartoTileLayer. */
+declare type _CartoTileLayerProps = {
+    /** Use to override the default tile data format.
+     *
+     * Possible values are: `TILE_FORMATS.BINARY`, `TILE_FORMATS.GEOJSON` and `TILE_FORMATS.MVT`.
+     *
+     * Only supported when `apiVersion` is `API_VERSIONS.V3` and `format` is `FORMATS.TILEJSON`.
+     */
+    formatTiles?: TileFormat;
+};
+export default class CartoTileLayer<DataT extends Feature = Feature, ExtraProps = {}> extends MVTLayer<DataT, Required<_CartoTileLayerProps> & ExtraProps> {
+    static layerName: string;
+    static defaultProps: DefaultProps<CartoTileLayerProps<Feature<import("geojson").Geometry, import("geojson").GeoJsonProperties>>>;
+    getTileData(tile: TileLoadProps): any;
+    renderSubLayers(props: TileLayer['props'] & {
+        id: string;
+        data: any;
+        _offset: number;
+        tile: _Tile2DHeader;
+    }): GeoJsonLayer | null;
+}
+export {};
+//# sourceMappingURL=carto-tile-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"carto-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/carto-tile-layer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAM,YAAY,EAAC,MAAM,eAAe,CAAC;AAEhD,OAAO,EACL,QAAQ,EACR,aAAa,EACb,SAAS,EAET,aAAa,EACb,cAAc,IAAI,aAAa,EAChC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAC,UAAU,EAAe,MAAM,wBAAwB,CAAC;AAGhE,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,SAAS,CAAC;AAqErC,kDAAkD;AAClD,oBAAY,mBAAmB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,IAAI,oBAAoB,GACrF,aAAa,CAAC,KAAK,CAAC,CAAC;AAEvB,0CAA0C;AAC1C,aAAK,oBAAoB,GAAG;IAC1B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,UAAU,CAAC;CAC1B,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,cAAc,CACjC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,UAAU,GAAG,EAAE,CACf,SAAQ,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,UAAU,CAAC;IACpE,MAAM,CAAC,SAAS,SAAoB;IACpC,MAAM,CAAC,YAAY,8GAAgB;IAEnC,WAAW,CAAC,IAAI,EAAE,aAAa;IA0B/B,eAAe,CACb,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG;QAC1B,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,GAAG,CAAC;QACV,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,aAAa,CAAC;KACrB,GACA,YAAY,GAAG,IAAI;CAkBvB"}

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,21 @@
+import { CompositeLayer, CompositeLayerProps, Layer, LayersList, UpdateParameters, DefaultProps } 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> = H3HexagonLayerProps<DataT> & {
+    aggregationResLevel?: number;
+};
+export default class H3TileLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT & Required<_H3TileLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<H3HexagonLayerProps<any>>;
+    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,EAChB,YAAY,EACb,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,IAAI,mBAAmB,CAAC,KAAK,CAAC,GAAG;IAC3D,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,yCAAgB;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,21 @@
+import { CompositeLayer, CompositeLayerProps, Layer, LayersList, UpdateParameters, DefaultProps } 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: DefaultProps<QuadkeyTileLayerProps<any>>;
+    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,EAChB,YAAY,EACb,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,2CAAgB;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;