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

package/typed/api/maps-v3-client.js

@@ -0,0 +1,304 @@
+/**
+ * Maps API Client for Carto 3
+ */
+import { getDefaultCredentials, buildMapsUrlFromBase } from '../config';
+import { API_VERSIONS, COLUMNS_SUPPORT, encodeParameter, FORMATS, GEO_COLUMN_SUPPORT, MAP_TYPES, TILE_FORMATS } from './maps-api-common';
+import { parseMap } from './parseMap';
+import { log } from '@deck.gl/core';
+import { assert } from '../utils';
+const MAX_GET_LENGTH = 2048;
+const DEFAULT_CLIENT = 'deck-gl-carto';
+/**
+ * Request against Maps API
+ */
+async function request({ method, url, accessToken, body }) {
+    const headers = {
+        Accept: 'application/json'
+    };
+    if (accessToken) {
+        headers.Authorization = `Bearer ${accessToken}`;
+    }
+    if (method === 'POST') {
+        headers['Content-Type'] = 'application/json';
+    }
+    try {
+        /* global fetch */
+        return await fetch(url, {
+            method,
+            headers,
+            body
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to connect to Maps API: ${error}`);
+    }
+}
+async function requestJson({ method, url, accessToken, body }) {
+    const response = await request({ method, url, accessToken, body });
+    const json = await response.json();
+    if (!response.ok) {
+        dealWithError({ response, error: json.error });
+    }
+    return json;
+}
+async function requestData({ method, url, accessToken, format, body }) {
+    if (format === FORMATS.NDJSON) {
+        return request({ method, url, accessToken, body });
+    }
+    const data = await requestJson({ method, url, accessToken, body });
+    return data.rows ? data.rows : data;
+}
+/**
+ * Display proper message from Maps API error
+ */
+function dealWithError({ response, error }) {
+    switch (response.status) {
+        case 400:
+            throw new Error(`Bad request. ${error}`);
+        case 401:
+        case 403:
+            throw new Error(`Unauthorized access. ${error}`);
+        default:
+            throw new Error(error);
+    }
+}
+/**
+ * Build a URL with all required parameters
+ */
+function getParameters({ type, source, geoColumn, columns, clientId, aggregationExp, aggregationResLevel }) {
+    const parameters = [encodeParameter('client', clientId || DEFAULT_CLIENT)];
+    const sourceName = type === MAP_TYPES.QUERY ? 'q' : 'name';
+    parameters.push(encodeParameter(sourceName, source));
+    if (geoColumn) {
+        parameters.push(encodeParameter('geo_column', geoColumn));
+    }
+    if (columns) {
+        parameters.push(encodeParameter('columns', columns.join(',')));
+    }
+    if (aggregationExp) {
+        parameters.push(encodeParameter('aggregationExp', aggregationExp));
+    }
+    if (aggregationResLevel) {
+        parameters.push(encodeParameter('aggregationResLevel', aggregationResLevel));
+    }
+    return parameters.join('&');
+}
+export async function mapInstantiation({ type, source, connection, credentials, geoColumn, columns, clientId, aggregationExp, aggregationResLevel }) {
+    const baseUrl = `${credentials.mapsUrl}/${connection}/${type}`;
+    const url = `${baseUrl}?${getParameters({
+        type,
+        source,
+        geoColumn,
+        columns,
+        clientId,
+        aggregationExp,
+        aggregationResLevel
+    })}`;
+    const { accessToken } = credentials;
+    if (url.length > MAX_GET_LENGTH && type === MAP_TYPES.QUERY) {
+        // need to be a POST request
+        const body = JSON.stringify({
+            q: source,
+            client: clientId || DEFAULT_CLIENT
+        });
+        return await requestJson({ method: 'POST', url: baseUrl, accessToken, body });
+    }
+    return await requestJson({ url, accessToken });
+}
+function getUrlFromMetadata(metadata, format) {
+    const m = metadata[format];
+    if (m && !m.error && m.url) {
+        return m.url[0];
+    }
+    return null;
+}
+function checkFetchLayerDataParameters({ type, source, connection, credentials, geoColumn, columns, aggregationExp, aggregationResLevel }) {
+    assert(connection, 'Must define connection');
+    assert(type, 'Must define a type');
+    assert(source, 'Must define a source');
+    assert(credentials.apiVersion === API_VERSIONS.V3, 'Method only available for v3');
+    assert(credentials.apiBaseUrl, 'Must define apiBaseUrl');
+    assert(credentials.accessToken, 'Must define an accessToken');
+    if (columns) {
+        assert(COLUMNS_SUPPORT.includes(type), `The columns parameter is not supported by type ${type}`);
+    }
+    if (geoColumn) {
+        assert(GEO_COLUMN_SUPPORT.includes(type), `The geoColumn parameter is not supported by type ${type}`);
+    }
+    else {
+        assert(!aggregationExp, 'Have aggregationExp, but geoColumn parameter is missing');
+        assert(!aggregationResLevel, 'Have aggregationResLevel, but geoColumn parameter is missing');
+    }
+    if (!aggregationExp) {
+        assert(!aggregationResLevel, 'Have aggregationResLevel, but aggregationExp parameter is missing');
+    }
+}
+export async function fetchLayerData({ type, source, connection, credentials, geoColumn, columns, format, formatTiles, clientId, aggregationExp, aggregationResLevel }) {
+    // Internally we split data fetching into two parts to allow us to
+    // conditionally fetch the actual data, depending on the metadata state
+    const { url, accessToken, mapFormat, metadata } = await _fetchDataUrl({
+        type,
+        source,
+        connection,
+        credentials,
+        geoColumn,
+        columns,
+        format,
+        formatTiles,
+        clientId,
+        aggregationExp,
+        aggregationResLevel
+    });
+    const data = await requestData({ url, format: mapFormat, accessToken });
+    const result = { data, format: mapFormat, schema: metadata.schema };
+    return result;
+}
+async function _fetchDataUrl({ type, source, connection, credentials, geoColumn, columns, format, formatTiles, clientId, aggregationExp, aggregationResLevel }) {
+    const defaultCredentials = getDefaultCredentials();
+    // Only pick up default credentials if they have been defined for
+    // correct API version
+    const localCreds = {
+        ...(defaultCredentials.apiVersion === API_VERSIONS.V3 && defaultCredentials),
+        ...credentials
+    };
+    checkFetchLayerDataParameters({
+        type,
+        source,
+        connection,
+        credentials: localCreds,
+        geoColumn,
+        columns,
+        aggregationExp,
+        aggregationResLevel
+    });
+    if (!localCreds.mapsUrl) {
+        localCreds.mapsUrl = buildMapsUrlFromBase(localCreds.apiBaseUrl);
+    }
+    const metadata = await mapInstantiation({
+        type,
+        source,
+        connection,
+        credentials: localCreds,
+        geoColumn,
+        columns,
+        clientId,
+        aggregationExp,
+        aggregationResLevel
+    });
+    let url = null;
+    let mapFormat;
+    if (format) {
+        mapFormat = format;
+        url = getUrlFromMetadata(metadata, format);
+        assert(url, `Format ${format} not available`);
+    }
+    else {
+        // guess map format
+        const prioritizedFormats = [FORMATS.GEOJSON, FORMATS.JSON, FORMATS.NDJSON, FORMATS.TILEJSON];
+        for (const f of prioritizedFormats) {
+            url = getUrlFromMetadata(metadata, f);
+            if (url) {
+                mapFormat = f;
+                break;
+            }
+        }
+        assert(url && mapFormat, 'Unsupported data formats received from backend.');
+    }
+    if (format === FORMATS.TILEJSON && formatTiles) {
+        log.assert(Object.values(TILE_FORMATS).includes(formatTiles), `Invalid value for formatTiles: ${formatTiles}. Use value from TILE_FORMATS`);
+        url += `&${encodeParameter('formatTiles', formatTiles)}`;
+    }
+    const { accessToken } = localCreds;
+    return { url, accessToken, mapFormat, metadata };
+}
+export async function getData({ type, source, connection, credentials, geoColumn, columns, format, clientId }) {
+    log.deprecated('getData', 'fetchLayerData')();
+    const layerData = await fetchLayerData({
+        type,
+        source,
+        connection,
+        credentials,
+        geoColumn,
+        columns,
+        format,
+        clientId
+    });
+    return layerData.data;
+}
+/* global clearInterval, setInterval, URL */
+async function _fetchMapDataset(dataset, accessToken, credentials, clientId) {
+    const { connectionName: connection, columns, format, geoColumn, source, type } = dataset;
+    // First fetch metadata
+    const { url, mapFormat } = await _fetchDataUrl({
+        clientId,
+        credentials: { ...credentials, accessToken },
+        connection,
+        columns,
+        format,
+        geoColumn,
+        source,
+        type
+    });
+    // Extract the last time the data changed
+    const cache = parseInt(new URL(url).searchParams.get('cache') || '', 10);
+    if (cache && dataset.cache === cache) {
+        return false;
+    }
+    dataset.cache = cache;
+    // Only fetch if the data has changed
+    dataset.data = await requestData({ url, format: mapFormat, accessToken });
+    return true;
+}
+async function fillInMapDatasets({ datasets, token }, clientId, credentials) {
+    const promises = datasets.map(dataset => _fetchMapDataset(dataset, token, credentials, clientId));
+    return await Promise.all(promises);
+}
+export async function fetchMap({ cartoMapId, clientId, credentials, autoRefresh, onNewData }) {
+    const defaultCredentials = getDefaultCredentials();
+    const localCreds = {
+        ...(defaultCredentials.apiVersion === API_VERSIONS.V3 && defaultCredentials),
+        ...credentials
+    };
+    const { accessToken } = localCreds;
+    assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+    assert(localCreds.apiVersion === API_VERSIONS.V3, 'Method only available for v3');
+    assert(localCreds.apiBaseUrl, 'Must define apiBaseUrl');
+    if (!localCreds.mapsUrl) {
+        localCreds.mapsUrl = buildMapsUrlFromBase(localCreds.apiBaseUrl);
+    }
+    if (autoRefresh || onNewData) {
+        assert(onNewData, 'Must define `onNewData` when using autoRefresh');
+        assert(typeof onNewData === 'function', '`onNewData` must be a function');
+        assert(typeof autoRefresh === 'number' && autoRefresh > 0, '`autoRefresh` must be a positive number');
+    }
+    const url = `${localCreds.mapsUrl}/public/${cartoMapId}`;
+    const map = await requestJson({ url, accessToken });
+    // Periodically check if the data has changed. Note that this
+    // will not update when a map is published.
+    let stopAutoRefresh;
+    if (autoRefresh) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        const intervalId = setInterval(async () => {
+            const changed = await fillInMapDatasets(map, clientId, localCreds);
+            if (onNewData && changed.some(v => v === true)) {
+                onNewData(parseMap(map));
+            }
+        }, autoRefresh * 1000);
+        stopAutoRefresh = () => {
+            clearInterval(intervalId);
+        };
+    }
+    const geojsonLayers = map.keplerMapConfig.config.visState.layers.filter(({ type }) => type === 'geojson' || type === 'point');
+    const geojsonDatasetIds = geojsonLayers.map(({ config }) => config.dataId);
+    map.datasets.forEach(dataset => {
+        if (geojsonDatasetIds.includes(dataset.id)) {
+            dataset.format = 'geojson';
+        }
+    });
+    // Mutates map.datasets so that dataset.data contains data
+    await fillInMapDatasets(map, clientId, localCreds);
+    return {
+        ...parseMap(map),
+        ...{ stopAutoRefresh }
+    };
+}

package/typed/api/parseMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseMap.d.ts","sourceRoot":"","sources":["../../src/api/parseMap.ts"],"names":[],"mappings":"AAmBA,wBAAgB,QAAQ,CAAC,IAAI,KAAA;;;;;;;;;;EAuC5B"}
+{"version":3,"file":"parseMap.d.ts","sourceRoot":"","sources":["../../src/api/parseMap.ts"],"names":[],"mappings":"AAmBA,wBAAgB,QAAQ,CAAC,IAAI,KAAA;;;;;;;;;;EAwC5B"}

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.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.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

@@ -7,7 +7,7 @@ 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, mapInstantiation as _mapInstantiation } from './api';
-export type { QueryParameters } from './api';
+export { FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS, CartoAPIError, fetchLayerData, fetchMap, getDataV2 as _getDataV2, mapInstantiation as _mapInstantiation } from './api';
+export type { APIErrorContext, QueryParameters } from './api';
 export type { CartoLayerProps } from './layers/carto-layer';
 //# sourceMappingURL=index.d.ts.map

package/typed/index.d.ts.map

@@ -1 +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,gBAAgB,IAAI,iBAAiB,EACtC,MAAM,OAAO,CAAC;AACf,YAAY,EAAC,eAAe,EAAC,MAAM,OAAO,CAAC;AAC3C,YAAY,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC"}
+{"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,aAAa,EACb,cAAc,EACd,QAAQ,EACR,SAAS,IAAI,UAAU,EACvB,gBAAgB,IAAI,iBAAiB,EACtC,MAAM,OAAO,CAAC;AACf,YAAY,EAAC,eAAe,EAAE,eAAe,EAAC,MAAM,OAAO,CAAC;AAC5D,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

@@ -1,4 +1,5 @@
 import { CompositeLayer, CompositeLayerProps, Layer, LayerProps, UpdateParameters } from '@deck.gl/core/typed';
+import { CartoAPIError } from '../api/carto-api-error';
 import { MapType, TileFormat, QueryParameters } from '../api/maps-api-common';
 import { Credentials } from '../config';
 import { Headers } from '../api/maps-v3-client';
@@ -64,9 +65,9 @@ declare type _CartoLayerProps = {
     /**
      * Called when the request to the CARTO Maps API failed.
      *
-     * By default the Error is thrown.
+     * By default the CartoAPIError is thrown.
      */
-    onDataError?: (err: unknown) => void;
+    onDataError?: (err: CartoAPIError) => void;
     clientId?: string;
     /** Custom headers to include in the map instantiation request **/
     headers?: Headers;

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

@@ -1 +1 @@
-{"version":3,"file":"carto-layer.d.ts","sourceRoot":"","sources":["../../src/layers/carto-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,EACL,UAAU,EAEV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAKvB,OAAO,EAIL,OAAO,EAEP,UAAU,EACV,eAAe,EAChB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAGL,WAAW,EAEZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAuB,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAiDpE,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,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;IAElB,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,iHAAiH;IACjH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,kDAAkD;IAClD,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,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,EAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAqB5D,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAsClC,oBAAoB,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC;IAuBzC,YAAY,IAAI,KAAK,GAAG,IAAI;CA4B7B"}
+{"version":3,"file":"carto-layer.d.ts","sourceRoot":"","sources":["../../src/layers/carto-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,EACL,UAAU,EAEV,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAC,aAAa,EAAC,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAIL,OAAO,EAEP,UAAU,EACV,eAAe,EAChB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAGL,WAAW,EAEZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAuB,OAAO,EAAC,MAAM,uBAAuB,CAAC;AAiDpE,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,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,aAAa,KAAK,IAAI,CAAC;IAE3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,iHAAiH;IACjH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,kDAAkD;IAClD,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,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,EAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAqB5D,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAsClC,oBAAoB,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC;IAuBzC,YAAY,IAAI,KAAK,GAAG,IAAI;CA4B7B"}