@deck.gl/geo-layers 8.10.0-alpha.4 → 8.10.0-alpha.5

package/dist/es5/mvt-layer/mvt-layer.js

@@ -87,414 +87,402 @@ var MVTLayer = function (_TileLayer) {
     return _super.apply(this, arguments);
   }
 
-  (0, _createClass2.default)(MVTLayer, [{
-    key: "initializeState",
-    value: function initializeState() {
-      (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "initializeState", this).call(this);
-      var binary = this.context.viewport.resolution !== undefined ? false : this.props.binary;
-      this.setState({
-        binary: binary,
-        data: null,
-        tileJSON: null
-      });
-    }
-  }, {
-    key: "isLoaded",
-    get: function get() {
-      return this.state && this.state.data && this.state.tileset && (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "isLoaded", this);
+  var _proto = MVTLayer.prototype;
+
+  _proto.initializeState = function initializeState() {
+    (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "initializeState", this).call(this);
+    var binary = this.context.viewport.resolution !== undefined ? false : this.props.binary;
+    this.setState({
+      binary: binary,
+      data: null,
+      tileJSON: null
+    });
+  };
+
+  _proto.updateState = function updateState(_ref) {
+    var _this$state;
+
+    var props = _ref.props,
+        oldProps = _ref.oldProps,
+        context = _ref.context,
+        changeFlags = _ref.changeFlags;
+
+    if (changeFlags.dataChanged) {
+      this._updateTileData();
     }
-  }, {
-    key: "updateState",
-    value: function updateState(_ref) {
-      var _this$state;
-
-      var props = _ref.props,
-          oldProps = _ref.oldProps,
-          context = _ref.context,
-          changeFlags = _ref.changeFlags;
-
-      if (changeFlags.dataChanged) {
-        this._updateTileData();
-      }
 
-      if ((_this$state = this.state) !== null && _this$state !== void 0 && _this$state.data) {
-        (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "updateState", this).call(this, {
-          props: props,
-          oldProps: oldProps,
-          context: context,
-          changeFlags: changeFlags
-        });
+    if ((_this$state = this.state) !== null && _this$state !== void 0 && _this$state.data) {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "updateState", this).call(this, {
+        props: props,
+        oldProps: oldProps,
+        context: context,
+        changeFlags: changeFlags
+      });
 
-        this._setWGS84PropertyForTiles();
-      }
+      this._setWGS84PropertyForTiles();
+    }
 
-      var highlightColor = props.highlightColor;
+    var highlightColor = props.highlightColor;
 
-      if (highlightColor !== oldProps.highlightColor && Array.isArray(highlightColor)) {
-        this.setState({
-          highlightColor: highlightColor
-        });
-      }
+    if (highlightColor !== oldProps.highlightColor && Array.isArray(highlightColor)) {
+      this.setState({
+        highlightColor: highlightColor
+      });
     }
-  }, {
-    key: "_updateTileData",
-    value: function () {
-      var _updateTileData2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
-        var data, tileJSON, _this$props, onDataLoad, fetch;
-
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                data = this.props.data;
-                tileJSON = null;
-
-                if (!(typeof data === 'string' && !(0, _tileset2d.isURLTemplate)(data))) {
-                  _context.next = 18;
-                  break;
-                }
-
-                _this$props = this.props, onDataLoad = _this$props.onDataLoad, fetch = _this$props.fetch;
-                this.setState({
-                  data: null,
-                  tileJSON: null
-                });
-                _context.prev = 5;
-                _context.next = 8;
-                return fetch(data, {
-                  propName: 'data',
-                  layer: this,
-                  loaders: []
-                });
+  };
 
-              case 8:
-                tileJSON = _context.sent;
-                _context.next = 15;
-                break;
+  _proto._updateTileData = function () {
+    var _updateTileData2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+      var data, tileJSON, _this$props, onDataLoad, fetch;
 
-              case 11:
-                _context.prev = 11;
-                _context.t0 = _context["catch"](5);
-                this.raiseError(_context.t0, 'loading TileJSON');
-                data = null;
-
-              case 15:
-                if (onDataLoad) {
-                  onDataLoad(tileJSON, {
-                    propName: 'data',
-                    layer: this
-                  });
-                }
-
-                _context.next = 19;
-                break;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              data = this.props.data;
+              tileJSON = null;
 
-              case 18:
-                if (data.tilejson) {
-                  tileJSON = data;
-                }
-
-              case 19:
-                if (tileJSON) {
-                  data = tileJSON.tiles;
-                }
+              if (!(typeof data === 'string' && !(0, _tileset2d.isURLTemplate)(data))) {
+                _context.next = 18;
+                break;
+              }
 
-                this.setState({
-                  data: data,
-                  tileJSON: tileJSON
+              _this$props = this.props, onDataLoad = _this$props.onDataLoad, fetch = _this$props.fetch;
+              this.setState({
+                data: null,
+                tileJSON: null
+              });
+              _context.prev = 5;
+              _context.next = 8;
+              return fetch(data, {
+                propName: 'data',
+                layer: this,
+                loaders: []
+              });
+
+            case 8:
+              tileJSON = _context.sent;
+              _context.next = 15;
+              break;
+
+            case 11:
+              _context.prev = 11;
+              _context.t0 = _context["catch"](5);
+              this.raiseError(_context.t0, 'loading TileJSON');
+              data = null;
+
+            case 15:
+              if (onDataLoad) {
+                onDataLoad(tileJSON, {
+                  propName: 'data',
+                  layer: this
                 });
+              }
 
-              case 21:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[5, 11]]);
-      }));
+              _context.next = 19;
+              break;
 
-      function _updateTileData() {
-        return _updateTileData2.apply(this, arguments);
-      }
+            case 18:
+              if (data.tilejson) {
+                tileJSON = data;
+              }
 
-      return _updateTileData;
-    }()
-  }, {
-    key: "_getTilesetOptions",
-    value: function _getTilesetOptions() {
-      var opts = (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "_getTilesetOptions", this).call(this);
-      var tileJSON = this.state.tileJSON;
-      var _this$props2 = this.props,
-          minZoom = _this$props2.minZoom,
-          maxZoom = _this$props2.maxZoom;
-
-      if (tileJSON) {
-        if (Number.isFinite(tileJSON.minzoom) && tileJSON.minzoom > minZoom) {
-          opts.minZoom = tileJSON.minzoom;
-        }
+            case 19:
+              if (tileJSON) {
+                data = tileJSON.tiles;
+              }
 
-        if (Number.isFinite(tileJSON.maxzoom) && (!Number.isFinite(maxZoom) || tileJSON.maxzoom < maxZoom)) {
-          opts.maxZoom = tileJSON.maxzoom;
+              this.setState({
+                data: data,
+                tileJSON: tileJSON
+              });
+
+            case 21:
+            case "end":
+              return _context.stop();
+          }
         }
-      }
+      }, _callee, this, [[5, 11]]);
+    }));
 
-      return opts;
+    function _updateTileData() {
+      return _updateTileData2.apply(this, arguments);
     }
-  }, {
-    key: "renderLayers",
-    value: function renderLayers() {
-      var _this$state2;
 
-      if (!((_this$state2 = this.state) !== null && _this$state2 !== void 0 && _this$state2.data)) return null;
-      return (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "renderLayers", this).call(this);
-    }
-  }, {
-    key: "getTileData",
-    value: function getTileData(loadProps) {
-      var _loadOptions;
-
-      var _this$state3 = this.state,
-          data = _this$state3.data,
-          binary = _this$state3.binary;
-      var index = loadProps.index,
-          signal = loadProps.signal;
-      var url = (0, _tileset2d.getURLFromTemplate)(data, loadProps);
-
-      if (!url) {
-        return Promise.reject('Invalid URL');
+    return _updateTileData;
+  }();
+
+  _proto._getTilesetOptions = function _getTilesetOptions() {
+    var opts = (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "_getTilesetOptions", this).call(this);
+    var tileJSON = this.state.tileJSON;
+    var _this$props2 = this.props,
+        minZoom = _this$props2.minZoom,
+        maxZoom = _this$props2.maxZoom;
+
+    if (tileJSON) {
+      if (Number.isFinite(tileJSON.minzoom) && tileJSON.minzoom > minZoom) {
+        opts.minZoom = tileJSON.minzoom;
       }
 
-      var loadOptions = this.getLoadOptions();
-      var fetch = this.props.fetch;
-      loadOptions = _objectSpread(_objectSpread({}, loadOptions), {}, {
-        mimeType: 'application/x-protobuf',
-        mvt: _objectSpread(_objectSpread({}, (_loadOptions = loadOptions) === null || _loadOptions === void 0 ? void 0 : _loadOptions.mvt), {}, {
-          coordinates: this.context.viewport.resolution ? 'wgs84' : 'local',
-          tileIndex: index
-        }),
-        gis: binary ? {
-          format: 'binary'
-        } : {}
-      });
-      return fetch(url, {
-        propName: 'data',
-        layer: this,
-        loadOptions: loadOptions,
-        signal: signal
-      });
-    }
-  }, {
-    key: "renderSubLayers",
-    value: function renderSubLayers(props) {
-      var _props$tile$index = props.tile.index,
-          x = _props$tile$index.x,
-          y = _props$tile$index.y,
-          z = _props$tile$index.z;
-      var worldScale = Math.pow(2, z);
-      var xScale = WORLD_SIZE / worldScale;
-      var yScale = -xScale;
-      var xOffset = WORLD_SIZE * x / worldScale;
-      var yOffset = WORLD_SIZE * (1 - y / worldScale);
-      var modelMatrix = new _core2.Matrix4().scale([xScale, yScale, 1]);
-      props.autoHighlight = false;
-
-      if (!this.context.viewport.resolution) {
-        props.modelMatrix = modelMatrix;
-        props.coordinateOrigin = [xOffset, yOffset, 0];
-        props.coordinateSystem = _core.COORDINATE_SYSTEM.CARTESIAN;
-        props.extensions = [].concat((0, _toConsumableArray2.default)(props.extensions || []), [new _extensions.ClipExtension()]);
+      if (Number.isFinite(tileJSON.maxzoom) && (!Number.isFinite(maxZoom) || tileJSON.maxzoom < maxZoom)) {
+        opts.maxZoom = tileJSON.maxzoom;
       }
+    }
 
-      var subLayers = (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "renderSubLayers", this).call(this, props);
+    return opts;
+  };
 
-      if (this.state.binary && !(subLayers instanceof _layers.GeoJsonLayer)) {
-        _core.log.warn('renderSubLayers() must return GeoJsonLayer when using binary:true')();
-      }
+  _proto.renderLayers = function renderLayers() {
+    var _this$state2;
 
-      return subLayers;
-    }
-  }, {
-    key: "_updateAutoHighlight",
-    value: function _updateAutoHighlight(info) {
-      var uniqueIdProperty = this.props.uniqueIdProperty;
-      var _this$state4 = this.state,
-          hoveredFeatureId = _this$state4.hoveredFeatureId,
-          hoveredFeatureLayerName = _this$state4.hoveredFeatureLayerName;
-      var hoveredFeature = info.object;
-      var newHoveredFeatureId;
-      var newHoveredFeatureLayerName;
-
-      if (hoveredFeature) {
-        newHoveredFeatureId = getFeatureUniqueId(hoveredFeature, uniqueIdProperty);
-        newHoveredFeatureLayerName = getFeatureLayerName(hoveredFeature);
-      }
+    if (!((_this$state2 = this.state) !== null && _this$state2 !== void 0 && _this$state2.data)) return null;
+    return (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "renderLayers", this).call(this);
+  };
 
-      var highlightColor = this.props.highlightColor;
+  _proto.getTileData = function getTileData(loadProps) {
+    var _loadOptions;
 
-      if (typeof highlightColor === 'function') {
-        highlightColor = highlightColor(info);
-      }
+    var _this$state3 = this.state,
+        data = _this$state3.data,
+        binary = _this$state3.binary;
+    var index = loadProps.index,
+        signal = loadProps.signal;
+    var url = (0, _tileset2d.getURLFromTemplate)(data, loadProps);
 
-      if (hoveredFeatureId !== newHoveredFeatureId || hoveredFeatureLayerName !== newHoveredFeatureLayerName) {
-        this.setState({
-          highlightColor: highlightColor,
-          hoveredFeatureId: newHoveredFeatureId,
-          hoveredFeatureLayerName: newHoveredFeatureLayerName
-        });
-      }
+    if (!url) {
+      return Promise.reject('Invalid URL');
     }
-  }, {
-    key: "getPickingInfo",
-    value: function getPickingInfo(params) {
-      var info = (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "getPickingInfo", this).call(this, params);
-      var isWGS84 = Boolean(this.context.viewport.resolution);
-
-      if (this.state.binary && info.index !== -1) {
-        var data = params.sourceLayer.props.data;
-        info.object = (0, _gis.binaryToGeojson)(data, {
-          globalFeatureId: info.index
-        });
-      }
 
-      if (info.object && !isWGS84) {
-        info.object = transformTileCoordsToWGS84(info.object, info.tile.bbox, this.context.viewport);
-      }
+    var loadOptions = this.getLoadOptions();
+    var fetch = this.props.fetch;
+    loadOptions = _objectSpread(_objectSpread({}, loadOptions), {}, {
+      mimeType: 'application/x-protobuf',
+      mvt: _objectSpread(_objectSpread({}, (_loadOptions = loadOptions) === null || _loadOptions === void 0 ? void 0 : _loadOptions.mvt), {}, {
+        coordinates: this.context.viewport.resolution ? 'wgs84' : 'local',
+        tileIndex: index
+      }),
+      gis: binary ? {
+        format: 'binary'
+      } : {}
+    });
+    return fetch(url, {
+      propName: 'data',
+      layer: this,
+      loadOptions: loadOptions,
+      signal: signal
+    });
+  };
+
+  _proto.renderSubLayers = function renderSubLayers(props) {
+    var _props$tile$index = props.tile.index,
+        x = _props$tile$index.x,
+        y = _props$tile$index.y,
+        z = _props$tile$index.z;
+    var worldScale = Math.pow(2, z);
+    var xScale = WORLD_SIZE / worldScale;
+    var yScale = -xScale;
+    var xOffset = WORLD_SIZE * x / worldScale;
+    var yOffset = WORLD_SIZE * (1 - y / worldScale);
+    var modelMatrix = new _core2.Matrix4().scale([xScale, yScale, 1]);
+    props.autoHighlight = false;
+
+    if (!this.context.viewport.resolution) {
+      props.modelMatrix = modelMatrix;
+      props.coordinateOrigin = [xOffset, yOffset, 0];
+      props.coordinateSystem = _core.COORDINATE_SYSTEM.CARTESIAN;
+      props.extensions = [].concat((0, _toConsumableArray2.default)(props.extensions || []), [new _extensions.ClipExtension()]);
+    }
+
+    var subLayers = (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "renderSubLayers", this).call(this, props);
 
-      return info;
+    if (this.state.binary && !(subLayers instanceof _layers.GeoJsonLayer)) {
+      _core.log.warn('renderSubLayers() must return GeoJsonLayer when using binary:true')();
     }
-  }, {
-    key: "getSubLayerPropsByTile",
-    value: function getSubLayerPropsByTile(tile) {
-      return {
-        highlightedObjectIndex: this.getHighlightedObjectIndex(tile),
-        highlightColor: this.state.highlightColor
-      };
+
+    return subLayers;
+  };
+
+  _proto._updateAutoHighlight = function _updateAutoHighlight(info) {
+    var uniqueIdProperty = this.props.uniqueIdProperty;
+    var _this$state4 = this.state,
+        hoveredFeatureId = _this$state4.hoveredFeatureId,
+        hoveredFeatureLayerName = _this$state4.hoveredFeatureLayerName;
+    var hoveredFeature = info.object;
+    var newHoveredFeatureId;
+    var newHoveredFeatureLayerName;
+
+    if (hoveredFeature) {
+      newHoveredFeatureId = getFeatureUniqueId(hoveredFeature, uniqueIdProperty);
+      newHoveredFeatureLayerName = getFeatureLayerName(hoveredFeature);
     }
-  }, {
-    key: "getHighlightedObjectIndex",
-    value: function getHighlightedObjectIndex(tile) {
-      var _this$state5 = this.state,
-          hoveredFeatureId = _this$state5.hoveredFeatureId,
-          hoveredFeatureLayerName = _this$state5.hoveredFeatureLayerName,
-          binary = _this$state5.binary;
-      var _this$props3 = this.props,
-          uniqueIdProperty = _this$props3.uniqueIdProperty,
-          highlightedFeatureId = _this$props3.highlightedFeatureId;
-      var data = tile.content;
-      var isHighlighted = isFeatureIdDefined(highlightedFeatureId);
-      var isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId) || isHighlighted;
-
-      if (!isFeatureIdPresent) {
-        return -1;
-      }
 
-      var featureIdToHighlight = isHighlighted ? highlightedFeatureId : hoveredFeatureId;
+    var highlightColor = this.props.highlightColor;
 
-      if (Array.isArray(data)) {
-        return data.findIndex(function (feature) {
-          var isMatchingId = getFeatureUniqueId(feature, uniqueIdProperty) === featureIdToHighlight;
-          var isMatchingLayer = isHighlighted || getFeatureLayerName(feature) === hoveredFeatureLayerName;
-          return isMatchingId && isMatchingLayer;
-        });
-      } else if (data && binary) {
-        return (0, _findIndexBinary.default)(data, uniqueIdProperty, featureIdToHighlight, isHighlighted ? '' : hoveredFeatureLayerName);
-      }
+    if (typeof highlightColor === 'function') {
+      highlightColor = highlightColor(info);
+    }
 
-      return -1;
+    if (hoveredFeatureId !== newHoveredFeatureId || hoveredFeatureLayerName !== newHoveredFeatureLayerName) {
+      this.setState({
+        highlightColor: highlightColor,
+        hoveredFeatureId: newHoveredFeatureId,
+        hoveredFeatureLayerName: newHoveredFeatureLayerName
+      });
     }
-  }, {
-    key: "_pickObjects",
-    value: function _pickObjects(maxObjects) {
-      var _this$context = this.context,
-          deck = _this$context.deck,
-          viewport = _this$context.viewport;
-      var width = viewport.width;
-      var height = viewport.height;
-      var x = viewport.x;
-      var y = viewport.y;
-      var layerIds = [this.id];
-      return deck.pickObjects({
-        x: x,
-        y: y,
-        width: width,
-        height: height,
-        layerIds: layerIds,
-        maxObjects: maxObjects
+  };
+
+  _proto.getPickingInfo = function getPickingInfo(params) {
+    var info = (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "getPickingInfo", this).call(this, params);
+    var isWGS84 = Boolean(this.context.viewport.resolution);
+
+    if (this.state.binary && info.index !== -1) {
+      var data = params.sourceLayer.props.data;
+      info.object = (0, _gis.binaryToGeojson)(data, {
+        globalFeatureId: info.index
       });
     }
-  }, {
-    key: "getRenderedFeatures",
-    value: function getRenderedFeatures() {
-      var maxFeatures = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
 
-      var features = this._pickObjects(maxFeatures);
+    if (info.object && !isWGS84) {
+      info.object = transformTileCoordsToWGS84(info.object, info.tile.bbox, this.context.viewport);
+    }
 
-      var featureCache = new Set();
-      var renderedFeatures = [];
+    return info;
+  };
+
+  _proto.getSubLayerPropsByTile = function getSubLayerPropsByTile(tile) {
+    return {
+      highlightedObjectIndex: this.getHighlightedObjectIndex(tile),
+      highlightColor: this.state.highlightColor
+    };
+  };
+
+  _proto.getHighlightedObjectIndex = function getHighlightedObjectIndex(tile) {
+    var _this$state5 = this.state,
+        hoveredFeatureId = _this$state5.hoveredFeatureId,
+        hoveredFeatureLayerName = _this$state5.hoveredFeatureLayerName,
+        binary = _this$state5.binary;
+    var _this$props3 = this.props,
+        uniqueIdProperty = _this$props3.uniqueIdProperty,
+        highlightedFeatureId = _this$props3.highlightedFeatureId;
+    var data = tile.content;
+    var isHighlighted = isFeatureIdDefined(highlightedFeatureId);
+    var isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId) || isHighlighted;
+
+    if (!isFeatureIdPresent) {
+      return -1;
+    }
 
-      var _iterator = _createForOfIteratorHelper(features),
-          _step;
+    var featureIdToHighlight = isHighlighted ? highlightedFeatureId : hoveredFeatureId;
 
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var f = _step.value;
-          var featureId = getFeatureUniqueId(f.object, this.props.uniqueIdProperty);
+    if (Array.isArray(data)) {
+      return data.findIndex(function (feature) {
+        var isMatchingId = getFeatureUniqueId(feature, uniqueIdProperty) === featureIdToHighlight;
+        var isMatchingLayer = isHighlighted || getFeatureLayerName(feature) === hoveredFeatureLayerName;
+        return isMatchingId && isMatchingLayer;
+      });
+    } else if (data && binary) {
+      return (0, _findIndexBinary.default)(data, uniqueIdProperty, featureIdToHighlight, isHighlighted ? '' : hoveredFeatureLayerName);
+    }
 
-          if (featureId === undefined) {
-            renderedFeatures.push(f.object);
-          } else if (!featureCache.has(featureId)) {
-            featureCache.add(featureId);
-            renderedFeatures.push(f.object);
-          }
+    return -1;
+  };
+
+  _proto._pickObjects = function _pickObjects(maxObjects) {
+    var _this$context = this.context,
+        deck = _this$context.deck,
+        viewport = _this$context.viewport;
+    var width = viewport.width;
+    var height = viewport.height;
+    var x = viewport.x;
+    var y = viewport.y;
+    var layerIds = [this.id];
+    return deck.pickObjects({
+      x: x,
+      y: y,
+      width: width,
+      height: height,
+      layerIds: layerIds,
+      maxObjects: maxObjects
+    });
+  };
+
+  _proto.getRenderedFeatures = function getRenderedFeatures() {
+    var maxFeatures = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+    var features = this._pickObjects(maxFeatures);
+
+    var featureCache = new Set();
+    var renderedFeatures = [];
+
+    var _iterator = _createForOfIteratorHelper(features),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var f = _step.value;
+        var featureId = getFeatureUniqueId(f.object, this.props.uniqueIdProperty);
+
+        if (featureId === undefined) {
+          renderedFeatures.push(f.object);
+        } else if (!featureCache.has(featureId)) {
+          featureCache.add(featureId);
+          renderedFeatures.push(f.object);
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
       }
-
-      return renderedFeatures;
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
-  }, {
-    key: "_setWGS84PropertyForTiles",
-    value: function _setWGS84PropertyForTiles() {
-      var _this = this;
-
-      var propName = 'dataInWGS84';
-      var tileset = this.state.tileset;
-      tileset.selectedTiles.forEach(function (tile) {
-        if (!tile.hasOwnProperty(propName)) {
-          Object.defineProperty(tile, propName, {
-            get: function get() {
-              if (!tile.content) {
-                return null;
-              }
 
-              if (_this.state.binary && Array.isArray(tile.content) && !tile.content.length) {
-                return [];
-              }
+    return renderedFeatures;
+  };
 
-              var bbox = tile.bbox;
+  _proto._setWGS84PropertyForTiles = function _setWGS84PropertyForTiles() {
+    var _this = this;
 
-              if (tile._contentWGS84 === undefined && (0, _tileset2d.isGeoBoundingBox)(bbox)) {
-                var content = _this.state.binary ? (0, _gis.binaryToGeojson)(tile.content) : tile.content;
-                tile._contentWGS84 = content.map(function (feature) {
-                  return transformTileCoordsToWGS84(feature, bbox, _this.context.viewport);
-                });
-              }
+    var propName = 'dataInWGS84';
+    var tileset = this.state.tileset;
+    tileset.selectedTiles.forEach(function (tile) {
+      if (!tile.hasOwnProperty(propName)) {
+        Object.defineProperty(tile, propName, {
+          get: function get() {
+            if (!tile.content) {
+              return null;
+            }
 
-              return tile._contentWGS84;
+            if (_this.state.binary && Array.isArray(tile.content) && !tile.content.length) {
+              return [];
             }
-          });
-        }
-      });
+
+            var bbox = tile.bbox;
+
+            if (tile._contentWGS84 === undefined && (0, _tileset2d.isGeoBoundingBox)(bbox)) {
+              var content = _this.state.binary ? (0, _gis.binaryToGeojson)(tile.content) : tile.content;
+              tile._contentWGS84 = content.map(function (feature) {
+                return transformTileCoordsToWGS84(feature, bbox, _this.context.viewport);
+              });
+            }
+
+            return tile._contentWGS84;
+          }
+        });
+      }
+    });
+  };
+
+  (0, _createClass2.default)(MVTLayer, [{
+    key: "isLoaded",
+    get: function get() {
+      return this.state && this.state.data && this.state.tileset && (0, _get2.default)((0, _getPrototypeOf2.default)(MVTLayer.prototype), "isLoaded", this);
     }
   }]);
   return MVTLayer;
 }(_tileLayer.default);
 
 exports.default = MVTLayer;
-(0, _defineProperty2.default)(MVTLayer, "layerName", 'MVTLayer');
-(0, _defineProperty2.default)(MVTLayer, "defaultProps", defaultProps);
+MVTLayer.layerName = 'MVTLayer';
+MVTLayer.defaultProps = defaultProps;
 
 function getFeatureUniqueId(feature, uniqueIdProperty) {
   if (feature.properties && uniqueIdProperty) {