@deck.gl/carto 8.10.0-alpha.7 → 9.0.0-alpha.3

package/dist/es5/api/carto-api-error.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/api/carto-api-error.ts"],"names":["CartoAPIError","error","errorContext","response","responseString","status","message","requestType","Object","keys","key","formatErrorKey","name","Error","replace","s","toUpperCase"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;IAgBaA,a;;;;;AAUX,yBAAYC,KAAZ,EAA0BC,YAA1B,EAAyDC,QAAzD,EAA8E;AAAA;;AAAA;AAC5E,QAAIC,cAAc,GAAG,mBAArB;;AACA,QAAID,QAAJ,EAAc;AACZC,MAAAA,cAAc,GAAG,mBAAjB;;AACA,UAAID,QAAQ,CAACE,MAAT,KAAoB,GAAxB,EAA6B;AAC3BD,QAAAA,cAAc,IAAI,aAAlB;AACD,OAFD,MAEO,IAAID,QAAQ,CAACE,MAAT,KAAoB,GAApB,IAA2BF,QAAQ,CAACE,MAAT,KAAoB,GAAnD,EAAwD;AAC7DD,QAAAA,cAAc,IAAI,qBAAlB;AACD,OAFM,MAEA,IAAID,QAAQ,CAACE,MAAT,KAAoB,GAAxB,EAA6B;AAClCD,QAAAA,cAAc,IAAI,WAAlB;AACD,OAFM,MAEA;AACLA,QAAAA,cAAc,IAAI,OAAlB;AACD;;AAEDA,MAAAA,cAAc,gBAASD,QAAQ,CAACE,MAAlB,OAAd;AACD;;AACDD,IAAAA,cAAc,eAAQH,KAAK,CAACK,OAAN,IAAiBL,KAAzB,CAAd;AAEA,QAAIK,OAAO,aAAMJ,YAAY,CAACK,WAAnB,wBAAX;AACAD,IAAAA,OAAO,gBAASF,cAAT,CAAP;;AACA,oCAAkBI,MAAM,CAACC,IAAP,CAAYP,YAAZ,CAAlB,kCAA6C;AAAxC,UAAMQ,GAAG,mBAAT;AACH,UAAIA,GAAG,KAAK,aAAZ,EAA2B;AAC3BJ,MAAAA,OAAO,gBAASK,cAAc,CAACD,GAAD,CAAvB,eAAiCR,YAAY,CAACQ,GAAD,CAA7C,CAAP;AACD;;AACDJ,IAAAA,OAAO,IAAI,IAAX;AAEA,8BAAMA,OAAN;AA1B4E,UAR9EL,KAQ8E;AAAA,UAL9EC,YAK8E;AAAA,UAF9EC,QAE8E;AA4B5E,UAAKS,IAAL,GAAY,eAAZ;AACA,UAAKT,QAAL,GAAgBA,QAAhB;AACA,UAAKF,KAAL,GAAaA,KAAb;AACA,UAAKC,YAAL,GAAoBA,YAApB;AA/B4E;AAgC7E;;;iCA1CgCW,K;;;;AAgDnC,SAASF,cAAT,CAAwBD,GAAxB,EAA6B;AAC3B,SAAOA,GAAG,CAACI,OAAJ,CAAY,UAAZ,EAAwB,KAAxB,EAA+BA,OAA/B,CAAuC,IAAvC,EAA6C,UAAAC,CAAC;AAAA,WAAIA,CAAC,CAACC,WAAF,EAAJ;AAAA,GAA9C,CAAP;AACD","sourcesContent":["import {MapType, RequestType} from './maps-api-common';\n\nexport type APIErrorContext = {\n  requestType: RequestType;\n  mapId?: string;\n  connection?: string;\n  source?: string;\n  type?: MapType;\n};\n\n/**\n *\n * Custom error for reported errors in CARTO Maps API.\n * Provides useful debugging information in console and context for applications.\n *\n */\nexport class CartoAPIError extends Error {\n  /** Source error from server */\n  error: Error;\n\n  /** Context (API call & parameters) in which error occured */\n  errorContext: APIErrorContext;\n\n  /** Response from server */\n  response?: Response;\n\n  constructor(error: Error, errorContext: APIErrorContext, response?: Response) {\n    let responseString = 'Failed to connect';\n    if (response) {\n      responseString = 'Server returned: ';\n      if (response.status === 400) {\n        responseString += 'Bad request';\n      } else if (response.status === 401 || response.status === 403) {\n        responseString += 'Unauthorized access';\n      } else if (response.status === 404) {\n        responseString += 'Not found';\n      } else {\n        responseString += 'Error';\n      }\n\n      responseString += ` (${response.status}):`;\n    }\n    responseString += ` ${error.message || error}`;\n\n    let message = `${errorContext.requestType} API request failed`;\n    message += `\\n${responseString}`;\n    for (const key of Object.keys(errorContext)) {\n      if (key === 'requestType') continue; // eslint-disable-line no-continue\n      message += `\\n${formatErrorKey(key)}: ${errorContext[key]}`;\n    }\n    message += '\\n';\n\n    super(message);\n\n    this.name = 'CartoAPIError';\n    this.response = response;\n    this.error = error;\n    this.errorContext = errorContext;\n  }\n}\n\n/**\n * Converts camelCase to Camel Case\n */\nfunction formatErrorKey(key) {\n  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());\n}\n"],"file":"carto-api-error.js"}
+{"version":3,"sources":["../../../src/api/carto-api-error.ts"],"names":["CartoAPIError","error","errorContext","response","responseString","status","message","requestType","Object","keys","key","formatErrorKey","name","Error","replace","s","toUpperCase"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;IAQaA,a;;;;;AAUX,yBAAYC,KAAZ,EAA0BC,YAA1B,EAAyDC,QAAzD,EAA8E;AAAA;;AAAA;AAC5E,QAAIC,cAAc,GAAG,mBAArB;;AACA,QAAID,QAAJ,EAAc;AACZC,MAAAA,cAAc,GAAG,mBAAjB;;AACA,UAAID,QAAQ,CAACE,MAAT,KAAoB,GAAxB,EAA6B;AAC3BD,QAAAA,cAAc,IAAI,aAAlB;AACD,OAFD,MAEO,IAAID,QAAQ,CAACE,MAAT,KAAoB,GAApB,IAA2BF,QAAQ,CAACE,MAAT,KAAoB,GAAnD,EAAwD;AAC7DD,QAAAA,cAAc,IAAI,qBAAlB;AACD,OAFM,MAEA,IAAID,QAAQ,CAACE,MAAT,KAAoB,GAAxB,EAA6B;AAClCD,QAAAA,cAAc,IAAI,WAAlB;AACD,OAFM,MAEA;AACLA,QAAAA,cAAc,IAAI,OAAlB;AACD;;AAEDA,MAAAA,cAAc,gBAASD,QAAQ,CAACE,MAAlB,OAAd;AACD;;AACDD,IAAAA,cAAc,eAAQH,KAAK,CAACK,OAAN,IAAiBL,KAAzB,CAAd;AAEA,QAAIK,OAAO,aAAMJ,YAAY,CAACK,WAAnB,wBAAX;AACAD,IAAAA,OAAO,gBAASF,cAAT,CAAP;;AACA,oCAAkBI,MAAM,CAACC,IAAP,CAAYP,YAAZ,CAAlB,kCAA6C;AAAxC,UAAMQ,GAAG,mBAAT;AACH,UAAIA,GAAG,KAAK,aAAZ,EAA2B;AAC3BJ,MAAAA,OAAO,gBAASK,cAAc,CAACD,GAAD,CAAvB,eAAiCR,YAAY,CAACQ,GAAD,CAA7C,CAAP;AACD;;AACDJ,IAAAA,OAAO,IAAI,IAAX;AAEA,8BAAMA,OAAN;AA1B4E,UAR9EL,KAQ8E;AAAA,UAL9EC,YAK8E;AAAA,UAF9EC,QAE8E;AA4B5E,UAAKS,IAAL,GAAY,eAAZ;AACA,UAAKT,QAAL,GAAgBA,QAAhB;AACA,UAAKF,KAAL,GAAaA,KAAb;AACA,UAAKC,YAAL,GAAoBA,YAApB;AA/B4E;AAgC7E;;;iCA1CgCW,K;;;;AAgDnC,SAASF,cAAT,CAAwBD,GAAxB,EAA6B;AAC3B,SAAOA,GAAG,CAACI,OAAJ,CAAY,UAAZ,EAAwB,KAAxB,EAA+BA,OAA/B,CAAuC,IAAvC,EAA6C,UAAAC,CAAC;AAAA,WAAIA,CAAC,CAACC,WAAF,EAAJ;AAAA,GAA9C,CAAP;AACD","sourcesContent":["import type {APIErrorContext} from './types';\n\n/**\n *\n * Custom error for reported errors in CARTO Maps API.\n * Provides useful debugging information in console and context for applications.\n *\n */\nexport class CartoAPIError extends Error {\n  /** Source error from server */\n  error: Error;\n\n  /** Context (API call & parameters) in which error occured */\n  errorContext: APIErrorContext;\n\n  /** Response from server */\n  response?: Response;\n\n  constructor(error: Error, errorContext: APIErrorContext, response?: Response) {\n    let responseString = 'Failed to connect';\n    if (response) {\n      responseString = 'Server returned: ';\n      if (response.status === 400) {\n        responseString += 'Bad request';\n      } else if (response.status === 401 || response.status === 403) {\n        responseString += 'Unauthorized access';\n      } else if (response.status === 404) {\n        responseString += 'Not found';\n      } else {\n        responseString += 'Error';\n      }\n\n      responseString += ` (${response.status}):`;\n    }\n    responseString += ` ${error.message || error}`;\n\n    let message = `${errorContext.requestType} API request failed`;\n    message += `\\n${responseString}`;\n    for (const key of Object.keys(errorContext)) {\n      if (key === 'requestType') continue; // eslint-disable-line no-continue\n      message += `\\n${formatErrorKey(key)}: ${errorContext[key]}`;\n    }\n    message += '\\n';\n\n    super(message);\n\n    this.name = 'CartoAPIError';\n    this.response = response;\n    this.error = error;\n    this.errorContext = errorContext;\n  }\n}\n\n/**\n * Converts camelCase to Camel Case\n */\nfunction formatErrorKey(key) {\n  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());\n}\n"],"file":"carto-api-error.js"}

package/dist/es5/api/common.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_HEADERS = exports.DEFAULT_PARAMETERS = exports.MAX_GET_LENGTH = exports.V3_MINOR_VERSION = exports.DEFAULT_CLIENT = exports.DEFAULT_API_BASE_URL = void 0;
+var DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
+exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+var DEFAULT_CLIENT = 'deck-gl-carto';
+exports.DEFAULT_CLIENT = DEFAULT_CLIENT;
+var V3_MINOR_VERSION = '3.3';
+exports.V3_MINOR_VERSION = V3_MINOR_VERSION;
+var MAX_GET_LENGTH = 8192;
+exports.MAX_GET_LENGTH = MAX_GET_LENGTH;
+var DEFAULT_PARAMETERS = {
+  client: DEFAULT_CLIENT,
+  v: V3_MINOR_VERSION
+};
+exports.DEFAULT_PARAMETERS = DEFAULT_PARAMETERS;
+var DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+exports.DEFAULT_HEADERS = DEFAULT_HEADERS;
+//# sourceMappingURL=common.js.map

package/dist/es5/api/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/api/common.ts"],"names":["DEFAULT_API_BASE_URL","DEFAULT_CLIENT","V3_MINOR_VERSION","MAX_GET_LENGTH","DEFAULT_PARAMETERS","client","v","DEFAULT_HEADERS","Accept"],"mappings":";;;;;;AAAO,IAAMA,oBAAoB,GAAG,oCAA7B;;AACA,IAAMC,cAAc,GAAG,eAAvB;;AACA,IAAMC,gBAAgB,GAAG,KAAzB;;AACA,IAAMC,cAAc,GAAG,IAAvB;;AAEA,IAAMC,kBAAkB,GAAG;AAChCC,EAAAA,MAAM,EAAEJ,cADwB;AAEhCK,EAAAA,CAAC,EAAEJ;AAF6B,CAA3B;;AAKA,IAAMK,eAAe,GAAG;AAC7BC,EAAAA,MAAM,EAAE,kBADqB;AAE7B,kBAAgB;AAFa,CAAxB","sourcesContent":["export const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';\nexport const DEFAULT_CLIENT = 'deck-gl-carto';\nexport const V3_MINOR_VERSION = '3.3';\nexport const MAX_GET_LENGTH = 8192;\n\nexport const DEFAULT_PARAMETERS = {\n  client: DEFAULT_CLIENT,\n  v: V3_MINOR_VERSION\n};\n\nexport const DEFAULT_HEADERS = {\n  Accept: 'application/json',\n  'Content-Type': 'application/json'\n};\n"],"file":"common.js"}

package/dist/es5/api/endpoints.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildMapsUrlFromBase = buildMapsUrlFromBase;
+exports.buildStatsUrlFromBase = buildStatsUrlFromBase;
+exports.buildQueryUrlFromBase = buildQueryUrlFromBase;
+exports.buildSourceUrl = buildSourceUrl;
+
+function buildUrlFromBase(apiBaseUrl, endpoint) {
+  var suffix = "/v3/".concat(endpoint);
+
+  if (apiBaseUrl.endsWith('/')) {
+    suffix = suffix.substring(1);
+  }
+
+  return "".concat(apiBaseUrl).concat(suffix);
+}
+
+function buildMapsUrlFromBase(apiBaseUrl) {
+  return buildUrlFromBase(apiBaseUrl, 'maps');
+}
+
+function buildStatsUrlFromBase(apiBaseUrl) {
+  return buildUrlFromBase(apiBaseUrl, 'stats');
+}
+
+function buildQueryUrlFromBase(apiBaseUrl) {
+  return buildUrlFromBase(apiBaseUrl, 'sql');
+}
+
+function buildSourceUrl(_ref) {
+  var apiBaseUrl = _ref.apiBaseUrl,
+      connectionName = _ref.connectionName,
+      endpoint = _ref.endpoint,
+      mapsUrl = _ref.mapsUrl;
+  return "".concat(mapsUrl || buildMapsUrlFromBase(apiBaseUrl), "/").concat(connectionName, "/").concat(endpoint);
+}
+//# sourceMappingURL=endpoints.js.map

package/dist/es5/api/endpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/api/endpoints.ts"],"names":["buildUrlFromBase","apiBaseUrl","endpoint","suffix","endsWith","substring","buildMapsUrlFromBase","buildStatsUrlFromBase","buildQueryUrlFromBase","buildSourceUrl","connectionName","mapsUrl"],"mappings":";;;;;;;;;;AAIA,SAASA,gBAAT,CAA0BC,UAA1B,EAA8CC,QAA9C,EAAoE;AAClE,MAAIC,MAAM,iBAAUD,QAAV,CAAV;;AACA,MAAID,UAAU,CAACG,QAAX,CAAoB,GAApB,CAAJ,EAA8B;AAC5BD,IAAAA,MAAM,GAAGA,MAAM,CAACE,SAAP,CAAiB,CAAjB,CAAT;AACD;;AAED,mBAAUJ,UAAV,SAAuBE,MAAvB;AACD;;AAEM,SAASG,oBAAT,CAA8BL,UAA9B,EAA0D;AAC/D,SAAOD,gBAAgB,CAACC,UAAD,EAAa,MAAb,CAAvB;AACD;;AAEM,SAASM,qBAAT,CAA+BN,UAA/B,EAA2D;AAChE,SAAOD,gBAAgB,CAACC,UAAD,EAAa,OAAb,CAAvB;AACD;;AAEM,SAASO,qBAAT,CAA+BP,UAA/B,EAA2D;AAChE,SAAOD,gBAAgB,CAACC,UAAD,EAAa,KAAb,CAAvB;AACD;;AAEM,SAASQ,cAAT,OAUI;AAAA,MATTR,UASS,QATTA,UASS;AAAA,MARTS,cAQS,QARTA,cAQS;AAAA,MAPTR,QAOS,QAPTA,QAOS;AAAA,MANTS,OAMS,QANTA,OAMS;AACT,mBAAUA,OAAO,IAAIL,oBAAoB,CAACL,UAAD,CAAzC,cAAyDS,cAAzD,cAA2ER,QAA3E;AACD","sourcesContent":["import {MapType} from './types';\n\nexport type V3Endpoint = 'maps' | 'stats' | 'sql';\n\nfunction buildUrlFromBase(apiBaseUrl: string, endpoint: V3Endpoint) {\n  let suffix = `/v3/${endpoint}`;\n  if (apiBaseUrl.endsWith('/')) {\n    suffix = suffix.substring(1);\n  }\n\n  return `${apiBaseUrl}${suffix}`;\n}\n\nexport function buildMapsUrlFromBase(apiBaseUrl: string): string {\n  return buildUrlFromBase(apiBaseUrl, 'maps');\n}\n\nexport function buildStatsUrlFromBase(apiBaseUrl: string): string {\n  return buildUrlFromBase(apiBaseUrl, 'stats');\n}\n\nexport function buildQueryUrlFromBase(apiBaseUrl: string): string {\n  return buildUrlFromBase(apiBaseUrl, 'sql');\n}\n\nexport function buildSourceUrl({\n  apiBaseUrl,\n  connectionName,\n  endpoint,\n  mapsUrl\n}: {\n  apiBaseUrl: string;\n  connectionName: string;\n  endpoint: MapType;\n  mapsUrl?: string;\n}): string {\n  return `${mapsUrl || buildMapsUrlFromBase(apiBaseUrl)}/${connectionName}/${endpoint}`;\n}\n"],"file":"endpoints.js"}

package/dist/es5/api/fetch-map.js

@@ -0,0 +1,560 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchMap = fetchMap;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _cartoApiError = require("./carto-api-error");
+
+var _common = require("./common");
+
+var _endpoints = require("./endpoints");
+
+var _sources = require("../sources");
+
+var _parseMap = require("./parse-map");
+
+var _requestWithParameters = require("./request-with-parameters");
+
+var _utils = require("../utils");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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; }
+
+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; }
+
+function _fetchMapDataset(_x, _x2, _x3, _x4, _x5) {
+  return _fetchMapDataset2.apply(this, arguments);
+}
+
+function _fetchMapDataset2() {
+  _fetchMapDataset2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(dataset, accessToken, apiBaseUrl, clientId, headers) {
+    var aggregationExp, aggregationResLevel, connectionName, columns, format, geoColumn, source, type, queryParameters, cache, globalOptions, _ref4, _ref5, spatialDataType, spatialDataColumn, options, _options, _options2, cacheChanged;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            aggregationExp = dataset.aggregationExp, aggregationResLevel = dataset.aggregationResLevel, connectionName = dataset.connectionName, columns = dataset.columns, format = dataset.format, geoColumn = dataset.geoColumn, source = dataset.source, type = dataset.type, queryParameters = dataset.queryParameters;
+            cache = {};
+            globalOptions = {
+              accessToken: accessToken,
+              apiBaseUrl: apiBaseUrl,
+              cache: cache,
+              clientId: clientId,
+              connectionName: connectionName,
+              format: format,
+              headers: headers
+            };
+
+            if (!(type === 'tileset')) {
+              _context.next = 9;
+              break;
+            }
+
+            _context.next = 6;
+            return (0, _sources.vectorTilesetSource)(_objectSpread(_objectSpread({}, globalOptions), {}, {
+              tableName: source
+            }));
+
+          case 6:
+            dataset.data = _context.sent;
+            _context.next = 50;
+            break;
+
+          case 9:
+            _ref4 = geoColumn ? geoColumn.split(':') : ['geom'], _ref5 = (0, _slicedToArray2.default)(_ref4, 2), spatialDataType = _ref5[0], spatialDataColumn = _ref5[1];
+
+            if (!(spatialDataType === 'geom')) {
+              _context.next = 24;
+              break;
+            }
+
+            options = _objectSpread(_objectSpread({}, globalOptions), {}, {
+              spatialDataColumn: spatialDataColumn
+            });
+
+            if (!(type === 'table')) {
+              _context.next = 18;
+              break;
+            }
+
+            _context.next = 15;
+            return (0, _sources.vectorTableSource)(_objectSpread(_objectSpread({}, options), {}, {
+              columns: columns,
+              tableName: source
+            }));
+
+          case 15:
+            dataset.data = _context.sent;
+            _context.next = 22;
+            break;
+
+          case 18:
+            if (!(type === 'query')) {
+              _context.next = 22;
+              break;
+            }
+
+            _context.next = 21;
+            return (0, _sources.vectorQuerySource)(_objectSpread(_objectSpread({}, options), {}, {
+              sqlQuery: source,
+              queryParameters: queryParameters
+            }));
+
+          case 21:
+            dataset.data = _context.sent;
+
+          case 22:
+            _context.next = 50;
+            break;
+
+          case 24:
+            if (!(spatialDataType === 'h3')) {
+              _context.next = 38;
+              break;
+            }
+
+            _options = _objectSpread(_objectSpread({}, globalOptions), {}, {
+              aggregationExp: aggregationExp,
+              aggregationResLevel: aggregationResLevel,
+              spatialDataColumn: spatialDataColumn
+            });
+
+            if (!(type === 'table')) {
+              _context.next = 32;
+              break;
+            }
+
+            _context.next = 29;
+            return (0, _sources.h3TableSource)(_objectSpread(_objectSpread({}, _options), {}, {
+              columns: columns,
+              tableName: source
+            }));
+
+          case 29:
+            dataset.data = _context.sent;
+            _context.next = 36;
+            break;
+
+          case 32:
+            if (!(type === 'query')) {
+              _context.next = 36;
+              break;
+            }
+
+            _context.next = 35;
+            return (0, _sources.h3QuerySource)(_objectSpread(_objectSpread({}, _options), {}, {
+              sqlQuery: source,
+              queryParameters: queryParameters
+            }));
+
+          case 35:
+            dataset.data = _context.sent;
+
+          case 36:
+            _context.next = 50;
+            break;
+
+          case 38:
+            if (!(spatialDataType === 'quadbin')) {
+              _context.next = 50;
+              break;
+            }
+
+            _options2 = _objectSpread(_objectSpread({}, globalOptions), {}, {
+              aggregationExp: aggregationExp,
+              aggregationResLevel: aggregationResLevel,
+              spatialDataColumn: spatialDataColumn
+            });
+
+            if (!(type === 'table')) {
+              _context.next = 46;
+              break;
+            }
+
+            _context.next = 43;
+            return (0, _sources.quadbinTableSource)(_objectSpread(_objectSpread({}, _options2), {}, {
+              columns: columns,
+              tableName: source
+            }));
+
+          case 43:
+            dataset.data = _context.sent;
+            _context.next = 50;
+            break;
+
+          case 46:
+            if (!(type === 'query')) {
+              _context.next = 50;
+              break;
+            }
+
+            _context.next = 49;
+            return (0, _sources.quadbinQuerySource)(_objectSpread(_objectSpread({}, _options2), {}, {
+              sqlQuery: source,
+              queryParameters: queryParameters
+            }));
+
+          case 49:
+            dataset.data = _context.sent;
+
+          case 50:
+            cacheChanged = true;
+
+            if (cache.value) {
+              cacheChanged = dataset.cache !== cache.value;
+              dataset.cache = cache.value;
+            }
+
+            return _context.abrupt("return", cacheChanged);
+
+          case 53:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _fetchMapDataset2.apply(this, arguments);
+}
+
+function _fetchTilestats(_x6, _x7, _x8, _x9) {
+  return _fetchTilestats2.apply(this, arguments);
+}
+
+function _fetchTilestats2() {
+  _fetchTilestats2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(attribute, dataset, accessToken, apiBaseUrl) {
+    var connection, data, id, source, type, errorContext, statsUrl, baseUrl, headers, stats, attributes, index;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            connection = dataset.connectionName, data = dataset.data, id = dataset.id, source = dataset.source, type = dataset.type;
+            errorContext = {
+              requestType: 'Tile stats',
+              connection: connection,
+              type: type,
+              source: source
+            };
+
+            if ('tilestats' in data) {
+              _context2.next = 4;
+              break;
+            }
+
+            throw new _cartoApiError.CartoAPIError(new Error("Invalid dataset for tilestats: ".concat(id)), errorContext);
+
+          case 4:
+            statsUrl = (0, _endpoints.buildStatsUrlFromBase)(apiBaseUrl);
+            baseUrl = "".concat(statsUrl, "/").concat(connection, "/");
+
+            if (type === 'query') {
+              baseUrl += attribute;
+            } else {
+              baseUrl += "".concat(source, "/").concat(attribute);
+            }
+
+            headers = {
+              Authorization: "Bearer ".concat(accessToken)
+            };
+            _context2.next = 10;
+            return (0, _requestWithParameters.requestWithParameters)({
+              baseUrl: baseUrl,
+              headers: headers,
+              parameters: type === 'query' ? {
+                q: source
+              } : {},
+              errorContext: errorContext
+            });
+
+          case 10:
+            stats = _context2.sent;
+            attributes = data.tilestats.layers[0].attributes;
+            index = attributes.findIndex(function (d) {
+              return d.attribute === attribute;
+            });
+            attributes[index] = stats;
+            return _context2.abrupt("return", true);
+
+          case 15:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchTilestats2.apply(this, arguments);
+}
+
+function fillInMapDatasets(_x10, _x11, _x12, _x13) {
+  return _fillInMapDatasets.apply(this, arguments);
+}
+
+function _fillInMapDatasets() {
+  _fillInMapDatasets = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(_ref, clientId, apiBaseUrl, headers) {
+    var datasets, token, promises;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            datasets = _ref.datasets, token = _ref.token;
+            promises = datasets.map(function (dataset) {
+              return _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers);
+            });
+            _context3.next = 4;
+            return Promise.all(promises);
+
+          case 4:
+            return _context3.abrupt("return", _context3.sent);
+
+          case 5:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _fillInMapDatasets.apply(this, arguments);
+}
+
+function fillInTileStats(_x14, _x15) {
+  return _fillInTileStats.apply(this, arguments);
+}
+
+function _fillInTileStats() {
+  _fillInTileStats = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(_ref2, apiBaseUrl) {
+    var datasets, keplerMapConfig, token, attributes, layers, _iterator, _step, _loop2, filteredAttributes, _loop, _i, _attributes, promises;
+
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            datasets = _ref2.datasets, keplerMapConfig = _ref2.keplerMapConfig, token = _ref2.token;
+            attributes = [];
+            layers = keplerMapConfig.config.visState.layers;
+            _iterator = _createForOfIteratorHelper(layers);
+
+            try {
+              _loop2 = function _loop2() {
+                var layer = _step.value;
+
+                for (var _i2 = 0, _Object$keys = Object.keys(layer.visualChannels); _i2 < _Object$keys.length; _i2++) {
+                  var _layer$visualChannels;
+
+                  var channel = _Object$keys[_i2];
+                  var attribute = (_layer$visualChannels = layer.visualChannels[channel]) === null || _layer$visualChannels === void 0 ? void 0 : _layer$visualChannels.name;
+
+                  if (attribute) {
+                    var dataset = datasets.find(function (d) {
+                      return d.id === layer.config.dataId;
+                    });
+
+                    if (dataset && dataset.type !== 'tileset' && dataset.data.tilestats) {
+                      attributes.push({
+                        attribute: attribute,
+                        dataset: dataset
+                      });
+                    }
+                  }
+                }
+              };
+
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                _loop2();
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+
+            filteredAttributes = [];
+
+            _loop = function _loop() {
+              var a = _attributes[_i];
+
+              if (!filteredAttributes.find(function (_ref6) {
+                var attribute = _ref6.attribute,
+                    dataset = _ref6.dataset;
+                return attribute === a.attribute && dataset === a.dataset;
+              })) {
+                filteredAttributes.push(a);
+              }
+            };
+
+            for (_i = 0, _attributes = attributes; _i < _attributes.length; _i++) {
+              _loop();
+            }
+
+            promises = filteredAttributes.map(function (_ref7) {
+              var attribute = _ref7.attribute,
+                  dataset = _ref7.dataset;
+              return _fetchTilestats(attribute, dataset, token, apiBaseUrl);
+            });
+            _context4.next = 11;
+            return Promise.all(promises);
+
+          case 11:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 12:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _fillInTileStats.apply(this, arguments);
+}
+
+function fetchMap(_x16) {
+  return _fetchMap.apply(this, arguments);
+}
+
+function _fetchMap() {
+  _fetchMap = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee6(_ref3) {
+    var _ref3$apiBaseUrl, apiBaseUrl, cartoMapId, _ref3$clientId, clientId, _ref3$headers, headers, mapsUrl, autoRefresh, onNewData, baseUrl, errorContext, map, stopAutoRefresh, intervalId, geojsonLayers, geojsonDatasetIds, out, textLayers, font;
+
+    return _regenerator.default.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _ref3$apiBaseUrl = _ref3.apiBaseUrl, apiBaseUrl = _ref3$apiBaseUrl === void 0 ? _common.DEFAULT_API_BASE_URL : _ref3$apiBaseUrl, cartoMapId = _ref3.cartoMapId, _ref3$clientId = _ref3.clientId, clientId = _ref3$clientId === void 0 ? _common.DEFAULT_CLIENT : _ref3$clientId, _ref3$headers = _ref3.headers, headers = _ref3$headers === void 0 ? {} : _ref3$headers, mapsUrl = _ref3.mapsUrl, autoRefresh = _ref3.autoRefresh, onNewData = _ref3.onNewData;
+            (0, _utils.assert)(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+            (0, _utils.assert)(apiBaseUrl, 'Must define apiBaseUrl');
+
+            if (autoRefresh || onNewData) {
+              (0, _utils.assert)(onNewData, 'Must define `onNewData` when using autoRefresh');
+              (0, _utils.assert)(typeof onNewData === 'function', '`onNewData` must be a function');
+              (0, _utils.assert)(typeof autoRefresh === 'number' && autoRefresh > 0, '`autoRefresh` must be a positive number');
+            }
+
+            baseUrl = "".concat(mapsUrl || (0, _endpoints.buildMapsUrlFromBase)(apiBaseUrl), "/public/").concat(cartoMapId);
+            errorContext = {
+              requestType: 'Public map',
+              mapId: cartoMapId
+            };
+            _context6.next = 8;
+            return (0, _requestWithParameters.requestWithParameters)({
+              baseUrl: baseUrl,
+              headers: headers,
+              errorContext: errorContext
+            });
+
+          case 8:
+            map = _context6.sent;
+
+            if (autoRefresh) {
+              intervalId = setInterval((0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5() {
+                var changed;
+                return _regenerator.default.wrap(function _callee5$(_context5) {
+                  while (1) {
+                    switch (_context5.prev = _context5.next) {
+                      case 0:
+                        _context5.next = 2;
+                        return fillInMapDatasets(map, clientId, apiBaseUrl, _objectSpread(_objectSpread({}, headers), {}, {
+                          'If-Modified-Since': new Date().toUTCString()
+                        }));
+
+                      case 2:
+                        changed = _context5.sent;
+
+                        if (onNewData && changed.some(function (v) {
+                          return v === true;
+                        })) {
+                          onNewData((0, _parseMap.parseMap)(map));
+                        }
+
+                      case 4:
+                      case "end":
+                        return _context5.stop();
+                    }
+                  }
+                }, _callee5);
+              })), autoRefresh * 1000);
+
+              stopAutoRefresh = function stopAutoRefresh() {
+                clearInterval(intervalId);
+              };
+            }
+
+            geojsonLayers = map.keplerMapConfig.config.visState.layers.filter(function (_ref9) {
+              var type = _ref9.type;
+              return type === 'geojson' || type === 'point';
+            });
+            geojsonDatasetIds = geojsonLayers.map(function (_ref10) {
+              var config = _ref10.config;
+              return config.dataId;
+            });
+            map.datasets.forEach(function (dataset) {
+              if (geojsonDatasetIds.includes(dataset.id)) {
+                var _geojsonLayers$find = geojsonLayers.find(function (_ref11) {
+                  var config = _ref11.config;
+                  return config.dataId === dataset.id;
+                }),
+                    config = _geojsonLayers$find.config;
+
+                dataset.format = 'geojson';
+
+                if (!dataset.geoColumn && config.columns.geojson) {
+                  dataset.geoColumn = config.columns.geojson;
+                }
+              }
+            });
+            _context6.next = 15;
+            return fillInMapDatasets(map, clientId, apiBaseUrl, headers);
+
+          case 15:
+            _context6.next = 17;
+            return fillInTileStats(map, apiBaseUrl);
+
+          case 17:
+            out = _objectSpread(_objectSpread({}, (0, _parseMap.parseMap)(map)), {
+              stopAutoRefresh: stopAutoRefresh
+            });
+            textLayers = out.layers.filter(function (layer) {
+              var pointType = layer.props.pointType || '';
+              return pointType.includes('text');
+            });
+
+            if (!(textLayers.length && window.FontFace && !document.fonts.check('12px Inter'))) {
+              _context6.next = 23;
+              break;
+            }
+
+            font = new FontFace('Inter', 'url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)');
+            _context6.next = 23;
+            return font.load().then(function (f) {
+              return document.fonts.add(f);
+            });
+
+          case 23:
+            return _context6.abrupt("return", out);
+
+          case 24:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _fetchMap.apply(this, arguments);
+}
+//# sourceMappingURL=fetch-map.js.map