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

package/{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

@@ -1,146 +1,81 @@
-import BaseObject from 'ol/Object';
-
-/**
- * A class representing a control to display on map.
- *
- * @example
- * const control = new Control();
- *
- * @classproperty {ol/Map~Map|mapboxgl.Map} map - The map which the control refers to.
- * @classproperty {boolean} active - Active the control.
- * @classproperty {HTMLElement} element - The HTML element used to render the control.
- * @classproperty {HTMLElement} target - The HTML element where to render the element property. Default is the map's element. Read only.
- */
+import BaseObject from "ol/Object";
 class Control extends BaseObject {
-  /**
-   * Constructor
-   *
-   * @param {Object} [options] Control options.
-   * @param {boolean} [options.active = true] Whether the control is active or not.
-   * @param {HTMLElement} [options.element] The HTML element used to render the control.
-   * @param {HTMLElement} [options.target] The HTML element where to render the element property. Default is the map's element.
-   * @param {function} [options.render] Render function called whenever the control needs to be rerendered.
-   */
   constructor(options = {}) {
     super(options);
     this.defineProperties(options);
-
     const { active } = {
       active: options.active !== false,
-      ...options,
+      ...options
     };
-
-    /**
-     * @ignore
-     */
     this.active = active;
   }
-
-  /**
-   * Define control's properties.
-   *
-   * @private
-   */
   defineProperties(options) {
     const { target, element, render } = {
-      ...options,
+      ...options
     };
-
     Object.defineProperties(this, {
       active: {
-        get: () => this.get('active'),
+        get: () => this.get("active"),
         set: (newActive) => {
-          this.set('active', newActive);
+          this.set("active", newActive);
           if (newActive) {
             this.activate();
           } else {
             this.deactivate();
           }
           this.render();
-        },
+        }
       },
       map: {
-        get: () => this.get('map'),
+        get: () => this.get("map"),
         set: (map) => {
-          // Remove previous node.
           if (this.map && this.element && this.element.parentNode) {
             this.element.parentNode.removeChild(this.element);
           }
-
-          // Clean listeners
           this.deactivate();
-
-          this.set('map', map);
-
+          this.set("map", map);
           if (this.map) {
-            // Add new node
-            const targett =
-              this.target ||
-              (this.map.getTargetElement && this.map.getTargetElement()) ||
-              (this.map.getContainer && this.map.getContainer());
-
+            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);
             }
-
-            // Add listeners
             if (this.active) {
               this.activate();
             }
           }
           this.render();
-        },
+        }
       },
       target: {
-        value: target,
+        value: target
       },
       element: {
         value: element,
-        writable: true,
+        writable: true
       },
       render: {
-        /** @ignore */
         value: render || this.render,
-        writable: true,
-      },
+        writable: true
+      }
     });
   }
-
-  /**
-   * Add listeners then renders the control.
-   * To be defined in inherited classes.
-   */
+  attachToMap(map) {
+    this.map = map;
+  }
+  detachFromMap() {
+    this.map = null;
+  }
   activate() {
     this.deactivate();
   }
-
-  /**
-   * Remove listeners added by activate() function then renders the control.
-   * To be defined in inherited classes.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  deactivate() {}
-
-  /**
-   * The default render function. It renders content in the HTML element.
-   * To be defined in inherited classes.
-   *
-   * @private
-   */
-  render() {}
-
-  /**
-   * The default element to display if this.element is not defined.
-   * To be defined in inherited classes.
-   *
-   * @private
-   */
-  // eslint-disable-next-line class-methods-use-this
-  createDefaultElement() {}
+  deactivate() {
+  }
+  render() {
+  }
+  createDefaultElement() {
+  }
 }
-
 export default Control;