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

package/common/Tracker.js

@@ -1,93 +0,0 @@
-import { compose, apply, create } from "ol/transform";
-import getVehiclePosition from "./utils/getVehiclePosition";
-export default class Tracker {
-  constructor(options) {
-    this.style = options.style;
-    this.canvas = options.canvas || document.createElement("canvas");
-  }
-  renderTrajectories(trajectories, viewState, options) {
-    const {
-      time = Date.now(),
-      size = [],
-      center,
-      resolution,
-      rotation = 0,
-      pixelRatio
-    } = viewState;
-    const {
-      noInterpolate = false,
-      hoverVehicleId,
-      selectedVehicleId
-    } = options;
-    const { canvas } = this;
-    const context = canvas.getContext("2d");
-    context.clearRect(0, 0, canvas.width, canvas.height);
-    const [width, height] = size;
-    if (width && height && (canvas.width !== width || canvas.height !== height)) {
-      [canvas.width, canvas.height] = [width * pixelRatio, height * pixelRatio];
-    }
-    const coordinateToPixelTransform = compose(create(), size[0] / 2, size[1] / 2, 1 / resolution, -1 / resolution, -rotation, -center[0], -center[1]);
-    if (canvas.style) {
-      canvas.style.width = `${canvas.width / pixelRatio}px`;
-      canvas.style.height = `${canvas.height / pixelRatio}px`;
-    }
-    let hoverVehicleImg;
-    let hoverVehiclePx;
-    let hoverVehicleWidth;
-    let hoverVehicleHeight;
-    let selectedVehicleImg;
-    let selectedVehiclePx;
-    let selectedVehicleWidth;
-    let selectedVehicleHeight;
-    let nbRendered = 0;
-    for (let i = trajectories.length - 1; i >= 0; i -= 1) {
-      const trajectory = trajectories[i];
-      const { train_id: id, timeOffset } = trajectory.properties;
-      const { coord, rotation: rotationIcon } = getVehiclePosition(time - (timeOffset || 0), trajectory, noInterpolate);
-      trajectories[i].properties.coordinate = coord;
-      trajectories[i].properties.rotation = rotationIcon;
-      if (!coord) {
-        continue;
-      }
-      let px = apply(coordinateToPixelTransform, [...coord]);
-      if (!px) {
-        continue;
-      }
-      px = px.map((p) => p * pixelRatio);
-      if (px[0] < 0 || px[0] > canvas.width || px[1] < 0 || px[1] > canvas.height) {
-        continue;
-      }
-      const vehicleImg = this.style(trajectory, viewState, options);
-      if (!vehicleImg) {
-        continue;
-      }
-      nbRendered += 1;
-      const imgWidth = vehicleImg.width;
-      const imgHeight = vehicleImg.height;
-      if (hoverVehicleId !== id && selectedVehicleId !== id) {
-        context.drawImage(vehicleImg, px[0] - imgWidth / 2, px[1] - imgHeight / 2, imgWidth, imgHeight);
-      }
-      if (hoverVehicleId && hoverVehicleId === id) {
-        hoverVehicleImg = vehicleImg;
-        hoverVehiclePx = px;
-        hoverVehicleWidth = imgWidth;
-        hoverVehicleHeight = imgHeight;
-      }
-      if (selectedVehicleId && selectedVehicleId === id) {
-        selectedVehicleImg = vehicleImg;
-        selectedVehiclePx = px;
-        selectedVehicleWidth = imgWidth;
-        selectedVehicleHeight = imgHeight;
-      }
-    }
-    if (selectedVehicleImg) {
-      context.drawImage(selectedVehicleImg, selectedVehiclePx[0] - selectedVehicleWidth / 2, selectedVehiclePx[1] - selectedVehicleHeight / 2, selectedVehicleWidth, selectedVehicleHeight);
-    }
-    if (hoverVehicleImg) {
-      context.drawImage(hoverVehicleImg, hoverVehiclePx[0] - hoverVehicleWidth / 2, hoverVehiclePx[1] - hoverVehicleHeight / 2, hoverVehicleWidth, hoverVehicleHeight);
-    }
-    return {
-      nbTrajectoriesRendered: nbRendered
-    };
-  }
-}

package/common/api/HttpAPI.test.js

@@ -1,50 +0,0 @@
-import fetch from "jest-fetch-mock";
-import API from "./HttpAPI";
-let api;
-describe("HttpAPI", () => {
-  beforeEach(() => {
-    global.fetch = fetch;
-    fetch.resetMocks();
-    api = new API({ url: "https://foo.ch", apiKey: "apiKey" });
-  });
-  describe("#fetch", () => {
-    test("should success", () => {
-      fetch.mockResponseOnce(JSON.stringify({ foo: "bar" }));
-      return api.fetch("/path", {
-        q: "Bern",
-        fooUndefined: void 0,
-        fooNull: null,
-        fooEmpty: ""
-      }).then((response) => {
-        expect(fetch.mock.calls[0][0]).toEqual("https://foo.ch/path?fooEmpty=&key=apiKey&q=Bern");
-        expect(response).toEqual({ foo: "bar" });
-      });
-    });
-    describe("should display error message", () => {
-      test("reject error", (done) => {
-        fetch.mockRejectOnce(new Error("Fake error message"));
-        return api.fetch().catch((err) => {
-          expect(err.name).toEqual("Error");
-          expect(err.message).toEqual("Fake error message");
-          done();
-        });
-      });
-      test("if the response is invalid json", (done) => {
-        fetch.mockResponseOnce("invalid json");
-        api.fetch().catch((err) => {
-          expect(err.name).toEqual("FetchError");
-          expect(err.message).toEqual("invalid json response body at  reason: Unexpected token i in JSON at position 0");
-          done();
-        });
-      });
-      test("if the response contains an error message", (done) => {
-        fetch.mockResponseOnce('{"error":"foo2"}');
-        api.fetch().catch((err) => {
-          expect(err.name).toEqual("Error");
-          expect(err.message).toEqual("foo2");
-          done();
-        });
-      });
-    });
-  });
-});

package/common/api/WebSocketAPI.test.js

@@ -1,311 +0,0 @@
-import WS from "jest-websocket-mock";
-import WebSocketAPI from "./WebSocketAPI";
-describe("WebSocketAPI", () => {
-  describe("#constructor", () => {
-    let server;
-    let server2;
-    beforeEach(() => {
-      server = new WS(`ws://foo:1234`);
-      server2 = new WS(`ws://foo:12345`);
-    });
-    afterEach(() => {
-      server.close();
-      server2.close();
-      WS.clean();
-    });
-    describe("#constructor", () => {
-      test("doesn't connect.", async () => {
-        const client = new WebSocketAPI();
-        expect(client.websocket).toBe();
-        expect(client.closed).toBe(false);
-        expect(client.closing).toBe(false);
-        expect(client.connecting).toBe(false);
-        expect(client.open).toBe(false);
-      });
-    });
-    describe("#close", () => {
-      test("should close the websocket and clear some property", async () => {
-        const client = new WebSocketAPI();
-        const subsc2 = {
-          params: "foo",
-          cb: () => {
-          },
-          errorCb: () => {
-          },
-          quiet: false
-        };
-        client.subscriptions = [subsc2];
-        client.messagesOnOpen = ["GET foo"];
-        client.connect(`ws://foo:1234`);
-        client.websocket.addEventListener = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        client.websocket.close = jest.fn();
-        await server.connected;
-        expect(client.websocket).toBeDefined();
-        expect(client.messagesOnOpen).toEqual(["GET foo"]);
-        client.close();
-        expect(client.messagesOnOpen).toEqual([]);
-        expect(client.websocket).toBeNull();
-      });
-    });
-    describe("#connect", () => {
-      test("create a new WebSocket.", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        client.send("hello");
-        await expect(server).toReceiveMessage("hello");
-        expect(server).toHaveReceivedMessages(["hello"]);
-      });
-      test("close previous connection.", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        expect(client.websocket).toBeDefined();
-        const old = client.websocket;
-        expect(old.readyState).toBe(WebSocket.OPEN);
-        client.connect(`ws://foo:12345`);
-        expect(old.readyState).toBe(WebSocket.CLOSING);
-        expect(client.websocket.readyState).toBe(WebSocket.CONNECTING);
-      });
-      test("call onOpen function", async () => {
-        const onOpen = jest.fn();
-        const client = new WebSocketAPI();
-        client.subscribe = jest.fn();
-        client.connect(`ws://foo:1234`, onOpen);
-        await server.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(onOpen).toHaveBeenCalledTimes(1);
-      });
-      test("subscribe previous subscriptions on open (quiet or not)", async () => {
-        const client = new WebSocketAPI();
-        client.subscribe = jest.fn();
-        client.send = jest.fn();
-        const subsc = {
-          params: "foo",
-          cb: () => {
-          },
-          errorCb: () => {
-          },
-          quiet: true
-        };
-        const subsc2 = {
-          params: "foo",
-          cb: () => {
-          },
-          errorCb: () => {
-          },
-          quiet: false
-        };
-        client.subscriptions = [subsc, subsc2];
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.subscribe).toHaveBeenCalledTimes(2);
-        client.subscribe.mockReset();
-        client.connect(`ws://foo:12345`);
-        await server2.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.subscribe).toHaveBeenCalledTimes(2);
-        expect(client.subscribe).toHaveBeenCalledWith(subsc.params, subsc.cb, subsc.errorCb, subsc.quiet);
-      });
-      test("send GET and SUB for not quiet previous subscriptions", async () => {
-        const client = new WebSocketAPI();
-        client.send = jest.fn();
-        const subsc = {
-          params: { channel: "foo" },
-          cb: () => {
-          },
-          errorCb: () => {
-          },
-          quiet: false
-        };
-        client.subscriptions = [subsc];
-        client.connect(`ws://foo:1234`);
-        client.websocket.addEventListener = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        await server.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.send).toHaveBeenCalledTimes(2);
-        expect(client.send.mock.calls[0]).toEqual(["GET foo"]);
-        expect(client.send.mock.calls[1]).toEqual(["SUB foo"]);
-        client.send.mockReset();
-        client.connect(`ws://foo:12345`);
-        client.websocket.addEventListener = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        await server2.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.send).toHaveBeenCalledTimes(2);
-        expect(client.send.mock.calls[0]).toEqual(["GET foo"]);
-        expect(client.send.mock.calls[1]).toEqual(["SUB foo"]);
-      });
-      test("doesn	 send GET and SUB for quiet previous subscriptions", async () => {
-        const client = new WebSocketAPI();
-        client.send = jest.fn();
-        const subsc = {
-          params: { channel: "foo" },
-          cb: () => {
-          },
-          errorCb: () => {
-          },
-          quiet: true
-        };
-        client.subscriptions = [subsc];
-        client.connect(`ws://foo:1234`);
-        client.websocket.addEventListener = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        await server.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.send).toHaveBeenCalledTimes(0);
-        client.send.mockReset();
-        client.connect(`ws://foo:12345`);
-        client.websocket.addEventListener = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        await server2.connected;
-        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.send).toHaveBeenCalledTimes(0);
-      });
-    });
-    describe("#subscribe", () => {
-      test("adds subscription to subscriptions array", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        const params = { channel: "bar", args: ["baz"], id: "id" };
-        const cb = jest.fn();
-        const errorCb = jest.fn();
-        client.subscribe(params, cb, errorCb);
-        expect(client.subscriptions.length).toBe(1);
-        expect(client.subscriptions[0].params).toBe(params);
-        expect(client.subscriptions[0].cb).toBe(cb);
-        expect(client.subscriptions[0].errorCb).toBe(errorCb);
-        expect(client.subscriptions[0].quiet).toBe(false);
-        const obj = { source: "bar baz", client_reference: "id" };
-        server.send(JSON.stringify(obj));
-        expect(cb).toHaveBeenCalledTimes(1);
-        expect(cb).toHaveBeenCalledWith(obj);
-      });
-      test("doesn't duplicate subscriptions", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        const params = { channel: "bar", args: ["baz"], id: "id" };
-        const cb = jest.fn();
-        const errorCb = jest.fn();
-        client.subscribe(params, cb, errorCb, true);
-        client.subscribe(params, cb, errorCb, true);
-        expect(client.subscriptions.length).toBe(1);
-        const obj = { source: "bar baz", client_reference: "id" };
-        server.send(JSON.stringify(obj));
-        expect(cb).toHaveBeenCalledTimes(1);
-        expect(cb).toHaveBeenCalledWith(obj);
-      });
-      test("send GET and SUB requests.", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        client.send = jest.fn();
-        const params = { channel: "bar", args: ["baz"], id: "id" };
-        const cb = jest.fn();
-        const errorCb = jest.fn();
-        client.subscribe(params, cb, errorCb);
-        expect(client.send).toHaveBeenCalledTimes(2);
-        expect(client.send).toHaveBeenCalledWith("GET bar baz id");
-        expect(client.send).toHaveBeenCalledWith("SUB bar baz id");
-        client.send.mockRestore();
-      });
-      test("should register callback without sending GET and SUB requests (quiet=true).", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        const params = { channel: "bar", args: ["baz"], id: "id" };
-        const cb = jest.fn();
-        const errorCb = jest.fn();
-        client.send = jest.fn();
-        client.subscribe(params, cb, errorCb, true);
-        expect(client.subscriptions.length).toBe(1);
-        expect(client.subscriptions[0].params).toBe(params);
-        expect(client.subscriptions[0].cb).toBe(cb);
-        expect(client.subscriptions[0].errorCb).toBe(errorCb);
-        expect(client.subscriptions[0].quiet).toBe(true);
-        expect(client.send).toBeCalledTimes(0);
-        client.send.mockRestore();
-      });
-    });
-    describe("#unsubscribe", () => {
-      test("should only unsubscribe the subscription using the good cb", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        const params = { channel: "foo", id: "id" };
-        const cb = jest.fn();
-        const cb2 = jest.fn();
-        client.subscribe(params, cb);
-        client.subscribe(params, cb2);
-        expect(client.subscriptions.length).toBe(2);
-        expect(client.subscriptions[0].params).toBe(params);
-        expect(client.subscriptions[0].cb).toBe(cb);
-        expect(client.subscriptions[1].params).toBe(params);
-        expect(client.subscriptions[1].cb).toBe(cb2);
-        client.unsubscribe("foo", cb);
-        expect(client.subscriptions.length).toBe(1);
-        expect(cb).toHaveBeenCalledTimes(0);
-        expect(cb2).toHaveBeenCalledTimes(0);
-        const obj = { source: "foo", client_reference: "id" };
-        server.send(JSON.stringify(obj));
-        expect(cb2).toHaveBeenCalledTimes(1);
-        expect(cb).toHaveBeenCalledTimes(0);
-      });
-      test("should unsubscribe all subscriptions related to a channel", () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        client.websocket.removeEventListener = jest.fn();
-        client.websocket.addEventListener = jest.fn();
-        const params = { channel: "foo" };
-        const params2 = { channel: "bar" };
-        const cb = jest.fn();
-        const cb2 = jest.fn();
-        client.subscribe(params, cb);
-        client.subscribe(params, cb);
-        client.subscribe(params, cb);
-        client.subscribe(params, cb2);
-        client.subscribe(params2, cb2);
-        expect(client.subscriptions.length).toBe(3);
-        expect(client.websocket.removeEventListener).toBeCalledTimes(2);
-        expect(client.websocket.addEventListener.mock.calls.filter((c) => c[0] === "message").length).toBe(5);
-        client.unsubscribe("foo");
-        expect(client.subscriptions.length).toBe(1);
-        expect(client.subscriptions[0].params).toBe(params2);
-        expect(client.subscriptions[0].cb).toBe(cb2);
-      });
-      test("send DEL when there is no more unquiet subscriptions on the channel", async () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        await server.connected;
-        client.send = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        client.websocket.addEventListener = jest.fn();
-        const params = { channel: "foo" };
-        const cb = jest.fn();
-        client.subscribe(params, cb);
-        expect(client.send).toHaveBeenCalledWith("GET foo");
-        expect(client.send).toHaveBeenCalledWith("SUB foo");
-        client.unsubscribe("foo");
-        expect(client.send).toHaveBeenCalledWith("DEL foo");
-      });
-      test("doesn't send DEL when we unsubscribe a quiet channel", () => {
-        const client = new WebSocketAPI();
-        client.connect(`ws://foo:1234`);
-        client.send = jest.fn();
-        client.websocket.removeEventListener = jest.fn();
-        client.websocket.addEventListener = jest.fn();
-        const params = { channel: "foo" };
-        const cb = jest.fn();
-        client.subscribe(params, cb, null, true);
-        expect(cb).toHaveBeenCalledTimes(0);
-        client.unsubscribe("foo");
-        expect(cb).toHaveBeenCalledTimes(0);
-        client.send.mockRestore();
-      });
-    });
-  });
-});

package/common/controls/Control.js

@@ -1,81 +0,0 @@
-import BaseObject from "ol/Object";
-class Control extends BaseObject {
-  constructor(options = {}) {
-    super(options);
-    this.defineProperties(options);
-    const { active } = {
-      active: options.active !== false,
-      ...options
-    };
-    this.active = active;
-  }
-  defineProperties(options) {
-    const { target, element, render } = {
-      ...options
-    };
-    Object.defineProperties(this, {
-      active: {
-        get: () => this.get("active"),
-        set: (newActive) => {
-          this.set("active", newActive);
-          if (newActive) {
-            this.activate();
-          } else {
-            this.deactivate();
-          }
-          this.render();
-        }
-      },
-      map: {
-        get: () => this.get("map"),
-        set: (map) => {
-          if (this.map && this.element && this.element.parentNode) {
-            this.element.parentNode.removeChild(this.element);
-          }
-          this.deactivate();
-          this.set("map", map);
-          if (this.map) {
-            const targett = this.target || this.map.getTargetElement && this.map.getTargetElement() || this.map.getContainer && this.map.getContainer();
-            if (!this.element) {
-              this.createDefaultElement();
-            }
-            if (this.element) {
-              targett.appendChild(this.element);
-            }
-            if (this.active) {
-              this.activate();
-            }
-          }
-          this.render();
-        }
-      },
-      target: {
-        value: target
-      },
-      element: {
-        value: element,
-        writable: true
-      },
-      render: {
-        value: render || this.render,
-        writable: true
-      }
-    });
-  }
-  attachToMap(map) {
-    this.map = map;
-  }
-  detachFromMap() {
-    this.map = null;
-  }
-  activate() {
-    this.deactivate();
-  }
-  deactivate() {
-  }
-  render() {
-  }
-  createDefaultElement() {
-  }
-}
-export default Control;

package/common/controls/Control.test.js

@@ -1,87 +0,0 @@
-import Control from "./Control";
-describe("Control", () => {
-  test("should be activated by default", () => {
-    const control = new Control();
-    expect(control.active).toBe(true);
-  });
-  test("should not be activated if set to false in the options", () => {
-    const control = new Control({ active: false });
-    expect(control.active).toBe(false);
-  });
-  test("should call activate/deactivate when active is set to true/false", () => {
-    const control = new Control();
-    const spy1 = jest.spyOn(control, "activate");
-    const spy2 = jest.spyOn(control, "deactivate");
-    const spy3 = jest.spyOn(control, "render");
-    control.active = false;
-    expect(spy1).toBeCalledTimes(0);
-    expect(spy2).toBeCalledTimes(1);
-    expect(spy3).toBeCalledTimes(1);
-    control.active = true;
-    expect(spy1).toBeCalledTimes(1);
-    expect(spy2).toBeCalledTimes(2);
-    expect(spy3).toBeCalledTimes(2);
-  });
-  test("should append/remove the element to the map container when map is set", () => {
-    const element = document.createElement("div");
-    const target = document.createElement("div");
-    const control = new Control({
-      element
-    });
-    const spy1 = jest.spyOn(control, "activate");
-    const spy2 = jest.spyOn(control, "deactivate");
-    const spy3 = jest.spyOn(control, "render");
-    control.map = {
-      getContainer() {
-        return target;
-      }
-    };
-    expect(target.childNodes[0]).toBe(element);
-    expect(spy1).toBeCalledTimes(1);
-    expect(spy2).toBeCalledTimes(2);
-    expect(spy3).toBeCalledTimes(1);
-    control.detachFromMap();
-    expect(target.childNodes[0]).toBe();
-    expect(spy1).toBeCalledTimes(1);
-    expect(spy2).toBeCalledTimes(3);
-    expect(spy3).toBeCalledTimes(2);
-  });
-  test("should append/remove the element to the target property when map is set", () => {
-    const element = document.createElement("div");
-    const target = document.createElement("div");
-    const control = new Control({
-      target,
-      element
-    });
-    const spy1 = jest.spyOn(control, "activate");
-    const spy2 = jest.spyOn(control, "deactivate");
-    const spy3 = jest.spyOn(control, "render");
-    control.map = {};
-    expect(target.childNodes[0]).toBe(element);
-    expect(spy1).toBeCalledTimes(1);
-    expect(spy2).toBeCalledTimes(2);
-    expect(spy3).toBeCalledTimes(1);
-    control.detachFromMap();
-    expect(target.childNodes[0]).toBe();
-    expect(spy1).toBeCalledTimes(1);
-    expect(spy2).toBeCalledTimes(3);
-    expect(spy3).toBeCalledTimes(2);
-  });
-  test("set a custom render method", () => {
-    const spy = jest.fn();
-    const control = new Control({
-      render: spy
-    });
-    expect(spy).toBeCalledTimes(1);
-  });
-  test("pass function params to custom render method", () => {
-    const spy = jest.fn();
-    const control = new Control({
-      render: spy
-    });
-    control.render("foo", "bar");
-    expect(spy).toBeCalledTimes(2);
-    expect(spy.mock.calls[1][0]).toBe("foo");
-    expect(spy.mock.calls[1][1]).toBe("bar");
-  });
-});