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

package/typed/api/parseMap.js

@@ -0,0 +1,178 @@
+import GL from '@luma.gl/constants';
+import { AGGREGATION, getLayer, getColorAccessor, getColorValueAccessor, getSizeAccessor, getTextAccessor, getTextPixelOffsetAccessor, OPACITY_MAP, opacityToAlpha } from './layer-map';
+import { _flatten as flatten, log } from '@deck.gl/core';
+import { assert } from '../utils';
+export function parseMap(json) {
+    const { keplerMapConfig, datasets } = json;
+    assert(keplerMapConfig.version === 'v1', 'Only support Kepler v1');
+    const { mapState, mapStyle } = keplerMapConfig.config;
+    const { layers, layerBlending, interactionConfig } = keplerMapConfig.config.visState;
+    return {
+        id: json.id,
+        title: json.title,
+        description: json.description,
+        createdAt: json.createdAt,
+        updatedAt: json.updatedAt,
+        initialViewState: mapState,
+        mapStyle,
+        layers: extractTextLayers(layers.reverse()).map(({ id, type, config, visualChannels }) => {
+            try {
+                const { dataId } = config;
+                const dataset = datasets.find(d => d.id === dataId);
+                assert(dataset, `No dataset matching dataId: ${dataId}`);
+                const { data } = dataset;
+                assert(data, `No data loaded for dataId: ${dataId}`);
+                const { Layer, propMap, defaultProps } = getLayer(type, config, dataset);
+                return new Layer({
+                    id,
+                    data,
+                    ...defaultProps,
+                    ...createBlendingProps(layerBlending),
+                    ...(!config.textLabel && createInteractionProps(interactionConfig)),
+                    ...createStyleProps(config, propMap),
+                    ...createChannelProps(visualChannels, type, config, data) // Must come after style
+                });
+            }
+            catch (e) {
+                log.error(e.message)();
+                return undefined;
+            }
+        })
+    };
+}
+function extractTextLayers(layers) {
+    return flatten(layers.map(({ id, config, ...rest }) => {
+        const { textLabel, ...configRest } = config;
+        return [
+            // Original layer without textLabel
+            { id, config: configRest, ...rest },
+            // One layer per valid text label, with full opacity
+            ...textLabel
+                .filter(t => t.field)
+                .map(t => {
+                return {
+                    id: `${id}-label-${t.field.name}`,
+                    config: {
+                        textLabel: t,
+                        ...configRest,
+                        label: `${config.label}-label-${t.field.name}`,
+                        visConfig: { ...configRest.visConfig, opacity: 1 }
+                    },
+                    ...rest
+                };
+            })
+        ];
+    }));
+}
+function createBlendingProps(layerBlending) {
+    if (layerBlending === 'additive') {
+        return {
+            parameters: {
+                blendFunc: [GL.SRC_ALPHA, GL.DST_ALPHA],
+                blendEquation: GL.FUNC_ADD
+            }
+        };
+    }
+    else if (layerBlending === 'subtractive') {
+        return {
+            parameters: {
+                blendFunc: [GL.ONE, GL.ONE_MINUS_DST_COLOR, GL.SRC_ALPHA, GL.DST_ALPHA],
+                blendEquation: [GL.FUNC_SUBTRACT, GL.FUNC_ADD]
+            }
+        };
+    }
+    return {};
+}
+function createInteractionProps(interactionConfig) {
+    const pickable = interactionConfig && interactionConfig.tooltip.enabled;
+    return {
+        autoHighlight: pickable,
+        pickable
+    };
+}
+function mapProps(source, target, mapping) {
+    for (const sourceKey in mapping) {
+        const sourceValue = source[sourceKey];
+        const targetKey = mapping[sourceKey];
+        if (sourceValue === undefined) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (typeof targetKey === 'string') {
+            target[targetKey] = sourceValue;
+        }
+        else if (typeof targetKey === 'function') {
+            const [key, value] = Object.entries(targetKey(sourceValue))[0];
+            target[key] = value;
+        }
+        else if (typeof targetKey === 'object') {
+            // Nested definition, recurse down one level (also handles arrays)
+            mapProps(sourceValue, target, targetKey);
+        }
+    }
+}
+function createStyleProps(config, mapping) {
+    const result = {};
+    mapProps(config, result, mapping);
+    // Kepler format sometimes omits strokeColor. TODO: remove once we can rely on
+    // `strokeColor` always being set when `stroke: true`.
+    if (result.stroked && !result.getLineColor) {
+        result.getLineColor = result.getFillColor;
+    }
+    for (const colorAccessor in OPACITY_MAP) {
+        if (Array.isArray(result[colorAccessor])) {
+            const color = [...result[colorAccessor]];
+            const opacityKey = OPACITY_MAP[colorAccessor];
+            const opacity = config.visConfig[opacityKey];
+            color[3] = opacityToAlpha(opacity);
+            result[colorAccessor] = color;
+        }
+    }
+    result.highlightColor = config.visConfig.enable3d ? [255, 255, 255, 60] : [252, 242, 26, 255];
+    return result;
+}
+/* eslint-disable complexity, max-statements */
+function createChannelProps(visualChannels, type, config, data) {
+    const { colorField, colorScale, sizeField, sizeScale, strokeColorField, strokeColorScale } = visualChannels;
+    let { heightField, heightScale } = visualChannels;
+    if (type === 'hexagonId') {
+        heightField = sizeField;
+        heightScale = sizeScale;
+    }
+    const { textLabel, visConfig } = config;
+    const result = {};
+    const textLabelField = textLabel && textLabel.field;
+    if (type === 'grid' || type === 'hexagon') {
+        result.colorScaleType = colorScale;
+        if (colorField) {
+            const { colorAggregation } = config.visConfig;
+            if (!AGGREGATION[colorAggregation]) {
+                result.getColorValue = getColorValueAccessor(colorField, colorAggregation, data);
+            }
+            else {
+                result.getColorWeight = d => d[colorField.name];
+            }
+        }
+    }
+    else if (colorField) {
+        result.getFillColor = getColorAccessor(colorField, colorScale, visConfig.colorRange, visConfig.opacity, data);
+    }
+    if (strokeColorField) {
+        const fallbackOpacity = type === 'point' ? visConfig.opacity : 1;
+        const opacity = visConfig.strokeOpacity !== undefined ? visConfig.strokeOpacity : fallbackOpacity;
+        result.getLineColor = getColorAccessor(strokeColorField, strokeColorScale, visConfig.strokeColorRange, opacity, data);
+    }
+    if (heightField) {
+        result.getElevation = getSizeAccessor(heightField, heightScale, visConfig.heightRange || visConfig.sizeRange, data);
+    }
+    if (sizeField) {
+        result.getPointRadius = getSizeAccessor(sizeField, sizeScale, visConfig.radiusRange || visConfig.sizeRange, data);
+    }
+    if (textLabelField) {
+        result.getText = getTextAccessor(textLabelField, data);
+        result.pointType = 'text';
+        const radius = result.getPointRadius || visConfig.radius;
+        result.getTextPixelOffset = getTextPixelOffsetAccessor(textLabel, radius);
+    }
+    return result;
+}

package/typed/basemap.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    readonly VOYAGER: string;
+    readonly POSITRON: string;
+    readonly DARK_MATTER: string;
+    readonly VOYAGER_NOLABELS: string;
+    readonly POSITRON_NOLABELS: string;
+    readonly DARK_MATTER_NOLABELS: string;
+};
+export default _default;
+//# sourceMappingURL=basemap.d.ts.map

package/typed/basemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basemap.d.ts","sourceRoot":"","sources":["../src/basemap.ts"],"names":[],"mappings":";;;;;;;;AAEA,wBAOW"}

package/typed/basemap.js

@@ -0,0 +1,9 @@
+const baseUrl = 'https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json';
+export default {
+    VOYAGER: baseUrl.replace('{basemap}', 'voyager'),
+    POSITRON: baseUrl.replace('{basemap}', 'positron'),
+    DARK_MATTER: baseUrl.replace('{basemap}', 'dark-matter'),
+    VOYAGER_NOLABELS: baseUrl.replace('{basemap}', 'voyager-nolabels'),
+    POSITRON_NOLABELS: baseUrl.replace('{basemap}', 'positron-nolabels'),
+    DARK_MATTER_NOLABELS: baseUrl.replace('{basemap}', 'dark-matter-nolabels')
+};

package/typed/config.d.ts

@@ -0,0 +1,26 @@
+export declare const defaultClassicCredentials: {
+    readonly apiKey: "default_public";
+    readonly region: "us";
+    readonly username: "public";
+};
+export declare const defaultCloudNativeCredentials: {
+    readonly apiBaseUrl: "https://gcp-us-east1.api.carto.com";
+};
+export interface ClassicCredentials {
+    apiVersion: 'v1' | 'v2';
+    apiKey: string;
+    region: string;
+    username: string;
+    mapsUrl?: string;
+}
+export interface CloudNativeCredentials {
+    apiVersion: 'v3';
+    apiBaseUrl: string;
+    accessToken?: string;
+    mapsUrl?: string;
+}
+export declare type Credentials = ClassicCredentials | CloudNativeCredentials;
+export declare function setDefaultCredentials({ apiVersion, ...rest }: Partial<Credentials>): void;
+export declare function getDefaultCredentials(): Credentials;
+export declare function buildMapsUrlFromBase(apiBaseUrl: string): string;
+//# sourceMappingURL=config.d.ts.map

package/typed/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX,eAAO,MAAM,6BAA6B;;CAEhC,CAAC;AAEX,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,IAAI,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,oBAAY,WAAW,GAAG,kBAAkB,GAAG,sBAAsB,CAAC;AAKtE,wBAAgB,qBAAqB,CAAC,EAAC,UAAU,EAAE,GAAG,IAAI,EAAC,EAAE,OAAO,CAAC,WAAW,CAAC,QAchF;AAED,wBAAgB,qBAAqB,IAAI,WAAW,CAEnD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAO/D"}

package/typed/config.js

@@ -0,0 +1,35 @@
+import { API_VERSIONS } from './api/maps-api-common';
+export const defaultClassicCredentials = {
+    apiKey: 'default_public',
+    region: 'us',
+    username: 'public'
+};
+export const defaultCloudNativeCredentials = {
+    apiBaseUrl: 'https://gcp-us-east1.api.carto.com'
+};
+let credentials = {};
+setDefaultCredentials({});
+export function setDefaultCredentials({ apiVersion, ...rest }) {
+    apiVersion = apiVersion || API_VERSIONS.V3;
+    switch (apiVersion) {
+        case API_VERSIONS.V1:
+        case API_VERSIONS.V2:
+            credentials = { apiVersion, ...defaultClassicCredentials, ...rest };
+            break;
+        case API_VERSIONS.V3:
+            credentials = { apiVersion, ...defaultCloudNativeCredentials, ...rest };
+            break;
+        default:
+            throw new Error(`Invalid API version ${apiVersion}. Use API_VERSIONS enum.`);
+    }
+}
+export function getDefaultCredentials() {
+    return credentials;
+}
+export function buildMapsUrlFromBase(apiBaseUrl) {
+    let suffix = '/v3/maps';
+    if (apiBaseUrl.endsWith('/')) {
+        suffix = suffix.substring(1);
+    }
+    return `${apiBaseUrl}${suffix}`;
+}

package/typed/index.d.ts

@@ -0,0 +1,12 @@
+export { getDefaultCredentials, setDefaultCredentials } from './config';
+export { default as CartoLayer } from './layers/carto-layer';
+export { default as _CartoTileLayer } from './layers/carto-tile-layer';
+export { default as _H3TileLayer } from './layers/h3-tile-layer';
+export { default as _QuadkeyTileLayer } from './layers/quadkey-tile-layer';
+export { default as BASEMAP } from './basemap';
+export { default as colorBins } from './style/color-bins-style';
+export { default as colorCategories } from './style/color-categories-style';
+export { default as colorContinuous } from './style/color-continuous-style';
+export { FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS, fetchLayerData, fetchMap, getDataV2 as _getDataV2, getData, mapInstantiation as _mapInstantiation } from './api';
+export type { CartoLayerProps } from './layers/carto-layer';
+//# sourceMappingURL=index.d.ts.map

package/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAE,qBAAqB,EAAC,MAAM,UAAU,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EACL,OAAO,EACP,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,SAAS,IAAI,UAAU,EACvB,OAAO,EACP,gBAAgB,IAAI,iBAAiB,EACtC,MAAM,OAAO,CAAC;AAEf,YAAY,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC"}

package/typed/index.js

@@ -0,0 +1,10 @@
+export { getDefaultCredentials, setDefaultCredentials } from './config';
+export { default as CartoLayer } from './layers/carto-layer';
+export { default as _CartoTileLayer } from './layers/carto-tile-layer';
+export { default as _H3TileLayer } from './layers/h3-tile-layer';
+export { default as _QuadkeyTileLayer } from './layers/quadkey-tile-layer';
+export { default as BASEMAP } from './basemap';
+export { default as colorBins } from './style/color-bins-style';
+export { default as colorCategories } from './style/color-categories-style';
+export { default as colorContinuous } from './style/color-continuous-style';
+export { FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS, fetchLayerData, fetchMap, getDataV2 as _getDataV2, getData, mapInstantiation as _mapInstantiation } from './api';

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

@@ -0,0 +1,98 @@
+import { CompositeLayer, Layer } from '@deck.gl/core/typed';
+import { Format, MapType, TileFormat } from '../api/maps-api-common';
+import { Credentials } from '../config';
+import { CompositeLayerProps, LayerProps } from 'modules/core/src/types/layer-props';
+import { ChangeFlags } from 'modules/core/src/lib/layer-state';
+/** 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,EAAC,cAAc,EAAE,KAAK,EAAM,MAAM,eAAe,CAAC;AAOzD,OAAO,EAEL,MAAM,EAGN,OAAO,EAEP,UAAU,EAEX,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAGL,WAAW,EAEZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,mBAAmB,EAAE,UAAU,EAAC,MAAM,oCAAoC,CAAC;AACnF,OAAO,EAAC,WAAW,EAAC,MAAM,kCAAkC,CAAC;AA4C7D,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,63 @@
+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 { LoaderWithParser } from '@loaders.gl/loader-utils';
+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: {
+        formatTiles: "binary";
+        loaders: LoaderWithParser[];
+        uniqueIdProperty: {
+            type: string;
+            value: string;
+        };
+        highlightedFeatureId: null;
+        binary: boolean;
+        stroked: boolean;
+        filled: boolean;
+        extruded: boolean;
+        wireframe: boolean;
+        iconAtlas: {
+            type: string;
+            value: null;
+        };
+        iconMapping: {
+            type: string;
+            value: {};
+        };
+        getIcon: {
+            type: string;
+            value: (f: any) => any;
+        };
+        getText: {
+            type: string;
+            value: (f: any) => any;
+        };
+        pointType: string;
+        getRadius: {
+            deprecatedFor: string;
+        };
+    };
+    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":"AAIA,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;AAChE,OAAO,EAAgB,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAEzE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;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"}