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

package/typed/api/maps-api-common.js

@@ -0,0 +1,50 @@
+export const DEFAULT_USER_COMPONENT_IN_URL = '{user}';
+export const DEFAULT_REGION_COMPONENT_IN_URL = '{region}';
+export const API_VERSIONS = {
+    V1: 'v1',
+    V2: 'v2',
+    V3: 'v3'
+};
+export const DEFAULT_MAPS_URL_FORMAT = {
+    [API_VERSIONS.V1]: `https://${DEFAULT_USER_COMPONENT_IN_URL}.carto.com/api/v1/map`,
+    [API_VERSIONS.V2]: `https://maps-api-v2.${DEFAULT_REGION_COMPONENT_IN_URL}.carto.com/user/${DEFAULT_USER_COMPONENT_IN_URL}`
+};
+export const MAP_TYPES = {
+    QUERY: 'query',
+    TABLE: 'table',
+    TILESET: 'tileset'
+};
+export const COLUMNS_SUPPORT = [MAP_TYPES.TABLE];
+export const GEO_COLUMN_SUPPORT = [MAP_TYPES.QUERY, MAP_TYPES.TABLE];
+// AVAILABLE FORMATS
+export const FORMATS = {
+    GEOJSON: 'geojson',
+    NDJSON: 'ndjson',
+    TILEJSON: 'tilejson',
+    JSON: 'json'
+};
+// AVAILABLE FORMATS FOR TILES
+export const TILE_FORMATS = {
+    MVT: 'mvt',
+    JSON: 'json',
+    GEOJSON: 'geojson',
+    BINARY: 'binary'
+};
+export var SchemaFieldType;
+(function (SchemaFieldType) {
+    SchemaFieldType["Number"] = "number";
+    SchemaFieldType["Bigint"] = "bigint";
+    SchemaFieldType["String"] = "string";
+    SchemaFieldType["Geometry"] = "geometry";
+    SchemaFieldType["Timestamp"] = "timestamp";
+    SchemaFieldType["Object"] = "object";
+    SchemaFieldType["Boolean"] = "boolean";
+    SchemaFieldType["Variant"] = "variant";
+    SchemaFieldType["Unknown"] = "unknown";
+})(SchemaFieldType || (SchemaFieldType = {}));
+/**
+ * Simple encode parameter
+ */
+export function encodeParameter(name, value) {
+    return `${name}=${encodeURIComponent(value)}`;
+}

package/typed/api/maps-client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Maps API Client for Maps API v1 and Maps API v2
+ */
+import { ClassicCredentials } from '../config';
+import { MapType } from './maps-api-common';
+export declare const CONNECTIONS: {
+    BIGQUERY: string;
+    CARTO: string;
+};
+/**
+ * Obtain a TileJson from Maps API v1 and v2
+ */
+export declare function getDataV2({ type, source, credentials }: {
+    type: MapType;
+    source: string;
+    credentials?: Partial<ClassicCredentials>;
+}): Promise<any>;
+//# sourceMappingURL=maps-client.d.ts.map

package/typed/api/maps-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps-client.d.ts","sourceRoot":"","sources":["../../src/api/maps-client.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,kBAAkB,EAInB,MAAM,WAAW,CAAC;AACnB,OAAO,EAML,OAAO,EAER,MAAM,mBAAmB,CAAC;AAE3B,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAKF;;GAEG;AACH,wBAAsB,SAAS,CAAC,EAC9B,IAAI,EACJ,MAAM,EACN,WAAW,EACZ,EAAE;IACD,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAC3C,gBAkCA"}

package/typed/api/maps-client.js

@@ -0,0 +1,125 @@
+/**
+ * Maps API Client for Maps API v1 and Maps API v2
+ */
+import { defaultClassicCredentials, defaultCloudNativeCredentials, getDefaultCredentials } from '../config';
+import { API_VERSIONS, DEFAULT_MAPS_URL_FORMAT, DEFAULT_REGION_COMPONENT_IN_URL, DEFAULT_USER_COMPONENT_IN_URL, encodeParameter, MAP_TYPES } from './maps-api-common';
+export const CONNECTIONS = {
+    BIGQUERY: 'bigquery',
+    CARTO: 'carto'
+};
+const BUFFER_SIZE = 16;
+const TILE_EXTENT = 4096;
+/**
+ * Obtain a TileJson from Maps API v1 and v2
+ */
+export async function getDataV2({ type, source, credentials }) {
+    const defaultCredentials = getDefaultCredentials();
+    const apiVersion = credentials?.apiVersion || defaultCredentials.apiVersion;
+    // Only pick up default credentials if they have been defined for
+    // correct API version
+    const localCreds = {
+        ...(apiVersion === API_VERSIONS.V3 ? defaultCloudNativeCredentials : defaultClassicCredentials),
+        mapsUrl: DEFAULT_MAPS_URL_FORMAT[apiVersion],
+        ...(defaultCredentials.apiVersion === apiVersion && defaultCredentials),
+        ...credentials
+    };
+    let url;
+    const connection = type === MAP_TYPES.TILESET ? CONNECTIONS.BIGQUERY : CONNECTIONS.CARTO;
+    switch (apiVersion) {
+        case API_VERSIONS.V1:
+            // Maps API v1
+            const mapConfig = createMapConfig(source);
+            url = buildURLMapsAPIv1({ mapConfig, credentials: localCreds });
+            const layergroup = await request({ url, credentials: localCreds });
+            return layergroup.metadata.tilejson.vector;
+        case API_VERSIONS.V2:
+            // Maps API v2
+            url = buildURLMapsAPIv2({ connection, type, source, credentials: localCreds });
+            return await request({ url, credentials: localCreds });
+        default:
+            throw new Error(`Invalid maps API version. It should be ${API_VERSIONS.V1} or ${API_VERSIONS.V2}`);
+    }
+}
+/**
+ * Request against Maps API
+ */
+async function request({ url, credentials }) {
+    let response;
+    try {
+        /* global fetch */
+        response = await fetch(url, {
+            headers: {
+                Accept: 'application/json'
+            }
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to connect to Maps API: ${error}`);
+    }
+    const json = await response.json();
+    if (!response.ok) {
+        dealWithError({ response, json, credentials });
+    }
+    return json;
+}
+/**
+ * Display proper message from Maps API error
+ */
+function dealWithError({ response, json, credentials }) {
+    switch (response.status) {
+        case 401:
+            throw new Error(`Unauthorized access to Maps API: invalid combination of user ('${credentials.username}') and apiKey ('${credentials.apiKey}')`);
+        case 403:
+            throw new Error(`Unauthorized access to dataset: the provided apiKey('${credentials.apiKey}') doesn't provide access to the requested data`);
+        default:
+            const e = credentials.apiVersion === API_VERSIONS.V1 ? JSON.stringify(json.errors) : json.error;
+            throw new Error(e);
+    }
+}
+function initURLParameters(credentials) {
+    const encodedApiKey = encodeParameter('api_key', credentials.apiKey);
+    const encodedClient = encodeParameter('client', 'deck-gl-carto');
+    return [encodedApiKey, encodedClient];
+}
+/**
+ * Build a URL with all required parameters
+ */
+function buildURLMapsAPIv1({ mapConfig, credentials }) {
+    const parameters = initURLParameters(credentials);
+    const cfg = JSON.stringify(mapConfig);
+    return `${mapsUrl(credentials)}?${parameters.join('&')}&${encodeParameter('config', cfg)}`;
+}
+function buildURLMapsAPIv2({ connection, type, source, credentials }) {
+    const parameters = initURLParameters(credentials);
+    // Query type is mapped to 'sql' at maps api v1
+    const mapsApiType = type === MAP_TYPES.QUERY ? 'sql' : type;
+    let url = `${mapsUrl(credentials)}/${connection}/${mapsApiType}?`;
+    url += `${encodeParameter('source', source)}&format=tilejson&${parameters.join('&')}`;
+    return url;
+}
+/**
+ * Prepare a url valid for the specified user
+ */
+function mapsUrl(credentials) {
+    return credentials.mapsUrl
+        .replace(DEFAULT_USER_COMPONENT_IN_URL, credentials.username)
+        .replace(DEFAULT_REGION_COMPONENT_IN_URL, credentials.region);
+}
+function createMapConfig(sql) {
+    return {
+        version: '1.3.1',
+        buffersize: {
+            mvt: BUFFER_SIZE
+        },
+        layers: [
+            {
+                type: 'mapnik',
+                options: {
+                    sql,
+                    // eslint-disable-next-line camelcase
+                    vector_extent: TILE_EXTENT
+                }
+            }
+        ]
+    };
+}

package/typed/api/maps-v3-client.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Maps API Client for Carto 3
+ */
+import { CloudNativeCredentials } from '../config';
+import { Format, MapInstantiation, MapType, SchemaField, TileFormat } from './maps-api-common';
+declare type FetchLayerDataParams = {
+    type: MapType;
+    source: string;
+    connection: string;
+    credentials: CloudNativeCredentials;
+    geoColumn?: string;
+    columns?: string[];
+    clientId?: string;
+    format?: Format;
+    formatTiles?: TileFormat;
+    aggregationExp?: string;
+    aggregationResLevel?: number;
+};
+export declare function mapInstantiation({ type, source, connection, credentials, geoColumn, columns, clientId, aggregationExp, aggregationResLevel }: FetchLayerDataParams): Promise<MapInstantiation>;
+export interface FetchLayerDataResult {
+    data: any;
+    format?: Format;
+    schema: SchemaField[];
+}
+export declare function fetchLayerData({ type, source, connection, credentials, geoColumn, columns, format, formatTiles, clientId, aggregationExp, aggregationResLevel }: FetchLayerDataParams): Promise<FetchLayerDataResult>;
+export declare function getData({ type, source, connection, credentials, geoColumn, columns, format, clientId }: FetchLayerDataParams): Promise<any>;
+export declare function fetchMap({ cartoMapId, clientId, credentials, autoRefresh, onNewData }: {
+    cartoMapId: string;
+    clientId: string;
+    credentials?: CloudNativeCredentials;
+    autoRefresh?: number;
+    onNewData?: (map: any) => void;
+}): Promise<{
+    stopAutoRefresh: (() => void) | undefined;
+    id: any;
+    title: any;
+    description: any;
+    createdAt: any;
+    updatedAt: any;
+    initialViewState: any;
+    mapStyle: any;
+    layers: (import("@deck.gl/core").Layer<{}> | undefined)[];
+}>;
+export {};
+//# sourceMappingURL=maps-v3-client.d.ts.map

package/typed/api/maps-v3-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps-v3-client.d.ts","sourceRoot":"","sources":["../../src/api/maps-v3-client.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAA8C,sBAAsB,EAAC,MAAM,WAAW,CAAC;AAC9F,OAAO,EAIL,MAAM,EAGN,gBAAgB,EAChB,OAAO,EAEP,WAAW,EACX,UAAU,EAEX,MAAM,mBAAmB,CAAC;AA0F3B,aAAK,oBAAoB,GAAG;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,sBAAsB,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAmCF,wBAAsB,gBAAgB,CAAC,EACrC,IAAI,EACJ,MAAM,EACN,UAAU,EACV,WAAW,EACX,SAAS,EACT,OAAO,EACP,QAAQ,EACR,cAAc,EACd,mBAAmB,EACpB,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAuBlD;AAsDD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,GAAG,CAAC;IACV,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AACD,wBAAsB,cAAc,CAAC,EACnC,IAAI,EACJ,MAAM,EACN,UAAU,EACV,WAAW,EACX,SAAS,EACT,OAAO,EACP,MAAM,EACN,WAAW,EACX,QAAQ,EACR,cAAc,EACd,mBAAmB,EACpB,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAoBtD;AAgFD,wBAAsB,OAAO,CAAC,EAC5B,IAAI,EACJ,MAAM,EACN,UAAU,EACV,WAAW,EACX,SAAS,EACT,OAAO,EACP,MAAM,EACN,QAAQ,EACT,EAAE,oBAAoB,gBAatB;AA4CD,wBAAsB,QAAQ,CAAC,EAC7B,UAAU,EACV,QAAQ,EACR,WAAW,EACX,WAAW,EACX,SAAS,EACV,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAC;CAChC;4BA8B6B,IAAI;;;;;;;;;GA8BjC"}

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

@@ -0,0 +1,11 @@
+export declare function parseMap(json: any): {
+    id: any;
+    title: any;
+    description: any;
+    createdAt: any;
+    updatedAt: any;
+    initialViewState: any;
+    mapStyle: any;
+    layers: (import("@deck.gl/core").Layer<{}> | undefined)[];
+};
+//# sourceMappingURL=parseMap.d.ts.map

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

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