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

package/ol/layers/Layer.test.js

@@ -1,175 +0,0 @@
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import Map from "ol/Map";
-import Group from "ol/layer/Group";
-import Layer from "./Layer";
-let olLayer;
-let map;
-describe("Layer", () => {
-  beforeEach(() => {
-    map = new Map({});
-    olLayer = new VectorLayer({ source: new VectorSource() });
-  });
-  test("should initialize.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer).toBeInstanceOf(Layer);
-  });
-  test("should be visible by default.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer.visible).toBe(true);
-  });
-  test("should be invisible if defined.", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    expect(layer.visible).toBe(false);
-  });
-  test("should be invisible if set.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    layer.visible = false;
-    expect(layer.visible).toBe(false);
-  });
-  test("should visibility stay unchanged", () => {
-    const layer = new Layer({ name: "Layer", visible: false, olLayer });
-    layer.visible = 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 call terminate on initialization.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap();
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-  test("should remove the layer when we call terminate.", () => {
-    const layer = new Layer({ name: "Layer", olLayer });
-    const spy = jest.spyOn(layer, "detachFromMap");
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(1);
-    layer.detachFromMap(map);
-    expect(spy).toHaveBeenCalledTimes(2);
-  });
-  test("should manage copyrights as string.", () => {
-    const spy = jest.spyOn(VectorSource.prototype, "setAttributions");
-    const layer = new Layer({ name: "Layer", copyrights: "foo", olLayer });
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledWith(["foo"]);
-  });
-  test("should manage copyrights as array.", () => {
-    const spy = jest.spyOn(VectorSource.prototype, "setAttributions");
-    const layer = new Layer({ name: "Layer", copyrights: ["bar"], olLayer });
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledWith(["bar"]);
-  });
-  test("should set attributions for Group.", () => {
-    const spy = jest.spyOn(VectorSource.prototype, "setAttributions");
-    const layer = new Layer({
-      name: "Layer",
-      copyrights: ["bar"],
-      olLayer: new Group({ layers: [olLayer] })
-    });
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledWith(["bar"]);
-  });
-  test("should listen for click/hover events when layer is visible by default then should not when hidden.", async () => {
-    global.console.error = jest.fn();
-    const layer = new Layer({ name: "Layer", olLayer });
-    expect(layer.visible).toBe(true);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [0, 0] });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.visible = false;
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [0, 0] });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    global.console.error.mockRestore();
-  });
-  test("should not listen for click/hover events when layer is not visible by default then should not when visible.", async () => {
-    global.console.error = jest.fn();
-    const layer = new Layer({ name: "Layer", olLayer, visible: false });
-    expect(layer.visible).toBe(false);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [0, 0] });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.visible = true;
-    await map.dispatchEvent({ type: "pointermove", map, coordinate: [0, 0] });
-    await map.dispatchEvent({ type: "singleclick", map, coordinate: [0, 0] });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    global.console.error.mockRestore();
-  });
-  test("should not listen for click/hover events  after layer.detachFromMap()", async () => {
-    global.console.error = jest.fn();
-    const layer = new Layer({ name: "Layer", olLayer, visible: true });
-    expect(layer.visible).toBe(true);
-    const spy = jest.fn();
-    const spy2 = jest.fn();
-    layer.attachToMap(map);
-    layer.onHover(spy);
-    layer.onClick(spy2);
-    layer.attachToMap(map);
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    await map.dispatchEvent({
-      type: "pointermove",
-      map,
-      coordinate: [0, 0]
-    });
-    await map.dispatchEvent({
-      type: "singleclick",
-      map,
-      coordinate: [0, 0]
-    });
-    expect(spy).toHaveBeenCalledTimes(1);
-    expect(spy2).toHaveBeenCalledTimes(1);
-    spy.mockReset();
-    spy2.mockReset();
-    layer.detachFromMap(map);
-    await map.dispatchEvent({
-      type: "pointermove",
-      map,
-      coordinate: [0, 0]
-    });
-    await map.dispatchEvent({
-      type: "singleclick",
-      map,
-      coordinate: [0, 0]
-    });
-    expect(spy).toHaveBeenCalledTimes(0);
-    expect(spy2).toHaveBeenCalledTimes(0);
-    global.console.error.mockRestore();
-  });
-  test("should clone", () => {
-    const layer = new Layer({
-      name: "Layer",
-      copyrights: ["bar"],
-      olLayer: new Group({ layers: [olLayer] })
-    });
-    const clone = layer.clone({ name: "clone" });
-    expect(clone).not.toBe(layer);
-    expect(clone.name).toBe("clone");
-    expect(clone).toBeInstanceOf(Layer);
-  });
-});

package/ol/layers/MapboxLayer.js

@@ -1,204 +0,0 @@
-import { toLonLat } from "ol/proj";
-import { Map } from "mapbox-gl";
-import Source from "ol/source/Source";
-import OLLayer from "ol/layer/Layer";
-import GeoJSON from "ol/format/GeoJSON";
-import Layer from "./Layer";
-import { getMapboxMapCopyrights, getUrlWithParams } from "../../common/utils";
-export default class MapboxLayer extends Layer {
-  constructor(options = {}) {
-    const mbLayer = new OLLayer({
-      source: new Source({}),
-      render: (frameState) => {
-        if (!this.map || !this.mbMap) {
-          return null;
-        }
-        let changed = false;
-        const canvas = this.mbMap.getCanvas();
-        const { viewState } = frameState;
-        const visible = this.olLayer.getVisible();
-        if (this.renderState.visible !== visible) {
-          canvas.style.display = visible ? "block" : "none";
-          this.renderState.visible = visible;
-          canvas.style.position = "absolute";
-        }
-        const opacity = this.olLayer.getOpacity();
-        if (this.renderState.opacity !== opacity) {
-          canvas.style.opacity = opacity;
-          this.renderState.opacity = opacity;
-        }
-        const { rotation } = viewState;
-        if (this.renderState.rotation !== rotation) {
-          this.mbMap.rotateTo(-(rotation || 0) * 180 / Math.PI, {
-            animate: false
-          });
-          changed = true;
-          this.renderState.rotation = rotation;
-        }
-        if (this.renderState.zoom !== viewState.zoom || this.renderState.center[0] !== viewState.center[0] || this.renderState.center[1] !== viewState.center[1]) {
-          this.mbMap.jumpTo({
-            center: toLonLat(viewState.center),
-            zoom: viewState.zoom - 1,
-            animate: false
-          });
-          changed = true;
-          this.renderState.zoom = viewState.zoom;
-          this.renderState.center = viewState.center;
-        }
-        const size = this.map.getSize();
-        if (this.renderState.size[0] !== size[0] || this.renderState.size[1] !== size[1]) {
-          changed = true;
-          this.renderState.size = size;
-        }
-        if (this.mbMap && this.mbMap.style && this.mbMap.isStyleLoaded() && changed) {
-          try {
-            if (this.mbMap._frame) {
-              this.mbMap._frame.cancel();
-              this.mbMap._frame = null;
-            }
-            this.mbMap._render();
-          } catch (err) {
-            console.warn(err);
-          }
-        }
-        return this.mbMap.getContainer();
-      }
-    });
-    super({
-      ...options,
-      olLayer: mbLayer
-    });
-    this.styleUrl = options.url;
-    this.apiKey = options.apiKey;
-    this.apiKeyName = options.apiKeyName || "key";
-    this.updateAttribution = this.updateAttribution.bind(this);
-  }
-  attachToMap(map) {
-    super.attachToMap(map);
-    if (!this.map || this.mbMap) {
-      return;
-    }
-    this.format = new GeoJSON({
-      featureProjection: this.map.getView().getProjection()
-    });
-    this.loadMbMap();
-    this.olListenersKeys.push(this.map.on("change:size", () => {
-      try {
-        if (this.mbMap) {
-          this.mbMap.resize();
-        }
-      } catch (err) {
-        console.warn(err);
-      }
-    }));
-  }
-  detachFromMap() {
-    if (this.mbMap) {
-      this.mbMap.off("idle", this.updateAttribution);
-      this.mbMap.triggerRepaint = () => {
-      };
-      this.mbMap.remove();
-      this.mbMap = null;
-    }
-    this.loaded = false;
-    super.detachFromMap();
-  }
-  loadMbMap() {
-    this.olListenersKeys.push(this.map.on("change:target", () => {
-      this.loadMbMap();
-    }));
-    if (!this.map.getTargetElement()) {
-      return;
-    }
-    if (!this.visible) {
-      this.olListenersKeys.push(this.once("change:visible", () => {
-        this.loadMbMap();
-      }));
-      return;
-    }
-    let [x, y] = this.map.getView().getCenter();
-    if (!x || !y) {
-      x = 0;
-      y = 0;
-    }
-    const container = document.createElement("div");
-    container.style.position = "absolute";
-    container.style.width = "100%";
-    container.style.height = "100%";
-    if (!this.apiKey && !this.styleUrl.includes(this.apiKeyName)) {
-      console.warn(`No apiKey is defined for request to ${this.styleUrl}`);
-    }
-    this.mbMap = new Map({
-      style: getUrlWithParams(this.styleUrl, {
-        [this.apiKeyName]: this.apiKey
-      }).toString(),
-      container,
-      interactive: false,
-      trackResize: false,
-      attributionControl: false,
-      ...this.options.mapOptions || {}
-    });
-    this.renderState = {
-      center: [x, y],
-      zoom: null,
-      rotation: null,
-      visible: null,
-      opacity: null,
-      size: [0, 0]
-    };
-    this.mbMap.once("load", () => {
-      this.mbMap.resize();
-      this.loaded = true;
-      this.copyrights = getMapboxMapCopyrights(this.mbMap) || [];
-      this.olLayer.getSource()?.setAttributions(this.copyrights);
-      this.dispatchEvent({
-        type: "load",
-        target: this
-      });
-    });
-    const mapboxCanvas = this.mbMap.getCanvas();
-    if (mapboxCanvas) {
-      if (this.options.tabIndex) {
-        mapboxCanvas.setAttribute("tabindex", this.options.tabIndex);
-      } else {
-        mapboxCanvas.removeAttribute("tabindex");
-      }
-    }
-    this.mbMap.on("idle", this.updateAttribution);
-  }
-  updateAttribution(evt) {
-    const newAttributions = getMapboxMapCopyrights(evt.target) || [];
-    if (this.copyrights.toString() !== newAttributions.toString()) {
-      this.copyrights = newAttributions;
-      this.olLayer.getSource()?.setAttributions(newAttributions);
-    }
-  }
-  getFeatureInfoAtCoordinate(coordinate, options) {
-    if (!options || !this.format || !this.mbMap || !this.mbMap.isStyleLoaded()) {
-      return Promise.resolve({ coordinate, features: [], layer: this });
-    }
-    let pixel = coordinate && this.mbMap.project(toLonLat(coordinate));
-    if (this.hitTolerance) {
-      const { x, y } = pixel;
-      pixel = [
-        { x: x - this.hitTolerance, y: y - this.hitTolerance },
-        { x: x + this.hitTolerance, y: y + this.hitTolerance }
-      ];
-    }
-    const features = this.mbMap.queryRenderedFeatures(pixel, options).map((feature) => {
-      const olFeature = this.format.readFeature(feature);
-      if (olFeature) {
-        olFeature.set("mapboxFeature", feature);
-      }
-      return olFeature;
-    });
-    return Promise.resolve({
-      layer: this,
-      features,
-      coordinate
-    });
-  }
-  clone(newOptions) {
-    return new MapboxLayer({ ...this.options, ...newOptions });
-  }
-}

package/ol/layers/MapboxLayer.test.js

@@ -1,160 +0,0 @@
-import OlMap from "ol/Map";
-import View from "ol/View";
-import gllib from "mapbox-gl";
-import MapboxLayer from "./MapboxLayer";
-let layer;
-let map;
-let consoleOutput;
-const styleUrl = "http://foo.com/styles";
-describe("MapboxLayer", () => {
-  describe("without apiKey", () => {
-    beforeEach(() => {
-      consoleOutput = [];
-      console.warn = (message) => consoleOutput.push(message);
-      layer = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl
-      });
-      map = new OlMap({
-        target: document.createElement("div"),
-        view: new View({ center: [0, 0] })
-      });
-    });
-    test("should be instanced.", () => {
-      expect(layer).toBeInstanceOf(MapboxLayer);
-      expect(layer.styleUrl).toBe(styleUrl);
-    });
-    test("should not initalized mapbox map.", () => {
-      layer.attachToMap();
-      expect(layer.mbMap).toBe();
-    });
-    test("should initalized mapbox map and warn the user if there is no api key defined.", () => {
-      layer.attachToMap(map);
-      expect(layer.mbMap).toBeInstanceOf(gllib.Map);
-      expect(consoleOutput[0]).toBe("No apiKey is defined for request to http://foo.com/styles");
-    });
-    test("should called terminate on initalization.", () => {
-      const spy = jest.spyOn(layer, "detachFromMap");
-      layer.attachToMap();
-      expect(spy).toHaveBeenCalledTimes(1);
-    });
-    test("should clone", () => {
-      const clone = layer.clone({ name: "clone" });
-      expect(clone).not.toBe(layer);
-      expect(clone.name).toBe("clone");
-      expect(clone).toBeInstanceOf(MapboxLayer);
-    });
-  });
-  describe("with apiKey", () => {
-    beforeEach(() => {
-      layer = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "apiKey"
-      });
-      map = new OlMap({
-        target: document.createElement("div"),
-        view: new View({ center: [0, 0] })
-      });
-    });
-    test("should be instanced with apiKey.", () => {
-      expect(layer).toBeInstanceOf(MapboxLayer);
-      expect(layer.styleUrl).toBe(styleUrl);
-    });
-    test("should not initalized mapbox map.", () => {
-      layer.attachToMap();
-      expect(layer.mbMap).toBe();
-    });
-    test("should initalized mapbox map, with 'apiKey' prop", () => {
-      const layer1 = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "apiKeyVal"
-      });
-      layer1.attachToMap(map);
-      expect(layer1.mbMap.options.style).toBe("http://foo.com/styles?key=apiKeyVal");
-    });
-    test("should initalized mapbox map, with 'apiKeyName' prop", () => {
-      const layer1 = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "test",
-        apiKeyName: "apiKey"
-      });
-      layer1.attachToMap(map);
-      expect(layer1.mbMap.options.style).toBe("http://foo.com/styles?apiKey=test");
-    });
-  });
-  describe("#getFeatureInfoAtCoordinate()", () => {
-    let layer1;
-    beforeEach(() => {
-      layer1 = new MapboxLayer({
-        name: "Layer",
-        url: styleUrl,
-        apiKey: "test",
-        apiKeyName: "apiKey"
-      });
-      layer1.attachToMap(map);
-      layer1.mbMap.isStyleLoaded = jest.fn(() => true);
-      layer1.mbMap.getSource = jest.fn(() => true);
-    });
-    afterEach(() => {
-      layer1.mbMap.getSource.mockRestore();
-      layer1.mbMap.isStyleLoaded.mockRestore();
-    });
-    test("should set the mapboxFeature as a property", (done) => {
-      const mapboxFeature = {
-        id: "2",
-        type: "Feature",
-        properties: {
-          foo: "bar"
-        },
-        source: "barr",
-        sourceLayer: "fooo"
-      };
-      layer1.mbMap.project = jest.fn((coord) => ({ x: coord[0], y: coord[1] }));
-      layer1.mbMap.queryRenderedFeatures = jest.fn(() => [mapboxFeature]);
-      layer1.getFeatureInfoAtCoordinate([0, 0], {}).then((featureInfo) => {
-        expect(featureInfo.features[0].get("mapboxFeature")).toBe(mapboxFeature);
-        done();
-      });
-      layer1.mbMap.project.mockRestore();
-      layer1.mbMap.queryRenderedFeatures.mockRestore();
-    });
-    describe("should use hitTolerance property", () => {
-      beforeEach(() => {
-        layer1.mbMap.project = jest.fn((coord) => ({
-          x: coord[0],
-          y: coord[1]
-        }));
-      });
-      afterEach(() => {
-        layer1.mbMap.project.mockRestore();
-        layer1.mbMap.queryRenderedFeatures.mockRestore();
-      });
-      test("when hitTolerance is not set", (done) => {
-        layer1.mbMap.queryRenderedFeatures = jest.fn((pixelBounds) => {
-          expect(pixelBounds).toEqual([
-            { x: -5, y: -5 },
-            { x: 5, y: 5 }
-          ]);
-          done();
-          return [];
-        });
-        layer1.getFeatureInfoAtCoordinate([0, 0], {});
-      });
-      test("when hitTolerance is set to 10", (done) => {
-        layer1.hitTolerance = 10;
-        layer1.mbMap.queryRenderedFeatures = jest.fn((pixelBounds) => {
-          expect(pixelBounds).toEqual([
-            { x: -10, y: -10 },
-            { x: 10, y: 10 }
-          ]);
-          done();
-          return [];
-        });
-        layer1.getFeatureInfoAtCoordinate([0, 0], {});
-      });
-    });
-  });
-});