mobility-toolbox-js 2.0.0-beta.32 → 2.0.0-beta.33

package/common/layers/Layer.js

@@ -1,140 +0,0 @@
-import BaseObject from "ol/Object";
-import { v4 as uuid } from "uuid";
-import getLayersAsFlatArray from "../utils/getLayersAsFlatArray";
-export default class Layer extends BaseObject {
-  constructor(options = {}) {
-    super();
-    this.defineProperties(options);
-    this.setProperties(options.properties);
-    this.visible = options.visible === void 0 ? true : !!options.visible;
-    this.group = options.group;
-    this.copyrights = options.copyrights;
-    this.children = options.children;
-    this.on(`change:visible:group`, (evt) => {
-      if (this.group === evt.target.group && this !== evt.target && this.visible) {
-        this.visible = false;
-      } else if (this.children) {
-        this.children.forEach((child) => child.dispatchEvent(evt));
-      }
-    });
-  }
-  defineProperties(options) {
-    const { name, key, properties, hitTolerance } = {
-      ...options
-    };
-    const uid = uuid();
-    Object.defineProperties(this, {
-      name: {
-        value: name
-      },
-      key: {
-        value: key || uid
-      },
-      group: {
-        get: () => this.get("group"),
-        set: (newGroup) => {
-          this.set("group", newGroup);
-        }
-      },
-      copyrights: {
-        get: () => this.get("copyrights"),
-        set: (newCopyrights) => {
-          const arrValue = newCopyrights && !Array.isArray(newCopyrights) ? [newCopyrights] : newCopyrights;
-          this.set("copyrights", arrValue || []);
-        }
-      },
-      options: {
-        value: options
-      },
-      map: {
-        writable: true
-      },
-      visible: {
-        get: () => this.get("visible"),
-        set: (newVisible) => {
-          if (newVisible === this.visible) {
-            return;
-          }
-          this.set("visible", newVisible);
-          if (this.visible) {
-            if (this.parent && !this.parent.visible) {
-              this.parent.visible = true;
-            }
-            if (this.children && this.children.find((child) => child.group)) {
-              const child = this.children.find((childd) => !!childd.group);
-              child.visible = true;
-            }
-            if (this.parent && this.group) {
-              let higherParent = this.parent;
-              while (higherParent.parent) {
-                higherParent = higherParent.parent;
-              }
-              higherParent.dispatchEvent({
-                type: `change:visible:group`,
-                target: this
-              });
-            }
-          } else if (!this.visible) {
-            if (this.parent && this.parent.visible && !this.parent.children.find((child) => child.visible)) {
-              this.parent.visible = false;
-            }
-          }
-        }
-      },
-      disabled: {
-        get: () => this.get("disabled"),
-        set: (newValue) => {
-          this.set("disabled", newValue);
-        }
-      },
-      parent: {
-        value: null,
-        writable: true
-      },
-      children: {
-        get: () => this.get("children") || [],
-        set: (newValue) => {
-          (this.children || []).forEach((child) => {
-            child.parent = null;
-          });
-          if (Array.isArray(newValue)) {
-            newValue.forEach((child) => {
-              child.parent = this;
-            });
-          }
-          this.set("children", newValue || []);
-        }
-      },
-      hitTolerance: {
-        value: hitTolerance || 5,
-        writable: true
-      },
-      properties: {
-        value: { ...properties || {} }
-      }
-    });
-  }
-  attachToMap(map) {
-    this.detachFromMap();
-    this.map = map;
-    if (this.children) {
-      this.children.forEach((child) => {
-        child.attachToMap(map);
-      });
-    }
-  }
-  detachFromMap() {
-    this.map = null;
-  }
-  getFeatureInfoAtCoordinate(coordinate, options) {
-    console.error("getFeatureInfoAtCoordinate must be implemented by inheriting layers", this.key);
-    return Promise.resolve({
-      layer: this,
-      features: [],
-      coordinate
-    });
-  }
-  flat() {
-    return getLayersAsFlatArray(this);
-  }
-}

package/common/layers/Layer.test.js

@@ -1,134 +0,0 @@
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import Layer from "./Layer";
-const olLayer = new VectorLayer({ source: new VectorSource() });
-describe("Layer", () => {
-  test("should initialize.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer).toBeInstanceOf(Layer);
-  });
-  test("should define default properties.", () => {
-    const options = {
-      name: "Layer",
-      key: "Layerkey",
-      olLayer
-    };
-    const layer = new Layer(options);
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.options).toEqual(options);
-    expect(layer.name).toEqual(options.name);
-    expect(layer.key).toEqual("Layerkey");
-    expect(layer.hitTolerance).toBe(5);
-    expect(layer.copyrights).toEqual([]);
-    expect(layer.visible).toBe(true);
-    expect(layer.properties).toEqual({});
-    expect(layer.map).toBe(void 0);
-    expect(layer.group).toBe(void 0);
-  });
-  test("should be visible by default.", () => {
-    const layer = new Layer();
-    expect(layer.visible).toBe(true);
-  });
-  test("should be hidden using constructor.", () => {
-    const layer = new Layer({ visible: false });
-    expect(layer.visible).toBe(false);
-  });
-  test("should be hidden using setter.", () => {
-    const layer = new Layer();
-    layer.visible = false;
-    expect(layer.visible).toBe(false);
-  });
-  test("should visibility stay unchanged", () => {
-    const layer = new Layer();
-    layer.visible = false;
-    expect(layer.visible).toBe(false);
-  });
-  test("should return its name.", () => {
-    const layer = new Layer({ name: "Layer" });
-    expect(layer.name).toEqual("Layer");
-  });
-  test("should called detachFromMap on initialization.", () => {
-    const layer = new Layer();
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap();
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should properties correctly set and get.", () => {
-    const layer = new Layer({
-      name: "Layer",
-      olLayer,
-      properties: {
-        abc: "foo"
-      }
-    });
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.get("abc")).toEqual("foo");
-    layer.set("abc", "bar");
-    expect(layer.get("abc")).toEqual("bar");
-  });
-  test("should set children", () => {
-    const layer = new Layer({
-      children: [new Layer(), new Layer()]
-    });
-    expect(layer.children.length).toBe(2);
-    expect(layer.children[0].parent).toBe(layer);
-    expect(layer.children[1].parent).toBe(layer);
-  });
-  test("should initialize copyrights property.", () => {
-    const layer = new Layer({
-      name: "Layer",
-      olLayer,
-      copyrights: ["&copy: copyright", "another copyright"]
-    });
-    expect(layer.copyrights[0]).toEqual("&copy: copyright");
-  });
-  test("should set and get copyright property.", () => {
-    const layer = new Layer({
-      name: "Layer",
-      olLayer
-    });
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.copyright).toEqual(void 0);
-    layer.copyright = "© OSM Contributors";
-    expect(layer.copyright).toEqual("© OSM Contributors");
-  });
-  describe("#attachToMap()", () => {
-    test("should set map.", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      expect(layer.map).toBe(void 0);
-      const obj = {};
-      layer.attachToMap(obj);
-      expect(layer.map).toBe(obj);
-    });
-    test("should call terminate.", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const spy = jest.spyOn(layer, "detachFromMap");
-      layer.attachToMap();
-      expect(spy).toHaveBeenCalledTimes(1);
-    });
-  });
-  describe("#getFeatureInfoAtCoordinate()", () => {
-    test("return an empty fetaureInfo object and display an error message", (done) => {
-      console.error = jest.fn();
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const coord = [0, 0];
-      layer.getFeatureInfoAtCoordinate(coord).then((featureInfo) => {
-        expect(featureInfo.features).toEqual([]);
-        expect(featureInfo.layer).toEqual(layer);
-        expect(featureInfo.coordinate).toEqual(coord);
-        expect(console.error).toHaveBeenCalledTimes(1);
-        done();
-        console.error.mockRestore();
-      });
-    });
-  });
-});

package/common/mixins/CopyrightMixin.js

@@ -1,24 +0,0 @@
-export class CopyrightInterface {
-  getCopyrights() {
-  }
-}
-const CopyrightMixin = (Base) => class extends Base {
-  render() {
-    if (!this.element) {
-      return;
-    }
-    this.element.innerHTML = this.active ? this.getCopyrights().join(" | ") : "";
-  }
-  createDefaultElement() {
-    this.element = document.createElement("div");
-    this.element.id = "mbt-copyright";
-    Object.assign(this.element.style, {
-      position: "absolute",
-      bottom: 0,
-      right: 0,
-      fontSize: ".8rem",
-      padding: "0 10px"
-    });
-  }
-};
-export default CopyrightMixin;