mobility-toolbox-js 2.0.0-beta.8 → 2.0.1-beta.13

package/common/layers/Layer.js

@@ -0,0 +1,213 @@
+import Observable from "ol/Observable";
+import { v4 as uuid } from "uuid";
+export default class Layer extends Observable {
+  constructor(options = {}) {
+    super();
+    this.defineProperties(options);
+    const { onClick, onHover } = options;
+    if (onHover) {
+      this.onHover(onHover);
+    }
+    if (onClick) {
+      this.onClick(onClick);
+    }
+    if (options.copyrights) {
+      this.copyrights = options.copyrights;
+    }
+    this.onUserClickCallback = this.onUserClickCallback.bind(this);
+    this.onUserMoveCallback = this.onUserMoveCallback.bind(this);
+  }
+  defineProperties(options) {
+    const {
+      name,
+      key,
+      children,
+      visible,
+      properties,
+      isBaseLayer,
+      isQueryable,
+      isClickActive,
+      isHoverActive,
+      hitTolerance
+    } = {
+      isQueryable: true,
+      isClickActive: true,
+      isHoverActive: true,
+      ...options
+    };
+    const uid = uuid();
+    const dfltName = name || uid;
+    Object.defineProperties(this, {
+      options: {
+        value: options
+      },
+      name: {
+        value: dfltName
+      },
+      key: {
+        value: key || dfltName.toLowerCase()
+      },
+      isBaseLayer: {
+        value: !!isBaseLayer
+      },
+      isQueryable: {
+        value: !!isQueryable,
+        writable: true
+      },
+      isClickActive: {
+        value: !!isQueryable && !!isClickActive,
+        writable: true
+      },
+      isHoverActive: {
+        value: !!isQueryable && !!isHoverActive,
+        writable: true
+      },
+      hitTolerance: {
+        value: hitTolerance || 5,
+        writable: true
+      },
+      isMobilityLayer: {
+        value: true
+      },
+      children: {
+        value: children || [],
+        writable: true
+      },
+      copyrights: {
+        get: () => this.get("copyrights"),
+        set: (newCopyrights) => {
+          const arrValue = !Array.isArray(newCopyrights) ? [newCopyrights] : newCopyrights;
+          this.set("copyrights", arrValue);
+        }
+      },
+      visible: {
+        value: visible === void 0 ? true : visible,
+        writable: true
+      },
+      properties: {
+        value: { ...properties || {} }
+      },
+      map: {
+        writable: true
+      },
+      clickCallbacks: {
+        value: []
+      },
+      hoverCallbacks: {
+        value: []
+      }
+    });
+  }
+  attachToMap(map) {
+    this.detachFromMap();
+    this.map = map;
+  }
+  detachFromMap() {
+  }
+  get(name) {
+    return this.properties[name];
+  }
+  set(name, value) {
+    if (value !== this.properties[name]) {
+      this.properties[name] = value;
+      this.dispatchEvent({
+        type: `change:${name}`,
+        target: this
+      });
+    }
+  }
+  setVisible(visible, stopPropagationDown = false, stopPropagationUp = false, stopPropagationSiblings = false) {
+    if (visible === this.visible) {
+      return;
+    }
+    this.visible = visible;
+    this.dispatchEvent({
+      type: "change:visible",
+      target: this,
+      stopPropagationDown,
+      stopPropagationUp,
+      stopPropagationSiblings
+    });
+  }
+  getVisibleChildren() {
+    return this.children.filter((child) => child.visible);
+  }
+  hasVisibleChildren() {
+    return !!this.children.find((child) => child.visible === true);
+  }
+  getFeatureInfoAtCoordinate(coordinate, options) {
+    console.error("getFeatureInfoAtCoordinate must be implemented by inheriting layers", this.key);
+    this.isQueryable = false;
+    return Promise.resolve({
+      layer: this,
+      features: [],
+      coordinate
+    });
+  }
+  onClick(callback) {
+    if (typeof callback === "function") {
+      if (!this.clickCallbacks.includes(callback)) {
+        this.clickCallbacks.push(callback);
+      }
+    } else {
+      throw new Error("onClick callback must be of type function:", callback);
+    }
+  }
+  unClick(callback) {
+    if (typeof callback === "function") {
+      const idx = this.clickCallbacks.indexOf(callback);
+      if (idx > -1) {
+        this.clickCallbacks.splice(idx, 1);
+      }
+    }
+  }
+  onUserClickCallback(evt) {
+    const emptyFeatureInfo = {
+      features: [],
+      layer: this,
+      coordinate: evt.coordinate,
+      event: evt
+    };
+    if (!this.isClickActive || !this.clickCallbacks.length) {
+      return Promise.resolve(emptyFeatureInfo);
+    }
+    return this.getFeatureInfoAtCoordinate(evt.coordinate).then((featureInfo) => {
+      const { features, layer, coordinate } = featureInfo;
+      this.clickCallbacks.forEach((callback) => callback(features, layer, coordinate));
+      return featureInfo;
+    }).catch(() => emptyFeatureInfo);
+  }
+  onHover(callback) {
+    if (typeof callback === "function") {
+      if (!this.hoverCallbacks.includes(callback)) {
+        this.hoverCallbacks.push(callback);
+      }
+    } else {
+      throw new Error("callback must be of type function.");
+    }
+  }
+  unHover(callback) {
+    if (typeof callback === "function") {
+      const idx = this.hoverCallbacks.indexOf(callback);
+      if (idx > -1) {
+        this.hoverCallbacks.splice(idx, 1);
+      }
+    }
+  }
+  onUserMoveCallback(evt) {
+    const emptyFeatureInfo = {
+      features: [],
+      layer: this,
+      coordinate: evt.coordinate,
+      event: evt
+    };
+    if (!this.isHoverActive || !this.hoverCallbacks.length) {
+      return Promise.resolve(emptyFeatureInfo);
+    }
+    return this.getFeatureInfoAtCoordinate(evt.coordinate).then((featureInfo) => {
+      const { features, layer, coordinate } = featureInfo;
+      this.hoverCallbacks.forEach((callback) => callback(features, layer, coordinate));
+      return featureInfo;
+    }).catch(() => emptyFeatureInfo);
+  }
+}