@deck.gl/carto 8.8.19 → 8.8.20

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

@@ -1,304 +0,0 @@
-/**
- * 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.js

@@ -1,178 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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.js

@@ -1,10 +0,0 @@
-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';