@deck.gl/carto 8.7.0-alpha.2 → 8.7.0-alpha.9

package/dist/es5/api/maps-v3-client.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -8,6 +10,12 @@ exports.fetchLayerData = fetchLayerData;
 exports.getData = getData;
 exports.fetchMap = fetchMap;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _config = require("../config");
 
 var _mapsApiCommon = require("./maps-api-common");
@@ -16,58 +24,92 @@ var _parseMap = require("./parseMap");
 
 var _core = require("@deck.gl/core");
 
-const MAX_GET_LENGTH = 2048;
-
-async function request({
-  method,
-  url,
-  format,
-  accessToken,
-  body
-}) {
-  let response;
-  const headers = {
-    Accept: 'application/json'
-  };
-
-  if (accessToken) {
-    headers.Authorization = "Bearer ".concat(accessToken);
-  }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-  if (method === 'POST') {
-    headers['Content-Type'] = 'application/json';
-  }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-  try {
-    response = await fetch(url, {
-      method,
-      headers,
-      body
-    });
-  } catch (error) {
-    throw new Error("Failed to connect to Maps API: ".concat(error));
-  }
+var MAX_GET_LENGTH = 2048;
 
-  if (format === _mapsApiCommon.FORMATS.NDJSON) {
-    return response;
-  }
-
-  const json = await response.json();
-
-  if (!response.ok) {
-    dealWithError({
-      response,
-      error: json.error
-    });
-  }
+function request(_x) {
+  return _request.apply(this, arguments);
+}
 
-  return json.rows ? json.rows : json;
+function _request() {
+  _request = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(_ref) {
+    var method, url, format, accessToken, body, response, headers, json;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            method = _ref.method, url = _ref.url, format = _ref.format, accessToken = _ref.accessToken, body = _ref.body;
+            headers = {
+              Accept: 'application/json'
+            };
+
+            if (accessToken) {
+              headers.Authorization = "Bearer ".concat(accessToken);
+            }
+
+            if (method === 'POST') {
+              headers['Content-Type'] = 'application/json';
+            }
+
+            _context.prev = 4;
+            _context.next = 7;
+            return fetch(url, {
+              method: method,
+              headers: headers,
+              body: body
+            });
+
+          case 7:
+            response = _context.sent;
+            _context.next = 13;
+            break;
+
+          case 10:
+            _context.prev = 10;
+            _context.t0 = _context["catch"](4);
+            throw new Error("Failed to connect to Maps API: ".concat(_context.t0));
+
+          case 13:
+            if (!(format === _mapsApiCommon.FORMATS.NDJSON)) {
+              _context.next = 15;
+              break;
+            }
+
+            return _context.abrupt("return", response);
+
+          case 15:
+            _context.next = 17;
+            return response.json();
+
+          case 17:
+            json = _context.sent;
+
+            if (!response.ok) {
+              dealWithError({
+                response: response,
+                error: json.error
+              });
+            }
+
+            return _context.abrupt("return", json.rows ? json.rows : json);
+
+          case 20:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[4, 10]]);
+  }));
+  return _request.apply(this, arguments);
 }
 
-function dealWithError({
-  response,
-  error
-}) {
+function dealWithError(_ref2) {
+  var response = _ref2.response,
+      error = _ref2.error;
+
   switch (response.status) {
     case 400:
       throw new Error("Bad request. ".concat(error));
@@ -81,20 +123,19 @@ function dealWithError({
   }
 }
 
-function getParameters({
-  type,
-  source,
-  geoColumn,
-  columns,
-  schema
-}) {
-  const parameters = [(0, _mapsApiCommon.encodeParameter)('client', 'deck-gl-carto')];
+function getParameters(_ref3) {
+  var type = _ref3.type,
+      source = _ref3.source,
+      geoColumn = _ref3.geoColumn,
+      columns = _ref3.columns,
+      schema = _ref3.schema;
+  var parameters = [(0, _mapsApiCommon.encodeParameter)('client', 'deck-gl-carto')];
 
   if (schema) {
     parameters.push((0, _mapsApiCommon.encodeParameter)('schema', true));
   }
 
-  const sourceName = type === _mapsApiCommon.MAP_TYPES.QUERY ? 'q' : 'name';
+  var sourceName = type === _mapsApiCommon.MAP_TYPES.QUERY ? 'q' : 'name';
   parameters.push((0, _mapsApiCommon.encodeParameter)(sourceName, source));
 
   if (type === _mapsApiCommon.MAP_TYPES.TABLE) {
@@ -110,51 +151,73 @@ function getParameters({
   return parameters.join('&');
 }
 
-async function mapInstantiation({
-  type,
-  source,
-  connection,
-  credentials,
-  geoColumn,
-  columns,
-  schema
-}) {
-  const baseUrl = "".concat(credentials.mapsUrl, "/").concat(connection, "/").concat(type);
-  const url = "".concat(baseUrl, "?").concat(getParameters({
-    type,
-    source,
-    geoColumn,
-    columns,
-    schema
-  }));
-  const {
-    accessToken
-  } = credentials;
-  const format = 'json';
-
-  if (url.length > MAX_GET_LENGTH && type === _mapsApiCommon.MAP_TYPES.QUERY) {
-    const body = JSON.stringify({
-      q: source,
-      client: 'deck-gl-carto'
-    });
-    return await request({
-      method: 'POST',
-      url: baseUrl,
-      format,
-      accessToken,
-      body
-    });
-  }
+function mapInstantiation(_x2) {
+  return _mapInstantiation.apply(this, arguments);
+}
 
-  return await request({
-    url,
-    format,
-    accessToken
-  });
+function _mapInstantiation() {
+  _mapInstantiation = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(_ref4) {
+    var type, source, connection, credentials, geoColumn, columns, schema, baseUrl, url, accessToken, format, body;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            type = _ref4.type, source = _ref4.source, connection = _ref4.connection, credentials = _ref4.credentials, geoColumn = _ref4.geoColumn, columns = _ref4.columns, schema = _ref4.schema;
+            baseUrl = "".concat(credentials.mapsUrl, "/").concat(connection, "/").concat(type);
+            url = "".concat(baseUrl, "?").concat(getParameters({
+              type: type,
+              source: source,
+              geoColumn: geoColumn,
+              columns: columns,
+              schema: schema
+            }));
+            accessToken = credentials.accessToken;
+            format = 'json';
+
+            if (!(url.length > MAX_GET_LENGTH && type === _mapsApiCommon.MAP_TYPES.QUERY)) {
+              _context2.next = 10;
+              break;
+            }
+
+            body = JSON.stringify({
+              q: source,
+              client: 'deck-gl-carto'
+            });
+            _context2.next = 9;
+            return request({
+              method: 'POST',
+              url: baseUrl,
+              format: format,
+              accessToken: accessToken,
+              body: body
+            });
+
+          case 9:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 10:
+            _context2.next = 12;
+            return request({
+              url: url,
+              format: format,
+              accessToken: accessToken
+            });
+
+          case 12:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _mapInstantiation.apply(this, arguments);
 }
 
 function getUrlFromMetadata(metadata, format) {
-  const m = metadata[format];
+  var m = metadata[format];
 
   if (m && !m.error && m.url) {
     return m.url[0];
@@ -163,12 +226,12 @@ function getUrlFromMetadata(metadata, format) {
   return null;
 }
 
-function checkFetchLayerDataParameters({
-  type,
-  source,
-  connection,
-  localCreds
-}) {
+function checkFetchLayerDataParameters(_ref5) {
+  var type = _ref5.type,
+      source = _ref5.source,
+      connection = _ref5.connection,
+      localCreds = _ref5.localCreds;
+
   _core.log.assert(connection, 'Must define connection');
 
   _core.log.assert(type, 'Must define a type');
@@ -182,233 +245,386 @@ function checkFetchLayerDataParameters({
   _core.log.assert(localCreds.accessToken, 'Must define an accessToken');
 }
 
-async function fetchLayerData({
-  type,
-  source,
-  connection,
-  credentials,
-  geoColumn,
-  columns,
-  format,
-  schema
-}) {
-  const {
-    url,
-    accessToken,
-    mapFormat,
-    metadata
-  } = await _fetchDataUrl({
-    type,
-    source,
-    connection,
-    credentials,
-    geoColumn,
-    columns,
-    format,
-    schema
-  });
-  const data = await request({
-    url,
-    format: mapFormat,
-    accessToken
-  });
-  const result = {
-    data,
-    format: mapFormat
-  };
-
-  if (schema) {
-    result.schema = metadata.schema;
-  }
-
-  return result;
+function fetchLayerData(_x3) {
+  return _fetchLayerData.apply(this, arguments);
 }
 
-async function _fetchDataUrl({
-  type,
-  source,
-  connection,
-  credentials,
-  geoColumn,
-  columns,
-  format,
-  schema
-}) {
-  const defaultCredentials = (0, _config.getDefaultCredentials)();
-  const localCreds = { ...(defaultCredentials.apiVersion === _mapsApiCommon.API_VERSIONS.V3 && defaultCredentials),
-    ...credentials
-  };
-  checkFetchLayerDataParameters({
-    type,
-    source,
-    connection,
-    localCreds
-  });
-
-  if (!localCreds.mapsUrl) {
-    localCreds.mapsUrl = (0, _config.buildMapsUrlFromBase)(localCreds.apiBaseUrl);
-  }
-
-  const metadata = await mapInstantiation({
-    type,
-    source,
-    connection,
-    credentials: localCreds,
-    geoColumn,
-    columns,
-    schema
-  });
-  let url;
-  let mapFormat;
-
-  if (format) {
-    mapFormat = format;
-    url = getUrlFromMetadata(metadata, format);
-
-    _core.log.assert(url, "Format ".concat(format, " not available"));
-  } else {
-    const prioritizedFormats = [_mapsApiCommon.FORMATS.GEOJSON, _mapsApiCommon.FORMATS.JSON, _mapsApiCommon.FORMATS.NDJSON, _mapsApiCommon.FORMATS.TILEJSON];
-
-    for (const f of prioritizedFormats) {
-      url = getUrlFromMetadata(metadata, f);
-
-      if (url) {
-        mapFormat = f;
-        break;
+function _fetchLayerData() {
+  _fetchLayerData = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(_ref6) {
+    var type, source, connection, credentials, geoColumn, columns, format, schema, _yield$_fetchDataUrl, url, accessToken, mapFormat, metadata, data, result;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            type = _ref6.type, source = _ref6.source, connection = _ref6.connection, credentials = _ref6.credentials, geoColumn = _ref6.geoColumn, columns = _ref6.columns, format = _ref6.format, schema = _ref6.schema;
+            _context3.next = 3;
+            return _fetchDataUrl({
+              type: type,
+              source: source,
+              connection: connection,
+              credentials: credentials,
+              geoColumn: geoColumn,
+              columns: columns,
+              format: format,
+              schema: schema
+            });
+
+          case 3:
+            _yield$_fetchDataUrl = _context3.sent;
+            url = _yield$_fetchDataUrl.url;
+            accessToken = _yield$_fetchDataUrl.accessToken;
+            mapFormat = _yield$_fetchDataUrl.mapFormat;
+            metadata = _yield$_fetchDataUrl.metadata;
+            _context3.next = 10;
+            return request({
+              url: url,
+              format: mapFormat,
+              accessToken: accessToken
+            });
+
+          case 10:
+            data = _context3.sent;
+            result = {
+              data: data,
+              format: mapFormat
+            };
+
+            if (schema) {
+              result.schema = metadata.schema;
+            }
+
+            return _context3.abrupt("return", result);
+
+          case 14:
+          case "end":
+            return _context3.stop();
+        }
       }
-    }
-  }
-
-  const {
-    accessToken
-  } = localCreds;
-  return {
-    url,
-    accessToken,
-    mapFormat,
-    metadata
-  };
+    }, _callee3);
+  }));
+  return _fetchLayerData.apply(this, arguments);
 }
 
-async function getData({
-  type,
-  source,
-  connection,
-  credentials,
-  geoColumn,
-  columns,
-  format
-}) {
-  _core.log.deprecated('getData', 'fetchLayerData')();
-
-  const layerData = await fetchLayerData({
-    type,
-    source,
-    connection,
-    credentials,
-    geoColumn,
-    columns,
-    format,
-    schema: false
-  });
-  return layerData.data;
+function _fetchDataUrl(_x4) {
+  return _fetchDataUrl2.apply(this, arguments);
 }
 
-async function _fetchMapDataset(dataset, accessToken) {
-  const {
-    connectionName: connection,
-    source,
-    type
-  } = dataset;
-  const {
-    url,
-    mapFormat
-  } = await _fetchDataUrl({
-    credentials: {
-      accessToken
-    },
-    connection,
-    source,
-    type
-  });
-  const cache = parseInt(new URLSearchParams(url).get('cache'), 10);
-
-  if (cache && dataset.cache === cache) {
-    return false;
-  }
-
-  dataset.cache = cache;
-  const data = await request({
-    url,
-    format: mapFormat,
-    accessToken
-  });
-  dataset.data = data;
-  return true;
+function _fetchDataUrl2() {
+  _fetchDataUrl2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(_ref7) {
+    var type, source, connection, credentials, geoColumn, columns, format, schema, defaultCredentials, localCreds, metadata, url, mapFormat, prioritizedFormats, _i, _prioritizedFormats, f, accessToken;
+
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            type = _ref7.type, source = _ref7.source, connection = _ref7.connection, credentials = _ref7.credentials, geoColumn = _ref7.geoColumn, columns = _ref7.columns, format = _ref7.format, schema = _ref7.schema;
+            defaultCredentials = (0, _config.getDefaultCredentials)();
+            localCreds = _objectSpread(_objectSpread({}, defaultCredentials.apiVersion === _mapsApiCommon.API_VERSIONS.V3 && defaultCredentials), credentials);
+            checkFetchLayerDataParameters({
+              type: type,
+              source: source,
+              connection: connection,
+              localCreds: localCreds
+            });
+
+            if (!localCreds.mapsUrl) {
+              localCreds.mapsUrl = (0, _config.buildMapsUrlFromBase)(localCreds.apiBaseUrl);
+            }
+
+            _context4.next = 7;
+            return mapInstantiation({
+              type: type,
+              source: source,
+              connection: connection,
+              credentials: localCreds,
+              geoColumn: geoColumn,
+              columns: columns,
+              schema: schema
+            });
+
+          case 7:
+            metadata = _context4.sent;
+
+            if (!format) {
+              _context4.next = 14;
+              break;
+            }
+
+            mapFormat = format;
+            url = getUrlFromMetadata(metadata, format);
+
+            _core.log.assert(url, "Format ".concat(format, " not available"));
+
+            _context4.next = 25;
+            break;
+
+          case 14:
+            prioritizedFormats = [_mapsApiCommon.FORMATS.GEOJSON, _mapsApiCommon.FORMATS.JSON, _mapsApiCommon.FORMATS.NDJSON, _mapsApiCommon.FORMATS.TILEJSON];
+            _i = 0, _prioritizedFormats = prioritizedFormats;
+
+          case 16:
+            if (!(_i < _prioritizedFormats.length)) {
+              _context4.next = 25;
+              break;
+            }
+
+            f = _prioritizedFormats[_i];
+            url = getUrlFromMetadata(metadata, f);
+
+            if (!url) {
+              _context4.next = 22;
+              break;
+            }
+
+            mapFormat = f;
+            return _context4.abrupt("break", 25);
+
+          case 22:
+            _i++;
+            _context4.next = 16;
+            break;
+
+          case 25:
+            accessToken = localCreds.accessToken;
+            return _context4.abrupt("return", {
+              url: url,
+              accessToken: accessToken,
+              mapFormat: mapFormat,
+              metadata: metadata
+            });
+
+          case 27:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _fetchDataUrl2.apply(this, arguments);
 }
 
-async function fillInMapDatasets({
-  datasets,
-  publicToken
-}) {
-  const promises = datasets.map(dataset => _fetchMapDataset(dataset, publicToken));
-  return await Promise.all(promises);
+function getData(_x5) {
+  return _getData.apply(this, arguments);
 }
 
-async function fetchMap({
-  cartoMapId,
-  credentials,
-  autoRefresh,
-  onNewData
-}) {
-  const defaultCredentials = (0, _config.getDefaultCredentials)();
-  const localCreds = { ...(defaultCredentials.apiVersion === _mapsApiCommon.API_VERSIONS.V3 && defaultCredentials),
-    ...credentials
-  };
-
-  _core.log.assert(cartoMapId, "Must define CARTO map id: fetchMap({cartoMapId: 'XXXX-XXXX-XXXX'})");
-
-  _core.log.assert(localCreds.apiVersion === _mapsApiCommon.API_VERSIONS.V3, 'Method only available for v3');
-
-  _core.log.assert(localCreds.apiBaseUrl, 'Must define apiBaseUrl');
-
-  if (!localCreds.mapsUrl) {
-    localCreds.mapsUrl = (0, _config.buildMapsUrlFromBase)(localCreds.apiBaseUrl);
-  }
-
-  if (autoRefresh || onNewData) {
-    _core.log.assert(onNewData, 'Must define `onNewData` when using autoRefresh');
-
-    _core.log.assert(typeof onNewData === 'function', '`onNewData` must be a function');
+function _getData() {
+  _getData = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5(_ref8) {
+    var type, source, connection, credentials, geoColumn, columns, format, layerData;
+    return _regenerator.default.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            type = _ref8.type, source = _ref8.source, connection = _ref8.connection, credentials = _ref8.credentials, geoColumn = _ref8.geoColumn, columns = _ref8.columns, format = _ref8.format;
+
+            _core.log.deprecated('getData', 'fetchLayerData')();
+
+            _context5.next = 4;
+            return fetchLayerData({
+              type: type,
+              source: source,
+              connection: connection,
+              credentials: credentials,
+              geoColumn: geoColumn,
+              columns: columns,
+              format: format,
+              schema: false
+            });
+
+          case 4:
+            layerData = _context5.sent;
+            return _context5.abrupt("return", layerData.data);
+
+          case 6:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getData.apply(this, arguments);
+}
 
-    _core.log.assert(autoRefresh > 0, '`autoRefresh` must be a positive number');
-  }
+function _fetchMapDataset(_x6, _x7, _x8) {
+  return _fetchMapDataset2.apply(this, arguments);
+}
 
-  const url = "".concat(localCreds.mapsUrl, "/public/").concat(cartoMapId);
-  const map = await request({
-    url
-  });
-  let stopAutoRefresh;
+function _fetchMapDataset2() {
+  _fetchMapDataset2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee6(dataset, accessToken, credentials) {
+    var connection, source, type, _yield$_fetchDataUrl2, url, mapFormat, cache, data;
+
+    return _regenerator.default.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            connection = dataset.connectionName, source = dataset.source, type = dataset.type;
+            _context6.next = 3;
+            return _fetchDataUrl({
+              credentials: _objectSpread(_objectSpread({}, credentials), {}, {
+                accessToken: accessToken
+              }),
+              connection: connection,
+              source: source,
+              type: type
+            });
+
+          case 3:
+            _yield$_fetchDataUrl2 = _context6.sent;
+            url = _yield$_fetchDataUrl2.url;
+            mapFormat = _yield$_fetchDataUrl2.mapFormat;
+            cache = parseInt(new URLSearchParams(url).get('cache'), 10);
+
+            if (!(cache && dataset.cache === cache)) {
+              _context6.next = 9;
+              break;
+            }
+
+            return _context6.abrupt("return", false);
+
+          case 9:
+            dataset.cache = cache;
+            _context6.next = 12;
+            return request({
+              url: url,
+              format: mapFormat,
+              accessToken: accessToken
+            });
+
+          case 12:
+            data = _context6.sent;
+            dataset.data = data;
+            return _context6.abrupt("return", true);
+
+          case 15:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _fetchMapDataset2.apply(this, arguments);
+}
 
-  if (autoRefresh) {
-    const intervalId = setInterval(async () => {
-      const changed = await fillInMapDatasets(map);
+function fillInMapDatasets(_x9, _x10) {
+  return _fillInMapDatasets.apply(this, arguments);
+}
 
-      if (changed.some(v => v === true)) {
-        onNewData((0, _parseMap.parseMap)(map));
+function _fillInMapDatasets() {
+  _fillInMapDatasets = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee7(_ref9, credentials) {
+    var datasets, token, promises;
+    return _regenerator.default.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            datasets = _ref9.datasets, token = _ref9.token;
+            promises = datasets.map(function (dataset) {
+              return _fetchMapDataset(dataset, token, credentials);
+            });
+            _context7.next = 4;
+            return Promise.all(promises);
+
+          case 4:
+            return _context7.abrupt("return", _context7.sent);
+
+          case 5:
+          case "end":
+            return _context7.stop();
+        }
       }
-    }, autoRefresh * 1000);
+    }, _callee7);
+  }));
+  return _fillInMapDatasets.apply(this, arguments);
+}
 
-    stopAutoRefresh = () => {
-      clearInterval(intervalId);
-    };
-  }
+function fetchMap(_x11) {
+  return _fetchMap.apply(this, arguments);
+}
 
-  await fillInMapDatasets(map);
-  return { ...(0, _parseMap.parseMap)(map),
-    ...{
-      stopAutoRefresh
-    }
-  };
+function _fetchMap() {
+  _fetchMap = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee9(_ref10) {
+    var cartoMapId, credentials, autoRefresh, onNewData, defaultCredentials, localCreds, url, map, stopAutoRefresh, intervalId;
+    return _regenerator.default.wrap(function _callee9$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            cartoMapId = _ref10.cartoMapId, credentials = _ref10.credentials, autoRefresh = _ref10.autoRefresh, onNewData = _ref10.onNewData;
+            defaultCredentials = (0, _config.getDefaultCredentials)();
+            localCreds = _objectSpread(_objectSpread({}, defaultCredentials.apiVersion === _mapsApiCommon.API_VERSIONS.V3 && defaultCredentials), credentials);
+
+            _core.log.assert(cartoMapId, "Must define CARTO map id: fetchMap({cartoMapId: 'XXXX-XXXX-XXXX'})");
+
+            _core.log.assert(localCreds.apiVersion === _mapsApiCommon.API_VERSIONS.V3, 'Method only available for v3');
+
+            _core.log.assert(localCreds.apiBaseUrl, 'Must define apiBaseUrl');
+
+            if (!localCreds.mapsUrl) {
+              localCreds.mapsUrl = (0, _config.buildMapsUrlFromBase)(localCreds.apiBaseUrl);
+            }
+
+            if (autoRefresh || onNewData) {
+              _core.log.assert(onNewData, 'Must define `onNewData` when using autoRefresh');
+
+              _core.log.assert(typeof onNewData === 'function', '`onNewData` must be a function');
+
+              _core.log.assert(autoRefresh > 0, '`autoRefresh` must be a positive number');
+            }
+
+            url = "".concat(localCreds.mapsUrl, "/public/").concat(cartoMapId);
+            _context9.next = 11;
+            return request({
+              url: url
+            });
+
+          case 11:
+            map = _context9.sent;
+
+            if (autoRefresh) {
+              intervalId = setInterval((0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee8() {
+                var changed;
+                return _regenerator.default.wrap(function _callee8$(_context8) {
+                  while (1) {
+                    switch (_context8.prev = _context8.next) {
+                      case 0:
+                        _context8.next = 2;
+                        return fillInMapDatasets(map, credentials);
+
+                      case 2:
+                        changed = _context8.sent;
+
+                        if (changed.some(function (v) {
+                          return v === true;
+                        })) {
+                          onNewData((0, _parseMap.parseMap)(map));
+                        }
+
+                      case 4:
+                      case "end":
+                        return _context8.stop();
+                    }
+                  }
+                }, _callee8);
+              })), autoRefresh * 1000);
+
+              stopAutoRefresh = function stopAutoRefresh() {
+                clearInterval(intervalId);
+              };
+            }
+
+            _context9.next = 15;
+            return fillInMapDatasets(map, credentials);
+
+          case 15:
+            return _context9.abrupt("return", _objectSpread(_objectSpread({}, (0, _parseMap.parseMap)(map)), {
+              stopAutoRefresh: stopAutoRefresh
+            }));
+
+          case 16:
+          case "end":
+            return _context9.stop();
+        }
+      }
+    }, _callee9);
+  }));
+  return _fetchMap.apply(this, arguments);
 }
 //# sourceMappingURL=maps-v3-client.js.map