mobility-toolbox-js 2.0.0-beta.8 → 2.0.1-beta.13

package/{src/api/tralis/WebSocketConnector.test.js → common/api/WebSocketAPI.test.js}

@@ -1,25 +1,21 @@
-import WS from 'jest-websocket-mock';
-import Connector from './WebSocketConnector';
-
-describe('WebSocketConnector', () => {
-  describe('#constructor', () => {
+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', () => {
+    describe("#constructor", () => {
       test("doesn't connect.", async () => {
-        const client = new Connector();
+        const client = new WebSocketAPI();
         expect(client.websocket).toBe();
         expect(client.closed).toBe(false);
         expect(client.closing).toBe(false);
@@ -27,44 +23,42 @@ describe('WebSocketConnector', () => {
         expect(client.open).toBe(false);
       });
     });
-
-    describe('#close', () => {
-      test('should close the websocket and clear some property', async () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+    describe("#close", () => {
+      test("should close the websocket and clear some property", async () => {
+        const client = new WebSocketAPI();
         const subsc2 = {
-          params: 'foo',
-          cb: () => {},
-          errorCb: () => {},
-          quiet: false,
+          params: "foo",
+          cb: () => {
+          },
+          errorCb: () => {
+          },
+          quiet: false
         };
         client.subscriptions = [subsc2];
-        client.messagesOnOpen = ['GET foo'];
+        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']);
+        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 Connector();
+    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']);
+        client.send("hello");
+        await expect(server).toReceiveMessage("hello");
+        expect(server).toHaveReceivedMessages(["hello"]);
       });
-
-      test('close previous connection.', async () => {
-        const client = new Connector();
+      test("close previous connection.", async () => {
+        const client = new WebSocketAPI();
         client.connect(`ws://foo:1234`);
         await server.connected;
         expect(client.websocket).toBeDefined();
@@ -74,96 +68,89 @@ describe('WebSocketConnector', () => {
         expect(old.readyState).toBe(WebSocket.CLOSING);
         expect(client.websocket.readyState).toBe(WebSocket.CONNECTING);
       });
-
-      test('call onOpen function', async () => {
+      test("call onOpen function", async () => {
         const onOpen = jest.fn();
-        const client = new Connector();
+        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 Connector();
+      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,
+          params: "foo",
+          cb: () => {
+          },
+          errorCb: () => {
+          },
+          quiet: true
         };
         const subsc2 = {
-          params: 'foo',
-          cb: () => {},
-          errorCb: () => {},
-          quiet: false,
+          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,
-        );
+        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 Connector();
+      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,
+          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']);
+        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);
-        // not quiet subscriptions will send GET and SUB requests.
         expect(client.send).toHaveBeenCalledTimes(2);
-        expect(client.send.mock.calls[0]).toEqual(['GET foo']);
-        expect(client.send.mock.calls[1]).toEqual(['SUB foo']);
+        expect(client.send.mock.calls[0]).toEqual(["GET foo"]);
+        expect(client.send.mock.calls[1]).toEqual(["SUB foo"]);
       });
-
-      test('doesn\t send GET and SUB for quiet previous subscriptions', async () => {
-        const client = new Connector();
+      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,
+          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();
@@ -171,24 +158,20 @@ describe('WebSocketConnector', () => {
         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);
-        // not quiet subscriptions will send GET and SUB requests.
         expect(client.send).toHaveBeenCalledTimes(0);
       });
     });
-
-    describe('#subscribe', () => {
-      test('adds subscription to subscriptions array', async () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+    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 params = { channel: "bar", args: ["baz"], id: "id" };
         const cb = jest.fn();
         const errorCb = jest.fn();
         client.subscribe(params, cb, errorCb);
@@ -197,54 +180,44 @@ describe('WebSocketConnector', () => {
         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' };
+        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 () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+        const client = new WebSocketAPI();
         client.connect(`ws://foo:1234`);
         await server.connected;
-        const params = { channel: 'bar', args: ['baz'], id: 'id' };
+        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' };
+        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 () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+      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 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');
+        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 () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+      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 params = { channel: "bar", args: ["baz"], id: "id" };
         const cb = jest.fn();
         const errorCb = jest.fn();
         client.send = jest.fn();
@@ -258,14 +231,12 @@ describe('WebSocketConnector', () => {
         client.send.mockRestore();
       });
     });
-
-    describe('#unsubscribe', () => {
-      test('should only unsubscribe the subscription using the good cb', async () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+    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 params = { channel: "foo", id: "id" };
         const cb = jest.fn();
         const cb2 = jest.fn();
         client.subscribe(params, cb);
@@ -275,27 +246,22 @@ describe('WebSocketConnector', () => {
         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);
+        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' };
+        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', () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+      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 params = { channel: "foo" };
+        const params2 = { channel: "bar" };
         const cb = jest.fn();
         const cb2 = jest.fn();
         client.subscribe(params, cb);
@@ -305,49 +271,38 @@ describe('WebSocketConnector', () => {
         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.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 () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+      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 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');
+        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", () => {
-        // eslint-disable-next-line no-unused-vars
-        const client = new Connector();
+        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 params = { channel: "foo" };
         const cb = jest.fn();
         client.subscribe(params, cb, null, true);
         expect(cb).toHaveBeenCalledTimes(0);
-
-        client.unsubscribe('foo');
+        client.unsubscribe("foo");
         expect(cb).toHaveBeenCalledTimes(0);
         client.send.mockRestore();
       });

package/common/controls/Control.js

@@ -0,0 +1,81 @@
+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/{src/common → common}/controls/Control.test.js

@@ -1,21 +1,18 @@
-import Control from './Control';
-
-describe('Control', () => {
-  test('should be activated by default', () => {
+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', () => {
+  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', () => {
+  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');
+    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);
@@ -25,74 +22,66 @@ describe('Control', () => {
     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');
+  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,
+      element
     });
-    const spy1 = jest.spyOn(control, 'activate');
-    const spy2 = jest.spyOn(control, 'deactivate');
-    const spy3 = jest.spyOn(control, 'render');
+    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.map = null;
+    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');
+  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,
+      element
     });
-    const spy1 = jest.spyOn(control, 'activate');
-    const spy2 = jest.spyOn(control, 'deactivate');
-    const spy3 = jest.spyOn(control, 'render');
+    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.map = null;
+    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', () => {
+  test("set a custom render method", () => {
     const spy = jest.fn();
-    // eslint-disable-next-line no-unused-vars
     const control = new Control({
-      render: spy,
+      render: spy
     });
     expect(spy).toBeCalledTimes(1);
   });
-
-  test('pass function params to custom render method', () => {
+  test("pass function params to custom render method", () => {
     const spy = jest.fn();
-    // eslint-disable-next-line no-unused-vars
     const control = new Control({
-      render: spy,
+      render: spy
     });
-    control.render('foo', 'bar');
+    control.render("foo", "bar");
     expect(spy).toBeCalledTimes(2);
-    expect(spy.mock.calls[1][0]).toBe('foo');
-    expect(spy.mock.calls[1][1]).toBe('bar');
+    expect(spy.mock.calls[1][0]).toBe("foo");
+    expect(spy.mock.calls[1][1]).toBe("bar");
   });
 });

package/common/index.js

@@ -0,0 +1,4 @@
+export { default as Tracker } from "./Tracker";
+export * as trackerConfig from "./trackerConfig";
+export * from "./utils";
+export * from "./styles";