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

package/common/api/WebSocketAPI.js

@@ -1,175 +0,0 @@
-class WebSocketAPI {
-  constructor() {
-    this.defineProperties();
-  }
-  defineProperties() {
-    Object.defineProperties(this, {
-      closed: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CLOSED)
-      },
-      closing: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CLOSING)
-      },
-      connecting: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CONNECTING)
-      },
-      open: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.OPEN)
-      },
-      messagesOnOpen: {
-        value: [],
-        writable: true
-      },
-      subscriptions: {
-        value: [],
-        writable: true
-      },
-      subscribed: {
-        value: {},
-        writable: true
-      }
-    });
-  }
-  static getRequestString(method, params) {
-    let reqStr = `${method} ${params.channel}`;
-    reqStr += params.args ? ` ${params.args}` : "";
-    reqStr += params.id ? ` ${params.id}` : "";
-    return reqStr.trim();
-  }
-  connect(url, onOpen = () => {
-  }) {
-    if (this.websocket && !this.closed) {
-      this.websocket.close();
-    }
-    this.websocket = new WebSocket(url);
-    if (!this.open) {
-      this.websocket.addEventListener("open", () => {
-        onOpen();
-        this.subscribePreviousSubscriptions();
-      });
-    } else {
-      onOpen();
-      this.subscribePreviousSubscriptions();
-    }
-  }
-  close() {
-    if (this.websocket) {
-      this.websocket.onclose = null;
-      this.websocket.close();
-      this.websocket = null;
-      this.messagesOnOpen = [];
-    }
-  }
-  send(message) {
-    if (!this.websocket) {
-      return;
-    }
-    const send = () => {
-      this.websocket.send(message);
-    };
-    if (!this.open) {
-      if (!this.messagesOnOpen.includes(message)) {
-        this.messagesOnOpen.push(message);
-        this.websocket.addEventListener("open", () => {
-          this.messagesOnOpen = [];
-          send();
-        });
-        this.websocket.addEventListener("close", () => {
-          this.messagesOnOpen = [];
-        });
-      }
-    } else if (!this.messagesOnOpen.includes(message)) {
-      send();
-    }
-  }
-  listen(params, cb, errorCb) {
-    this.unlisten(params, cb);
-    const onMessage = (evt) => {
-      let data = {};
-      try {
-        data = JSON.parse(evt.data);
-      } catch (err) {
-        console.error("WebSocket: unable to parse JSON data", err, evt.data);
-      }
-      let source = params.channel;
-      source += params.args ? ` ${params.args}` : "";
-      const contents = data.source === "buffer" ? data.content : [data];
-      contents.forEach((content) => {
-        if (content?.source === source && (!params.id || params.id === data.client_reference)) {
-          cb(content);
-        }
-      });
-    };
-    if (this.websocket) {
-      this.websocket.addEventListener("message", onMessage);
-      if (errorCb) {
-        this.websocket.addEventListener("error", errorCb);
-        this.websocket.addEventListener("close", errorCb);
-      }
-    }
-    return { onMessageCb: onMessage, onErrorCb: errorCb };
-  }
-  unlisten(params, cb) {
-    if (!this.websocket) {
-      return;
-    }
-    this.subscriptions.filter((s) => s.params.channel === params.channel && (!cb || s.cb === cb)).forEach(({ onMessageCb, onErrorCb }) => {
-      if (this.websocket) {
-        this.websocket.removeEventListener("message", onMessageCb);
-        if (onErrorCb) {
-          this.websocket.removeEventListener("error", onErrorCb);
-          this.websocket.removeEventListener("close", onErrorCb);
-        }
-      }
-    });
-  }
-  get(params, cb, errorCb) {
-    const reqStr = WebSocketAPI.getRequestString("GET", params);
-    this.send(reqStr);
-    this.listen(params, cb, errorCb);
-  }
-  subscribe(params, cb, errorCb, quiet = false) {
-    const { onMessageCb, onErrorCb } = this.listen(params, cb, errorCb);
-    const reqStr = WebSocketAPI.getRequestString("", params);
-    const index = this.subscriptions.findIndex((subcr) => params.channel === subcr.params.channel && cb === subcr.cb);
-    const newSubscr = { params, cb, errorCb, onMessageCb, onErrorCb, quiet };
-    if (index > -1) {
-      this.subscriptions[index] = newSubscr;
-    } else {
-      this.subscriptions.push(newSubscr);
-    }
-    if (!this.subscribed[reqStr]) {
-      if (!newSubscr.quiet) {
-        this.send(`GET ${reqStr}`);
-        this.send(`SUB ${reqStr}`);
-      }
-      this.subscribed[reqStr] = true;
-    }
-  }
-  unsubscribe(source, cb) {
-    const toRemove = this.subscriptions.filter((s) => s.params.channel === source && (!cb || s.cb === cb));
-    toRemove.forEach(({ onMessageCb, onErrorCb }) => {
-      if (this.websocket) {
-        this.websocket.removeEventListener("message", onMessageCb);
-        if (onErrorCb) {
-          this.websocket.removeEventListener("error", onErrorCb);
-          this.websocket.removeEventListener("close", onErrorCb);
-        }
-      }
-    });
-    this.subscriptions = this.subscriptions.filter((s) => s.params.channel !== source || cb && s.cb !== cb);
-    if (source && this.subscribed[source] && !this.subscriptions.find((s) => s.params.channel === source) && toRemove.find((subscr) => !subscr.quiet)) {
-      this.send(`DEL ${source}`);
-      this.subscribed[source] = false;
-    }
-  }
-  subscribePreviousSubscriptions() {
-    Object.keys(this.subscribed).forEach((key) => {
-      this.subscribed[key] = false;
-    });
-    [...this.subscriptions].forEach((s) => {
-      this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
-    });
-  }
-}
-export default WebSocketAPI;

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");
-  });
-});