mobility-toolbox-js 2.0.0-beta.34 → 2.0.0-beta.37

package/common/api/WebSocketAPI.test.js

@@ -0,0 +1,380 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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.", () => __awaiter(void 0, void 0, void 0, function* () {
+                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', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                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();
+                yield 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.', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                client.send('hello');
+                yield expect(server).toReceiveMessage('hello');
+                expect(server).toHaveReceivedMessages(['hello']);
+            }));
+            test('close previous connection.', () => __awaiter(void 0, void 0, void 0, function* () {
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+                const onOpen = jest.fn();
+                const client = new WebSocketAPI();
+                client.subscribe = jest.fn();
+                client.connect(`ws://foo:1234`, onOpen);
+                yield server.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(onOpen).toHaveBeenCalledTimes(1);
+            }));
+            test('subscribe previous subscriptions on open (quiet or not)', () => __awaiter(void 0, void 0, void 0, function* () {
+                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`);
+                yield server.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                expect(client.subscribe).toHaveBeenCalledTimes(2);
+                client.subscribe.mockReset();
+                client.connect(`ws://foo:12345`);
+                yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+                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();
+                yield 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();
+                yield 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']);
+            }));
+            test('doesn\t send GET and SUB for quiet previous subscriptions', () => __awaiter(void 0, void 0, void 0, function* () {
+                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();
+                yield 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();
+                yield server2.connected;
+                expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+                // not quiet subscriptions will send GET and SUB requests.
+                expect(client.send).toHaveBeenCalledTimes(0);
+            }));
+        });
+        describe('#get', () => {
+            test('listen to message event', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'get', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.get(params, cb, errorCb);
+                expect(cb).toHaveBeenCalledTimes(0);
+                const obj = { source: 'get baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb).toHaveBeenCalledWith(obj);
+            }));
+            test('unlisten after receiving one response', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'get', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.get(params, cb, errorCb);
+                expect(cb).toHaveBeenCalledTimes(0);
+                const obj = { source: 'get baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                server.send(JSON.stringify(obj));
+                server.send(JSON.stringify(obj));
+                server.send(JSON.stringify(obj));
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+            }));
+            test('call (then remove) good callbacks on multiple requests', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield server.connected;
+                const params = { channel: 'get', args: ['baz'], id: 'id' };
+                const cb = jest.fn();
+                const errorCb = jest.fn();
+                client.get(params, cb, errorCb);
+                const params2 = { channel: 'get', args: ['foo'], id: 'id' };
+                const cb2 = jest.fn();
+                const errorCb2 = jest.fn();
+                client.get(params2, cb2, errorCb2);
+                client.get(params, cb2, errorCb);
+                expect(cb).toHaveBeenCalledTimes(0);
+                const obj = { source: 'get baz', client_reference: 'id' };
+                server.send(JSON.stringify(obj));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb2).toHaveBeenCalledTimes(1);
+                server.send(JSON.stringify({ source: 'get foo', client_reference: 'id' }));
+                expect(cb).toHaveBeenCalledTimes(1);
+                expect(cb2).toHaveBeenCalledTimes(2);
+            }));
+        });
+        describe('#subscribe', () => {
+            test('adds subscription to subscriptions array', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield 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", () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield 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.', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                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).', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield 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', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield 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', () => {
+                // eslint-disable-next-line no-unused-vars
+                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', () => __awaiter(void 0, void 0, void 0, function* () {
+                // eslint-disable-next-line no-unused-vars
+                const client = new WebSocketAPI();
+                client.connect(`ws://foo:1234`);
+                yield 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", () => {
+                // eslint-disable-next-line no-unused-vars
+                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.d.ts

@@ -21,11 +21,11 @@ declare class Control extends BaseObject {
      * @param {function} [options.render] Render function called whenever the control needs to be rerendered.
      */
     constructor(options?: {
-        active?: boolean;
-        element?: HTMLElement;
-        target?: HTMLElement;
-        render?: Function;
-    });
+        active?: boolean | undefined;
+        element?: HTMLElement | undefined;
+        target?: HTMLElement | undefined;
+        render?: Function | undefined;
+    } | undefined);
     /**
      * @ignore
      */

package/common/controls/Control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Control.d.ts","sourceRoot":"","sources":["../../../src/common/controls/Control.js"],"names":[],"mappings":";AAEA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;OAQG;IACH;QAL6B,MAAM,GAAxB,OAAO;QACe,OAAO,GAA7B,WAAW;QACW,MAAM,GAA5B,WAAW;QACQ,MAAM;OAenC;IAJC;;OAEG;IACH,gBAAoB;IAGtB;;;;OAIG;IACH,yBAmEC;IAED;;OAEG;IACH,4BAEC;IADC,SAAc;IAGhB;;OAEG;IACH,sBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IAEH,mBAAe;IAEf;;;;;OAKG;IACH,eAAW;IAEX;;;;;OAKG;IAEH,6BAAyB;CAC1B"}
+{"version":3,"file":"Control.d.ts","sourceRoot":"","sources":["../../../src/common/controls/Control.js"],"names":[],"mappings":";AAEA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;OAQG;IACH;;;;;mBAaC;IAJC;;OAEG;IACH,gBAAoB;IAGtB;;;;OAIG;IACH,yBAmEC;IAED;;OAEG;IACH,4BAEC;IADC,SAAc;IAGhB;;OAEG;IACH,sBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IAEH,mBAAe;IAEf;;;;;OAKG;IACH,eAAW;IAEX;;;;;OAKG;IAEH,6BAAyB;CAC1B"}

package/common/controls/Control.js

@@ -1,32 +1,4 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var Object_1 = require("ol/Object");
+import BaseObject from 'ol/Object';
 /**
  * A class representing a control to display on map.
  *
@@ -38,8 +10,7 @@ var Object_1 = require("ol/Object");
  * @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.
  */
-var Control = /** @class */ (function (_super) {
-    __extends(Control, _super);
+class Control extends BaseObject {
     /**
      * Constructor
      *
@@ -49,66 +20,63 @@ var Control = /** @class */ (function (_super) {
      * @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.
      */
-    function Control(options) {
-        if (options === void 0) { options = {}; }
-        var _this = _super.call(this, options) || this;
-        _this.defineProperties(options);
-        var active = __assign({ active: options.active !== false }, options).active;
+    constructor(options = {}) {
+        super(options);
+        this.defineProperties(options);
+        const { active } = Object.assign({ active: options.active !== false }, options);
         /**
          * @ignore
          */
-        _this.active = active;
-        return _this;
+        this.active = active;
     }
     /**
      * Define control's properties.
      *
      * @private
      */
-    Control.prototype.defineProperties = function (options) {
-        var _this = this;
-        var _a = __assign({}, options), target = _a.target, element = _a.element, render = _a.render;
+    defineProperties(options) {
+        const { target, element, render } = Object.assign({}, options);
         Object.defineProperties(this, {
             active: {
-                get: function () { return _this.get('active'); },
-                set: function (newActive) {
-                    _this.set('active', newActive);
+                get: () => this.get('active'),
+                set: (newActive) => {
+                    this.set('active', newActive);
                     if (newActive) {
-                        _this.activate();
+                        this.activate();
                     }
                     else {
-                        _this.deactivate();
+                        this.deactivate();
                     }
-                    _this.render();
+                    this.render();
                 },
             },
             map: {
-                get: function () { return _this.get('map'); },
-                set: function (map) {
+                get: () => this.get('map'),
+                set: (map) => {
                     // Remove previous node.
-                    if (_this.map && _this.element && _this.element.parentNode) {
-                        _this.element.parentNode.removeChild(_this.element);
+                    if (this.map && this.element && this.element.parentNode) {
+                        this.element.parentNode.removeChild(this.element);
                     }
                     // Clean listeners
-                    _this.deactivate();
-                    _this.set('map', map);
-                    if (_this.map) {
+                    this.deactivate();
+                    this.set('map', map);
+                    if (this.map) {
                         // Add new node
-                        var targett = _this.target ||
-                            (_this.map.getTargetElement && _this.map.getTargetElement()) ||
-                            (_this.map.getContainer && _this.map.getContainer());
-                        if (!_this.element) {
-                            _this.createDefaultElement();
+                        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.element) {
+                            targett.appendChild(this.element);
                         }
                         // Add listeners
-                        if (_this.active) {
-                            _this.activate();
+                        if (this.active) {
+                            this.activate();
                         }
                     }
-                    _this.render();
+                    this.render();
                 },
             },
             target: {
@@ -124,39 +92,39 @@ var Control = /** @class */ (function (_super) {
                 writable: true,
             },
         });
-    };
+    }
     /**
      * Attach the control to the map. Add events, html element ...
      */
-    Control.prototype.attachToMap = function (map) {
+    attachToMap(map) {
         this.map = map;
-    };
+    }
     /**
      * Detach the control From the map. Remove events, html element ..
      */
-    Control.prototype.detachFromMap = function () {
+    detachFromMap() {
         this.map = null;
-    };
+    }
     /**
      * Add listeners then renders the control.
      * To be defined in inherited classes.
      */
-    Control.prototype.activate = function () {
+    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
-    Control.prototype.deactivate = function () { };
+    deactivate() { }
     /**
      * The default render function. It renders content in the HTML element.
      * To be defined in inherited classes.
      *
      * @private
      */
-    Control.prototype.render = function () { };
+    render() { }
     /**
      * The default element to display if this.element is not defined.
      * To be defined in inherited classes.
@@ -164,7 +132,6 @@ var Control = /** @class */ (function (_super) {
      * @private
      */
     // eslint-disable-next-line class-methods-use-this
-    Control.prototype.createDefaultElement = function () { };
-    return Control;
-}(Object_1.default));
-exports.default = Control;
+    createDefaultElement() { }
+}
+export default Control;

package/common/controls/Control.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Control.test.d.ts.map

package/common/controls/Control.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Control.test.d.ts","sourceRoot":"","sources":["../../../src/common/controls/Control.test.js"],"names":[],"mappings":""}