mobility-toolbox-js 2.0.1-beta.13 → 2.1.0

package/common/layers/Layer.test.js

@@ -1,526 +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",
-      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("layer");
-    expect(layer.isBaseLayer).toBe(false);
-    expect(layer.isBaseLayer).toBe(false);
-    expect(layer.isQueryable).toBe(true);
-    expect(layer.isClickActive).toBe(true);
-    expect(layer.isHoverActive).toBe(true);
-    expect(layer.hitTolerance).toBe(5);
-    expect(layer.isMobilityLayer).toBe(true);
-    expect(layer.copyrights).toBe();
-    expect(layer.visible).toBe(true);
-    expect(layer.properties).toEqual({});
-    expect(layer.map).toBe(void 0);
-    expect(layer.clickCallbacks).toEqual([]);
-    expect(layer.hoverCallbacks).toEqual([]);
-  });
-  test("should be visible by default.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer.visible).toBe(true);
-  });
-  test("should be hidden using constructor.", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    expect(layer.visible).toBe(false);
-  });
-  test("should be hidden using setter.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    layer.setVisible(false);
-    expect(layer.visible).toBe(false);
-  });
-  test("should visibility stay unchanged", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    layer.setVisible(false);
-    expect(layer.visible).toBe(false);
-  });
-  test("should return its name.", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    expect(layer.name).toEqual("Layer");
-  });
-  test("should set isClickActive and isHoverActive to false if isQueryable is set to false.", () => {
-    const options = {
-      name: "Layer",
-      isQueryable: false,
-      isClickActive: true,
-      isHoverActive: true,
-      olLayer
-    };
-    const layer = new Layer(options);
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.isQueryable).toBe(false);
-    expect(layer.isClickActive).toBe(false);
-    expect(layer.isHoverActive).toBe(false);
-  });
-  test("should called terminate on initialization.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    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({
-      name: "foo",
-      children: [
-        new Layer({
-          name: "bar"
-        }),
-        new Layer({
-          name: "foobar",
-          visible: false
-        })
-      ]
-    });
-    expect(layer.getVisibleChildren().length).toBe(1);
-    expect(layer.hasVisibleChildren()).toBe(true);
-  });
-  test("should set onClick using constructor.", () => {
-    const fn = () => {
-    };
-    const layer = new Layer({
-      name: "Layer",
-      olLayer,
-      onClick: fn,
-      onHover: fn
-    });
-    expect(layer.clickCallbacks[0]).toBe(fn);
-    expect(layer.hoverCallbacks[0]).toBe(fn);
-  });
-  test("should onClick throw error.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(() => {
-      layer.onClick("not of type function");
-    }).toThrow(Error);
-  });
-  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("#get() and #set()", () => {
-    test("should get/set a properties.", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      expect(layer.get("foo")).toBe(void 0);
-      layer.set("foo", "bar");
-      expect(layer.get("foo")).toBe("bar");
-    });
-  });
-  describe("#set()", () => {
-    test("should dispatch a change event.", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const spy = jest.spyOn(layer, "dispatchEvent");
-      layer.set("foo", "bar");
-      expect(spy).toHaveBeenCalledWith({ type: "change:foo", target: layer });
-    });
-  });
-  describe("#setVisible()", () => {
-    test("should not trigger a change event if the visiblity hasn't changed.", () => {
-      const layer = new Layer({
-        name: "Layer",
-        visible: false,
-        olLayer
-      });
-      const spy = jest.spyOn(layer, "dispatchEvent");
-      layer.setVisible(false, "foo", "bar", "qux");
-      expect(spy).toHaveBeenCalledTimes(0);
-    });
-    test("should trigger a change event only if the visiblity change.", () => {
-      const layer = new Layer({
-        name: "Layer",
-        visible: false,
-        olLayer
-      });
-      const spy = jest.spyOn(layer, "dispatchEvent");
-      layer.setVisible(true, "foo", "bar", "qux");
-      expect(layer.visible).toBe(true);
-      expect(spy).toHaveBeenCalledTimes(1);
-      expect(spy).toHaveBeenCalledWith({
-        type: "change:visible",
-        target: layer,
-        stopPropagationDown: "foo",
-        stopPropagationUp: "bar",
-        stopPropagationSiblings: "qux"
-      });
-    });
-  });
-  describe("#getVisibleChildren()", () => {
-    test("should return only visible child.", () => {
-      const layerVisible = { visible: true };
-      const layerVisible2 = { visible: true };
-      const layerHidden = { visible: false };
-      const layer = new Layer({
-        name: "Layer",
-        visible: false,
-        olLayer,
-        children: [layerVisible, layerHidden, layerVisible2]
-      });
-      expect(layer.getVisibleChildren()).toEqual([layerVisible, layerVisible2]);
-    });
-  });
-  describe("#hasVisibleChildren()", () => {
-    test("should return true.", () => {
-      const layerVisible = { visible: true };
-      const layerVisible2 = { visible: true };
-      const layerHidden = { visible: false };
-      const layer = new Layer({
-        name: "Layer",
-        visible: false,
-        olLayer,
-        children: [layerVisible, layerHidden, layerVisible2]
-      });
-      expect(layer.hasVisibleChildren()).toEqual(true);
-    });
-    test("should return false.", () => {
-      const layerHidden = { visible: false };
-      const layer = new Layer({
-        name: "Layer",
-        visible: false,
-        olLayer,
-        children: [layerHidden]
-      });
-      expect(layer.hasVisibleChildren()).toEqual(false);
-    });
-  });
-  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();
-      });
-    });
-  });
-  describe("#onClick()", () => {
-    test("adds function to clickCallbacks array", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onClick(fn);
-      expect(layer.clickCallbacks).toEqual([fn]);
-      layer.onClick(fn2);
-      expect(layer.clickCallbacks).toEqual([fn, fn2]);
-    });
-    test("triggers Error if parameter is not a function", (done) => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      try {
-        layer.onClick("test");
-      } catch (e) {
-        expect(e).toBeDefined();
-        done();
-      }
-    });
-  });
-  describe("#unClick()", () => {
-    test("removes function from clickCallbacks array", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onClick(fn);
-      expect(layer.clickCallbacks).toEqual([fn]);
-      layer.onClick(fn2);
-      expect(layer.clickCallbacks).toEqual([fn, fn2]);
-      layer.unClick(fn);
-      expect(layer.clickCallbacks).toEqual([fn2]);
-      layer.unClick(fn);
-      expect(layer.clickCallbacks).toEqual([fn2]);
-    });
-  });
-  describe("#onUserClickCallback()", () => {
-    const evt = { type: "signleclick", coordinate: [0, 0] };
-    const getFeatureInfo = (layer, features = []) => ({
-      features,
-      layer,
-      coordinate: evt.coordinate,
-      event: evt
-    });
-    test("calls click callback functions", (done) => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-      layer.onClick(fn);
-      layer.onClick(fn2);
-      layer.onUserClickCallback(evt).then((featureInfo) => {
-        expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy).toHaveBeenCalledWith(evt.coordinate);
-        expect(featureInfo).toBe(goodFeatureInfo);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        expect(fn2).toHaveBeenCalledTimes(1);
-        expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        done();
-      });
-    });
-    describe("returns empty feature info", () => {
-      test("if isClickActive = false", (done) => {
-        const layer = new Layer({
-          name: "Layer",
-          isClickActive: false,
-          olLayer
-        });
-        layer.onClick(jest.fn());
-        layer.onUserClickCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-      test("if clickCallbacks is empty", (done) => {
-        const layer = new Layer({
-          name: "Layer",
-          olLayer
-        });
-        layer.onUserClickCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-      test("if an error is thrown in click callback", (done) => {
-        const layer = new Layer({
-          name: "Layer",
-          olLayer
-        });
-        layer.onClick(() => {
-          throw new Error("foo");
-        });
-        layer.onUserClickCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-    });
-    test("triggers Error if parameter is not a function", (done) => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      try {
-        layer.onClick("test");
-      } catch (e) {
-        expect(e).toBeDefined();
-        done();
-      }
-    });
-  });
-  describe("#onHover()", () => {
-    test("adds function to clickCallbacks array", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onHover(fn);
-      expect(layer.hoverCallbacks).toEqual([fn]);
-      layer.onHover(fn2);
-      expect(layer.hoverCallbacks).toEqual([fn, fn2]);
-    });
-    test("triggers Error if parameter is not a function", (done) => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      try {
-        layer.onHover("test");
-      } catch (e) {
-        expect(e).toBeDefined();
-        done();
-      }
-    });
-  });
-  describe("#unHover()", () => {
-    test("removes function from clickCallbacks array", () => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onHover(fn);
-      expect(layer.hoverCallbacks).toEqual([fn]);
-      layer.onHover(fn2);
-      expect(layer.hoverCallbacks).toEqual([fn, fn2]);
-      layer.unHover(fn);
-      expect(layer.hoverCallbacks).toEqual([fn2]);
-      layer.unHover(fn);
-      expect(layer.hoverCallbacks).toEqual([fn2]);
-    });
-  });
-  describe("#onUserMoveCallback()", () => {
-    const evt = { type: "pointermove", coordinate: [0, 0] };
-    const getFeatureInfo = (layer, features = []) => ({
-      features,
-      layer,
-      coordinate: evt.coordinate,
-      event: evt
-    });
-    test("calls hover callback functions", (done) => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-      layer.onHover(fn);
-      layer.onHover(fn2);
-      layer.onUserMoveCallback(evt).then((featureInfo) => {
-        expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy).toHaveBeenCalledWith(evt.coordinate);
-        expect(featureInfo).toBe(goodFeatureInfo);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        expect(fn2).toHaveBeenCalledTimes(1);
-        expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        done();
-      });
-    });
-    describe("returns empty feature info", () => {
-      test("if isHoverActive = false", (done) => {
-        const layer = new Layer({
-          name: "Layer",
-          isHoverActive: false,
-          olLayer
-        });
-        layer.onHover(jest.fn());
-        layer.onUserMoveCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-      test("if hoverCallbacks is empty", (done) => {
-        const layer = new Layer({
-          name: "Layer",
-          olLayer
-        });
-        layer.onUserMoveCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-      test("if an error is thrown in hover callback", (done) => {
-        const layer = new Layer({
-          name: "Layer",
-          olLayer
-        });
-        layer.onHover(() => {
-          throw new Error("foo");
-        });
-        layer.onUserMoveCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-    });
-    test("triggers Error if parameter is not a function", (done) => {
-      const layer = new Layer({
-        name: "Layer",
-        olLayer
-      });
-      try {
-        layer.onHover("test");
-      } catch (e) {
-        expect(e).toBeDefined();
-        done();
-      }
-    });
-  });
-});

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;

package/common/mixins/SearchMixin.js

@@ -1,110 +0,0 @@
-import { StopsAPI } from "../../api";
-export class SearchInterface {
-  constructor(options = {}) {
-  }
-  search(query, abortController) {
-  }
-}
-const SearchMixin = (Base) => class extends Base {
-  constructor(options = {}) {
-    super(options);
-    const { apiParams, apiKey, url } = options;
-    this.apiParams = { limit: 20, ...apiParams || {} };
-    this.placeholder = options.placeholder || "Search for a stop...";
-    const apiOptions = { apiKey };
-    if (url) {
-      apiOptions.url = url;
-    }
-    this.api = new StopsAPI(apiOptions);
-    this.abortController = new AbortController();
-  }
-  render(featureCollection) {
-    const suggestions = featureCollection?.features || [];
-    if (!this.suggestionsElt) {
-      return;
-    }
-    this.suggestionsElt.style.display = suggestions.length ? "block" : "none";
-    this.suggestionsElt.innerHTML = "";
-    suggestions.forEach((suggestion) => {
-      const { properties } = suggestion;
-      const suggElt = document.createElement("div");
-      suggElt.innerHTML = properties.name;
-      suggElt.onclick = () => {
-        this.onSuggestionClick(suggestion);
-      };
-      Object.assign(suggElt.style, {
-        padding: "5px 12px"
-      });
-      this.suggestionsElt.appendChild(suggElt);
-    });
-  }
-  createDefaultElement() {
-    this.element = document.createElement("div");
-    this.element.id = "mbt-search";
-    Object.assign(this.element.style, {
-      position: "absolute",
-      top: 0,
-      left: "50px",
-      margin: "10px",
-      display: "flex",
-      flexDirection: "column",
-      width: "320px"
-    });
-    this.inputElt = document.createElement("input");
-    this.inputElt.type = "text";
-    this.inputElt.placeholder = this.placeholder;
-    this.inputElt.autoComplete = "off";
-    this.inputElt.onkeyup = (evt) => {
-      this.abortController.abort();
-      this.abortController = new AbortController();
-      this.search(evt.target.value, this.abortController);
-    };
-    Object.assign(this.inputElt.style, {
-      padding: "10px 30px 10px 10px"
-    });
-    this.element.appendChild(this.inputElt);
-    this.suggestionsElt = document.createElement("div");
-    Object.assign(this.suggestionsElt.style, {
-      backgroundColor: "white",
-      overflowY: "auto",
-      cursor: "pointer"
-    });
-    this.element.appendChild(this.suggestionsElt);
-    this.clearElt = document.createElement("div");
-    Object.assign(this.clearElt.style, {
-      display: "none",
-      position: "absolute",
-      right: "0",
-      padding: "0 10px",
-      fontSize: "200%",
-      cursor: "pointer"
-    });
-    this.clearElt.innerHTML = "\xD7";
-    this.clearElt.onclick = () => this.clear();
-    this.element.appendChild(this.clearElt);
-  }
-  search(q, abortController) {
-    if (q !== void 0 || q !== null) {
-      this.apiParams.q = q;
-    }
-    if (this.clearElt) {
-      this.clearElt.style.display = "block";
-    }
-    return this.api.search(this.apiParams, abortController).then((data) => {
-      this.render(data);
-    }).catch(() => {
-      this.render();
-    });
-  }
-  onSuggestionClick(suggestion) {
-  }
-  clear() {
-    if (!this.suggestionsElt) {
-      return;
-    }
-    this.inputElt.value = "";
-    this.suggestionsElt.innerHTML = "";
-    this.clearElt.style.display = "none";
-  }
-};
-export default SearchMixin;