react-spatial/LayerService.js

Components to build React map apps.

/**
 * A layer service class to handle layer adding, removing and visiblity.
 */
var LayerService = function LayerService(layers) {
  this.layers = layers;
  this.callbacks = {};
  this.keys = [];
  this.listenChangeEvt();
};

LayerService.prototype.addLayer = function addLayer (layer) {
  this.layers.push(layer);
};

LayerService.prototype.getLayers = function getLayers () {
  return this.layers;
};

LayerService.prototype.setLayers = function setLayers (layers) {
  this.layers = layers;
  this.listenChangeEvt();
  // When we change the layers we trigger an change:layers event
  (this.callbacks['change:layers'] || []).forEach(function (cb) { return cb(layers); });
};

LayerService.prototype.getLayersAsFlatArray = function getLayersAsFlatArray (optLayers) {
    var this$1 = this;

  var layers = [];
  (optLayers || this.getLayers() || []).forEach(function (l) {
    layers.push(l);
    var children = l.getChildren();
    layers = layers.concat(this$1.getLayersAsFlatArray(children));
  });
  return layers;
};

LayerService.prototype.getLayer = function getLayer (name) {
  return this.getLayersAsFlatArray().find(function (l) { return l.getName() === name; });
};

LayerService.prototype.getParent = function getParent (child) {
  return this.getLayersAsFlatArray().find(
    function (l) { return !!l.getChildren().includes(child); }
  );
};

LayerService.prototype.getRadioGroupLayers = function getRadioGroupLayers (radioGroupName) {
  if (radioGroupName) {
    return this.getLayersAsFlatArray().filter(
      function (l) { return l.getRadioGroup() === radioGroupName; }
    );
  }

  return null;
};

LayerService.prototype.getBaseLayers = function getBaseLayers () {
  return this.getLayersAsFlatArray().filter(function (l) { return l.getIsBaseLayer(); });
};

LayerService.prototype.getQueryableLayers = function getQueryableLayers () {
  return this.getLayersAsFlatArray().filter(
    function (layer) { return layer.getVisible() && layer.isQueryable; }
  );
};

LayerService.prototype.getFeatureInfoAtCoordinate = function getFeatureInfoAtCoordinate (coordinate) {
  var promises = this.getQueryableLayers().map(function (layer) {
    return layer
      .getFeatureInfoAtCoordinate(coordinate, layer.filter)
      .then(function (featureInfo) {
        return featureInfo;
      });
  });
  return Promise.all(promises);
};

LayerService.prototype.on = function on (evt, callback) {
  this.un(evt, callback);
  this.callbacks[evt] = this.callbacks[evt] || [];
  this.callbacks[evt].push(callback);
};

LayerService.prototype.un = function un (evt, callback) {
  for (var i = 0; i < (this.callbacks[evt] || []).length; i += 1) {
    if (callback === this.callbacks[evt][i]) {
      this.callbacks[evt].splice(i, 1);
      break;
    }
  }
};

LayerService.prototype.listenChangeEvt = function listenChangeEvt () {
    var this$1 = this;

  this.getLayersAsFlatArray().forEach(function (layer) {
    this$1.keys.push(
      layer.on('change:visible', function (evt) {
        var visible = evt.target.getVisible();

        // Apply to siblings only if it's a radio group.
        if (
          !evt.stopPropagationSiblings &&
          layer.getRadioGroup() &&
          visible
        ) {
          var siblings = this$1.getRadioGroupLayers(
            layer.getRadioGroup()
          ).filter(function (l) { return l !== layer; });

          siblings.forEach(function (s) {
            if (
              visible &&
              s.getRadioGroup() &&
              evt.target.getRadioGroup() === s.getRadioGroup()
            ) {
              s.setVisible(false, false, true, true);
            }
          });
        }

        // Apply to children
        if (!evt.stopPropagationDown && layer.children) {
          layer.children.forEach(function (child) {
            child.setVisible(visible, false, true, false);
          });
        }

        // Apply to parent only if:
        // - a child is visible
        // - all children are hidden
        var parentLayer = this$1.getParent(layer);

        if (
          !evt.stopPropagationUp &&
          parentLayer &&
          (visible ||
            (!visible && !parentLayer.children.find(function (c) { return c.getVisible(); })))
        ) {
          parentLayer.setVisible(visible, true, false, false);
        }

        (this$1.callbacks['change:visible'] || []).forEach(function (cb) { return cb(evt.target); }
        );
      })
    );
  });
};

export default LayerService;

//# sourceMappingURL=LayerService.js.map