@deck.gl/carto 8.10.0-alpha.2 → 8.10.0-alpha.5

package/dist/es5/index.js

@@ -23,13 +23,13 @@ Object.defineProperty(exports, "CartoLayer", {
     return _cartoLayer.default;
   }
 });
-Object.defineProperty(exports, "_CartoTileLayer", {
+Object.defineProperty(exports, "VectorTileLayer", {
   enumerable: true,
   get: function get() {
-    return _cartoTileLayer.default;
+    return _vectorTileLayer.default;
   }
 });
-Object.defineProperty(exports, "_H3TileLayer", {
+Object.defineProperty(exports, "H3TileLayer", {
   enumerable: true,
   get: function get() {
     return _h3TileLayer.default;
@@ -41,13 +41,13 @@ Object.defineProperty(exports, "_PointLabelLayer", {
     return _pointLabelLayer.default;
   }
 });
-Object.defineProperty(exports, "_QuadbinTileLayer", {
+Object.defineProperty(exports, "QuadbinTileLayer", {
   enumerable: true,
   get: function get() {
     return _quadbinTileLayer.default;
   }
 });
-Object.defineProperty(exports, "_RasterTileLayer", {
+Object.defineProperty(exports, "RasterTileLayer", {
   enumerable: true,
   get: function get() {
     return _rasterTileLayer.default;
@@ -131,12 +131,78 @@ Object.defineProperty(exports, "_mapInstantiation", {
     return _api.mapInstantiation;
   }
 });
+Object.defineProperty(exports, "cartoH3QuerySource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoH3QuerySource;
+  }
+});
+Object.defineProperty(exports, "cartoH3TableSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoH3TableSource;
+  }
+});
+Object.defineProperty(exports, "cartoH3TilesetSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoH3TilesetSource;
+  }
+});
+Object.defineProperty(exports, "cartoRasterSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoRasterSource;
+  }
+});
+Object.defineProperty(exports, "cartoQuadbinQuerySource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoQuadbinQuerySource;
+  }
+});
+Object.defineProperty(exports, "cartoQuadbinTableSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoQuadbinTableSource;
+  }
+});
+Object.defineProperty(exports, "cartoQuadbinTilesetSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoQuadbinTilesetSource;
+  }
+});
+Object.defineProperty(exports, "cartoVectorQuerySource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoVectorQuerySource;
+  }
+});
+Object.defineProperty(exports, "cartoVectorTableSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoVectorTableSource;
+  }
+});
+Object.defineProperty(exports, "cartoVectorTilesetSource", {
+  enumerable: true,
+  get: function get() {
+    return _sources.cartoVectorTilesetSource;
+  }
+});
+Object.defineProperty(exports, "SOURCE_DEFAULTS", {
+  enumerable: true,
+  get: function get() {
+    return _sources.SOURCE_DEFAULTS;
+  }
+});
 
 var _config = require("./config");
 
 var _cartoLayer = _interopRequireDefault(require("./layers/carto-layer"));
 
-var _cartoTileLayer = _interopRequireDefault(require("./layers/carto-tile-layer"));
+var _vectorTileLayer = _interopRequireDefault(require("./layers/vector-tile-layer"));
 
 var _h3TileLayer = _interopRequireDefault(require("./layers/h3-tile-layer"));
 
@@ -155,4 +221,6 @@ var _colorCategoriesStyle = _interopRequireDefault(require("./style/color-catego
 var _colorContinuousStyle = _interopRequireDefault(require("./style/color-continuous-style"));
 
 var _api = require("./api");
+
+var _sources = require("./sources");
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA","sourcesContent":["export {getDefaultCredentials, setDefaultCredentials} from './config';\nexport {default as CartoLayer} from './layers/carto-layer';\nexport {default as _CartoTileLayer} from './layers/carto-tile-layer';\nexport {default as _H3TileLayer} from './layers/h3-tile-layer';\nexport {default as _PointLabelLayer} from './layers/point-label-layer';\nexport {default as _QuadbinTileLayer} from './layers/quadbin-tile-layer';\nexport {default as _RasterTileLayer} from './layers/raster-tile-layer';\nexport {default as BASEMAP} from './basemap';\nexport {default as colorBins} from './style/color-bins-style';\nexport {default as colorCategories} from './style/color-categories-style';\nexport {default as colorContinuous} from './style/color-continuous-style';\nexport {\n  FORMATS,\n  TILE_FORMATS,\n  MAP_TYPES,\n  API_VERSIONS,\n  CartoAPIError,\n  fetchLayerData,\n  fetchMap,\n  getDataV2 as _getDataV2,\n  mapInstantiation as _mapInstantiation\n} from './api';\nexport type {APIErrorContext, QueryParameters} from './api';\nexport type {CartoLayerProps} from './layers/carto-layer';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAcA","sourcesContent":["export {getDefaultCredentials, setDefaultCredentials} from './config';\nexport {default as CartoLayer} from './layers/carto-layer'; // <-- REMOVE in v9\nexport {default as VectorTileLayer} from './layers/vector-tile-layer';\nexport {default as H3TileLayer} from './layers/h3-tile-layer';\nexport {default as _PointLabelLayer} from './layers/point-label-layer';\nexport {default as QuadbinTileLayer} from './layers/quadbin-tile-layer';\nexport {default as RasterTileLayer} from './layers/raster-tile-layer';\nexport {default as BASEMAP} from './basemap';\nexport {default as colorBins} from './style/color-bins-style';\nexport {default as colorCategories} from './style/color-categories-style';\nexport {default as colorContinuous} from './style/color-continuous-style';\nexport {\n  FORMATS,\n  TILE_FORMATS,\n  MAP_TYPES,\n  API_VERSIONS,\n  CartoAPIError,\n  fetchLayerData,\n  fetchMap,\n  getDataV2 as _getDataV2,\n  mapInstantiation as _mapInstantiation\n} from './api';\nexport type {APIErrorContext, QueryParameters} from './api';\nexport type {CartoLayerProps} from './layers/carto-layer';\n\nexport {\n  cartoH3QuerySource,\n  cartoH3TableSource,\n  cartoH3TilesetSource,\n  cartoRasterSource,\n  cartoQuadbinQuerySource,\n  cartoQuadbinTableSource,\n  cartoQuadbinTilesetSource,\n  cartoVectorQuerySource,\n  cartoVectorTableSource,\n  cartoVectorTilesetSource,\n  SOURCE_DEFAULTS\n} from './sources';\nexport type {\n  CartoTilejsonResult,\n  CartoH3QuerySourceOptions,\n  CartoH3TableSourceOptions,\n  CartoH3TilesetSourceOptions,\n  CartoRasterSourceOptions,\n  CartoQuadbinQuerySourceOptions,\n  CartoQuadbinTableSourceOptions,\n  CartoQuadbinTilesetSourceOptions,\n  CartoVectorQuerySourceOptions,\n  CartoVectorTableSourceOptions,\n  CartoVectorTilesetSourceOptions,\n  GeojsonResult,\n  JsonResult\n} from './sources';\n"],"file":"index.js"}

package/dist/es5/layers/carto-layer.js

@@ -15,6 +15,8 @@ var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/h
 
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -27,8 +29,6 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _core = require("@deck.gl/core");
 
 var _geoLayers = require("@deck.gl/geo-layers");
@@ -97,237 +97,233 @@ var CartoLayer = function (_CompositeLayer) {
     return _super.apply(this, arguments);
   }
 
-  (0, _createClass2.default)(CartoLayer, [{
-    key: "initializeState",
-    value: function initializeState() {
-      this.state = {
-        data: null,
-        apiVersion: null
-      };
-    }
-  }, {
-    key: "isLoaded",
-    get: function get() {
-      return this.getSubLayers().length > 0 && (0, _get2.default)((0, _getPrototypeOf2.default)(CartoLayer.prototype), "isLoaded", this);
-    }
-  }, {
-    key: "_checkProps",
-    value: function _checkProps(props) {
-      var type = props.type,
-          credentials = props.credentials,
-          connection = props.connection,
-          geoColumn = props.geoColumn,
-          columns = props.columns;
+  var _proto = CartoLayer.prototype;
 
-      var localCreds = _objectSpread(_objectSpread({}, (0, _config.getDefaultCredentials)()), credentials);
+  _proto.initializeState = function initializeState() {
+    this.state = {
+      data: null,
+      apiVersion: null
+    };
+  };
 
-      var apiVersion = localCreds.apiVersion;
+  _proto._checkProps = function _checkProps(props) {
+    var type = props.type,
+        credentials = props.credentials,
+        connection = props.connection,
+        geoColumn = props.geoColumn,
+        columns = props.columns;
 
-      _core.log.assert(Object.values(_api.API_VERSIONS).includes(apiVersion), "Invalid apiVersion ".concat(apiVersion, ". Use API_VERSIONS enum."));
+    var localCreds = _objectSpread(_objectSpread({}, (0, _config.getDefaultCredentials)()), credentials);
 
-      if (apiVersion === _api.API_VERSIONS.V1 || apiVersion === _api.API_VERSIONS.V2) {
-        _core.log.assert(type === _mapsApiCommon.MAP_TYPES.QUERY || type === _mapsApiCommon.MAP_TYPES.TILESET, "Invalid type ".concat(type, ". Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ").concat(apiVersion));
+    var apiVersion = localCreds.apiVersion;
 
-        _core.log.assert(!connection, "Connection prop is not supported for apiVersion ".concat(apiVersion));
+    _core.log.assert(Object.values(_api.API_VERSIONS).includes(apiVersion), "Invalid apiVersion ".concat(apiVersion, ". Use API_VERSIONS enum."));
 
-        _core.log.assert(!geoColumn, "geoColumn prop is not supported for apiVersion ".concat(apiVersion));
+    if (apiVersion === _api.API_VERSIONS.V1 || apiVersion === _api.API_VERSIONS.V2) {
+      _core.log.assert(type === _mapsApiCommon.MAP_TYPES.QUERY || type === _mapsApiCommon.MAP_TYPES.TILESET, "Invalid type ".concat(type, ". Use type MAP_TYPES.QUERY or MAP_TYPES.TILESET for apiVersion ").concat(apiVersion));
 
-        _core.log.assert(!columns, "columns prop is not supported for apiVersion ".concat(apiVersion));
-      } else if (apiVersion === _api.API_VERSIONS.V3) {
-        _core.log.assert(connection, 'Missing mandatory connection parameter');
+      _core.log.assert(!connection, "Connection prop is not supported for apiVersion ".concat(apiVersion));
 
-        _core.log.assert(Object.values(_mapsApiCommon.MAP_TYPES).includes(type), "Invalid type ".concat(type, ". Use MAP_TYPES enum."));
+      _core.log.assert(!geoColumn, "geoColumn prop is not supported for apiVersion ".concat(apiVersion));
 
-        if (!_mapsApiCommon.COLUMNS_SUPPORT.includes(type)) {
-          _core.log.assert(!columns, "columns prop is only supported for types: ".concat(_mapsApiCommon.COLUMNS_SUPPORT.join()));
-        }
+      _core.log.assert(!columns, "columns prop is not supported for apiVersion ".concat(apiVersion));
+    } else if (apiVersion === _api.API_VERSIONS.V3) {
+      _core.log.assert(connection, 'Missing mandatory connection parameter');
 
-        if (!_mapsApiCommon.GEO_COLUMN_SUPPORT.includes(type)) {
-          _core.log.assert(!geoColumn, "geoColumn prop is only supported for types: ".concat(_mapsApiCommon.GEO_COLUMN_SUPPORT.join()));
-        }
+      _core.log.assert(Object.values(_mapsApiCommon.MAP_TYPES).includes(type), "Invalid type ".concat(type, ". Use MAP_TYPES enum."));
 
-        if (columns) {
-          _core.log.assert(Array.isArray(columns), 'columns prop must be an Array');
-        }
+      if (!_mapsApiCommon.COLUMNS_SUPPORT.includes(type)) {
+        _core.log.assert(!columns, "columns prop is only supported for types: ".concat(_mapsApiCommon.COLUMNS_SUPPORT.join()));
       }
-    }
-  }, {
-    key: "updateState",
-    value: function updateState(_ref) {
-      var props = _ref.props,
-          oldProps = _ref.oldProps,
-          changeFlags = _ref.changeFlags;
-
-      this._checkProps(props);
-
-      var shouldUpdateData = changeFlags.dataChanged || props.aggregationExp !== oldProps.aggregationExp || props.aggregationResLevel !== oldProps.aggregationResLevel || props.connection !== oldProps.connection || props.geoColumn !== oldProps.geoColumn || props.formatTiles !== oldProps.formatTiles || props.type !== oldProps.type || JSON.stringify(props.columns) !== JSON.stringify(oldProps.columns) || JSON.stringify(props.credentials) !== JSON.stringify(oldProps.credentials) || JSON.stringify(props.queryParameters) !== JSON.stringify(oldProps.queryParameters);
 
-      if (shouldUpdateData) {
-        this.setState({
-          data: null,
-          apiVersion: null
-        });
+      if (!_mapsApiCommon.GEO_COLUMN_SUPPORT.includes(type)) {
+        _core.log.assert(!geoColumn, "geoColumn prop is only supported for types: ".concat(_mapsApiCommon.GEO_COLUMN_SUPPORT.join()));
+      }
 
-        this._updateData();
+      if (columns) {
+        _core.log.assert(Array.isArray(columns), 'columns prop must be an Array');
       }
     }
-  }, {
-    key: "_updateData",
-    value: function () {
-      var _updateData2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
-        var _this$props$onDataLoa, _this$props2, _this$props, type, source, credentials, connection, rest, localConfig, apiVersion, result;
-
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                _context.prev = 0;
-                _this$props = this.props, type = _this$props.type, source = _this$props.data, credentials = _this$props.credentials, connection = _this$props.connection, rest = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
-                localConfig = _objectSpread(_objectSpread({}, (0, _config.getDefaultCredentials)()), credentials);
-                apiVersion = localConfig.apiVersion;
-
-                if (!(apiVersion === _api.API_VERSIONS.V1 || apiVersion === _api.API_VERSIONS.V2)) {
-                  _context.next = 11;
-                  break;
-                }
-
-                _context.next = 7;
-                return (0, _api.getDataV2)({
-                  type: type,
-                  source: source,
-                  credentials: credentials
-                });
-
-              case 7:
-                _context.t0 = _context.sent;
-                result = {
-                  data: _context.t0
-                };
-                _context.next = 14;
-                break;
+  };
 
-              case 11:
-                _context.next = 13;
-                return (0, _api.fetchLayerData)(_objectSpread(_objectSpread({
-                  type: type,
-                  source: source,
-                  credentials: credentials,
-                  connection: connection
-                }, rest), {}, {
-                  format: _mapsApiCommon.FORMATS.TILEJSON
-                }));
-
-              case 13:
-                result = _context.sent;
-
-              case 14:
-                this.setState(_objectSpread(_objectSpread({}, result), {}, {
-                  apiVersion: apiVersion
-                }));
-                (_this$props$onDataLoa = (_this$props2 = this.props).onDataLoad) === null || _this$props$onDataLoa === void 0 ? void 0 : _this$props$onDataLoa.call(_this$props2, result.data, {
-                  propName: 'data',
-                  layer: this
-                });
-                _context.next = 25;
-                break;
+  _proto.updateState = function updateState(_ref) {
+    var props = _ref.props,
+        oldProps = _ref.oldProps,
+        changeFlags = _ref.changeFlags;
 
-              case 18:
-                _context.prev = 18;
-                _context.t1 = _context["catch"](0);
+    this._checkProps(props);
 
-                if (!this.props.onDataError) {
-                  _context.next = 24;
-                  break;
-                }
+    var shouldUpdateData = changeFlags.dataChanged || props.aggregationExp !== oldProps.aggregationExp || props.aggregationResLevel !== oldProps.aggregationResLevel || props.connection !== oldProps.connection || props.geoColumn !== oldProps.geoColumn || props.formatTiles !== oldProps.formatTiles || props.type !== oldProps.type || JSON.stringify(props.columns) !== JSON.stringify(oldProps.columns) || JSON.stringify(props.credentials) !== JSON.stringify(oldProps.credentials) || JSON.stringify(props.queryParameters) !== JSON.stringify(oldProps.queryParameters);
 
-                this.props.onDataError(_context.t1);
-                _context.next = 25;
+    if (shouldUpdateData) {
+      this.setState({
+        data: null,
+        apiVersion: null
+      });
+
+      this._updateData();
+    }
+  };
+
+  _proto._updateData = function () {
+    var _updateData2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+      var _this$props$onDataLoa, _this$props2, _this$props, type, source, credentials, connection, rest, localConfig, apiVersion, result;
+
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              _this$props = this.props, type = _this$props.type, source = _this$props.data, credentials = _this$props.credentials, connection = _this$props.connection, rest = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+              localConfig = _objectSpread(_objectSpread({}, (0, _config.getDefaultCredentials)()), credentials);
+              apiVersion = localConfig.apiVersion;
+
+              if (!(apiVersion === _api.API_VERSIONS.V1 || apiVersion === _api.API_VERSIONS.V2)) {
+                _context.next = 11;
                 break;
+              }
+
+              _context.next = 7;
+              return (0, _api.getDataV2)({
+                type: type,
+                source: source,
+                credentials: credentials
+              });
+
+            case 7:
+              _context.t0 = _context.sent;
+              result = {
+                data: _context.t0
+              };
+              _context.next = 14;
+              break;
+
+            case 11:
+              _context.next = 13;
+              return (0, _api.fetchLayerData)(_objectSpread(_objectSpread({
+                type: type,
+                source: source,
+                credentials: credentials,
+                connection: connection
+              }, rest), {}, {
+                format: _mapsApiCommon.FORMATS.TILEJSON
+              }));
+
+            case 13:
+              result = _context.sent;
+
+            case 14:
+              this.setState(_objectSpread(_objectSpread({}, result), {}, {
+                apiVersion: apiVersion
+              }));
+              (_this$props$onDataLoa = (_this$props2 = this.props).onDataLoad) === null || _this$props$onDataLoa === void 0 ? void 0 : _this$props$onDataLoa.call(_this$props2, result.data, {
+                propName: 'data',
+                layer: this
+              });
+              _context.next = 25;
+              break;
+
+            case 18:
+              _context.prev = 18;
+              _context.t1 = _context["catch"](0);
+
+              if (!this.props.onDataError) {
+                _context.next = 24;
+                break;
+              }
+
+              this.props.onDataError(_context.t1);
+              _context.next = 25;
+              break;
 
-              case 24:
-                throw _context.t1;
+            case 24:
+              throw _context.t1;
 
-              case 25:
-              case "end":
-                return _context.stop();
-            }
+            case 25:
+            case "end":
+              return _context.stop();
           }
-        }, _callee, this, [[0, 18]]);
-      }));
+        }
+      }, _callee, this, [[0, 18]]);
+    }));
 
-      function _updateData() {
-        return _updateData2.apply(this, arguments);
-      }
+    function _updateData() {
+      return _updateData2.apply(this, arguments);
+    }
 
-      return _updateData;
-    }()
-  }, {
-    key: "_getSubLayerAndProps",
-    value: function _getSubLayerAndProps() {
-      (0, _utils.assert)(this.state);
-      var _this$state = this.state,
-          data = _this$state.data,
-          apiVersion = _this$state.apiVersion;
-      var uniqueIdProperty = defaultProps.uniqueIdProperty;
-      var _this$props3 = this.props,
-          _notUsed = _this$props3.data,
-          propsNoData = (0, _objectWithoutProperties2.default)(_this$props3, _excluded2);
-
-      var props = _objectSpread({
-        uniqueIdProperty: uniqueIdProperty
-      }, propsNoData);
-
-      if (apiVersion === _api.API_VERSIONS.V1 || apiVersion === _api.API_VERSIONS.V2) {
-        return [_geoLayers.MVTLayer, props];
-      }
+    return _updateData;
+  }();
+
+  _proto._getSubLayerAndProps = function _getSubLayerAndProps() {
+    (0, _utils.assert)(this.state);
+    var _this$state = this.state,
+        data = _this$state.data,
+        apiVersion = _this$state.apiVersion;
+    var uniqueIdProperty = defaultProps.uniqueIdProperty;
+    var _this$props3 = this.props,
+        _notUsed = _this$props3.data,
+        propsNoData = (0, _objectWithoutProperties2.default)(_this$props3, _excluded2);
+
+    var props = _objectSpread({
+      uniqueIdProperty: uniqueIdProperty
+    }, propsNoData);
+
+    if (apiVersion === _api.API_VERSIONS.V1 || apiVersion === _api.API_VERSIONS.V2) {
+      return [_geoLayers.MVTLayer, props];
+    }
 
-      var tileUrl = new URL(data.tiles[0]);
-      props.formatTiles = props.formatTiles || tileUrl.searchParams.get('formatTiles');
-      return [(0, _layerMap.layerFromTileDataset)(props.formatTiles, data.scheme, props.type), props];
+    var tileUrl = new URL(data.tiles[0]);
+    props.formatTiles = props.formatTiles || tileUrl.searchParams.get('formatTiles');
+    return [(0, _layerMap.layerFromTileDataset)(props.formatTiles, data.scheme, props.type), props];
+  };
+
+  _proto.renderLayers = function renderLayers() {
+    (0, _utils.assert)(this.state);
+    var _this$state2 = this.state,
+        apiVersion = _this$state2.apiVersion,
+        data = _this$state2.data;
+    if (!data) return null;
+    var _this$props4 = this.props,
+        credentials = _this$props4.credentials,
+        updateTriggers = _this$props4.updateTriggers;
+    var loadOptions = this.getLoadOptions() || {};
+
+    if (apiVersion === _api.API_VERSIONS.V3) {
+      var _loadOptions$fetch;
+
+      var localConfig = _objectSpread(_objectSpread({}, (0, _config.getDefaultCredentials)()), credentials);
+
+      var accessToken = localConfig.accessToken;
+      loadOptions.fetch = _objectSpread(_objectSpread({}, loadOptions.fetch), {}, {
+        headers: _objectSpread(_objectSpread({}, (_loadOptions$fetch = loadOptions.fetch) === null || _loadOptions$fetch === void 0 ? void 0 : _loadOptions$fetch.headers), {}, {
+          Authorization: "Bearer ".concat(accessToken)
+        })
+      });
     }
-  }, {
-    key: "renderLayers",
-    value: function renderLayers() {
-      (0, _utils.assert)(this.state);
-      var _this$state2 = this.state,
-          apiVersion = _this$state2.apiVersion,
-          data = _this$state2.data;
-      if (!data) return null;
-      var _this$props4 = this.props,
-          credentials = _this$props4.credentials,
-          updateTriggers = _this$props4.updateTriggers;
-      var loadOptions = this.getLoadOptions() || {};
-
-      if (apiVersion === _api.API_VERSIONS.V3) {
-        var _loadOptions$fetch;
-
-        var localConfig = _objectSpread(_objectSpread({}, (0, _config.getDefaultCredentials)()), credentials);
-
-        var accessToken = localConfig.accessToken;
-        loadOptions.fetch = _objectSpread(_objectSpread({}, loadOptions.fetch), {}, {
-          headers: _objectSpread(_objectSpread({}, (_loadOptions$fetch = loadOptions.fetch) === null || _loadOptions$fetch === void 0 ? void 0 : _loadOptions$fetch.headers), {}, {
-            Authorization: "Bearer ".concat(accessToken)
-          })
-        });
-      }
 
-      var _this$_getSubLayerAnd = this._getSubLayerAndProps(),
-          _this$_getSubLayerAnd2 = (0, _slicedToArray2.default)(_this$_getSubLayerAnd, 2),
-          layer = _this$_getSubLayerAnd2[0],
-          props = _this$_getSubLayerAnd2[1];
-
-      return new layer(props, this.getSubLayerProps({
-        id: "carto-".concat(layer.layerName),
-        data: data,
-        loadOptions: loadOptions,
-        updateTriggers: updateTriggers
-      }));
+    var _this$_getSubLayerAnd = this._getSubLayerAndProps(),
+        _this$_getSubLayerAnd2 = (0, _slicedToArray2.default)(_this$_getSubLayerAnd, 2),
+        layer = _this$_getSubLayerAnd2[0],
+        props = _this$_getSubLayerAnd2[1];
+
+    return new layer(props, this.getSubLayerProps({
+      id: "carto-".concat(layer.layerName),
+      data: data,
+      loadOptions: loadOptions,
+      updateTriggers: updateTriggers
+    }));
+  };
+
+  (0, _createClass2.default)(CartoLayer, [{
+    key: "isLoaded",
+    get: function get() {
+      return this.getSubLayers().length > 0 && (0, _get2.default)((0, _getPrototypeOf2.default)(CartoLayer.prototype), "isLoaded", this);
     }
   }]);
   return CartoLayer;
 }(_core.CompositeLayer);
 
 exports.default = CartoLayer;
-(0, _defineProperty2.default)(CartoLayer, "layerName", 'CartoLayer');
-(0, _defineProperty2.default)(CartoLayer, "defaultProps", defaultProps);
+CartoLayer.layerName = 'CartoLayer';
+CartoLayer.defaultProps = defaultProps;
 //# sourceMappingURL=carto-layer.js.map