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

package/common/controls/Control.test.js

@@ -0,0 +1,89 @@
+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();
+        // eslint-disable-next-line no-unused-vars
+        const control = new Control({
+            render: spy,
+        });
+        expect(spy).toBeCalledTimes(1);
+    });
+    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,
+        });
+        control.render('foo', 'bar');
+        expect(spy).toBeCalledTimes(2);
+        expect(spy.mock.calls[1][0]).toBe('foo');
+        expect(spy.mock.calls[1][1]).toBe('bar');
+    });
+});

package/common/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./utils"), exports);
-__exportStar(require("./styles"), exports);
+export * from './utils';
+export * from './styles';

package/common/layers/Layer.d.ts

@@ -31,19 +31,19 @@ export default class Layer extends BaseObject {
      * @param {Object} [options.properties={}] Application-specific layer properties.
      */
     constructor(options?: {
-        key?: string;
-        name?: string;
-        copyrights?: string[];
-        children?: Array<Layer>;
-        visible?: boolean;
-        disabled?: boolean;
-        hitTolerance?: number;
-        properties?: any;
+        key?: string | undefined;
+        name?: string | undefined;
+        copyrights?: string[] | undefined;
+        children?: Layer[] | undefined;
+        visible?: boolean | undefined;
+        disabled?: boolean | undefined;
+        hitTolerance?: number | undefined;
+        properties?: Object | undefined;
     });
     visible: boolean;
     group: any;
-    copyrights: string[];
-    children: Layer[];
+    copyrights: string[] | undefined;
+    children: Layer[] | undefined;
     /**
      * Define layer's properties that needs custom get and set.
      *
@@ -70,7 +70,7 @@ export default class Layer extends BaseObject {
      * @param {Object} options Some options. See child classes to see which are supported.
      * @return {Promise<FeatureInfo>} An empty response.
      */
-    getFeatureInfoAtCoordinate(coordinate: any, options: any): Promise<FeatureInfo>;
+    getFeatureInfoAtCoordinate(coordinate: any, options: Object): Promise<FeatureInfo>;
     /**
      * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
      */

package/common/layers/Layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../../src/common/layers/Layer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;;;;;;;OAYG;IACH;QAT4B,GAAG,GAApB,MAAM;QACW,IAAI,GAArB,MAAM;QACa,UAAU,GAA7B,MAAM,EAAE;QACe,QAAQ,GAA/B,MAAM,KAAK,CAAC;QACM,OAAO,GAAzB,OAAO;QACW,QAAQ,GAA1B,OAAO;QACU,YAAY,GAA7B,MAAM;QACW,UAAU;OA+BrC;IAvBC,iBAAuE;IAEvE,WAA0B;IAE1B,qBAAoC;IAEpC,kBAAgC;IAmBlC;;;;OAIG;IACH,qCA0HC;IAED;;;;OAIG;IACH,4BAUC;IARC,cAAc;IACd,SAAc;IAShB;;OAEG;IAEH,sBAGC;IAED;;;;;;;OAOG;IAEH,2DAHY,QAAQ,WAAW,CAAC,CAiB/B;IAED;;OAEG;IACH,cAEC;CACF"}
+{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../../src/common/layers/Layer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;;;;;;;OAYG;IACH;QAT4B,GAAG;QACH,IAAI;QACF,UAAU;QACN,QAAQ;QACb,OAAO;QACP,QAAQ;QACT,YAAY;QACZ,UAAU;OA+BrC;IAvBC,iBAAuE;IAEvE,WAA0B;IAE1B,iCAAoC;IAEpC,8BAAgC;IAmBlC;;;;OAIG;IACH,qCA0HC;IAED;;;;OAIG;IACH,4BAUC;IARC,cAAc;IACd,SAAc;IAShB;;OAEG;IAEH,sBAGC;IAED;;;;;;;OAOG;IAEH,qDAJW,MAAM,GACL,QAAQ,WAAW,CAAC,CAiB/B;IAED;;OAEG;IACH,cAEC;CACF"}

package/common/layers/Layer.js

@@ -1,34 +1,6 @@
-"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");
-var uuid_1 = require("uuid");
-var getLayersAsFlatArray_1 = require("../utils/getLayersAsFlatArray");
+import BaseObject from 'ol/Object';
+import { v4 as uuid } from 'uuid';
+import getLayersAsFlatArray from '../utils/getLayersAsFlatArray';
 /**
  * A class representing a layer to display on map.
  *
@@ -47,8 +19,7 @@ var getLayersAsFlatArray_1 = require("../utils/getLayersAsFlatArray");
  * @classproperty {Object} properties - Custom properties.
  * @classproperty {ol/Map~Map|mapboxgl.Map} map - The map where the layer is displayed.
  */
-var Layer = /** @class */ (function (_super) {
-    __extends(Layer, _super);
+export default class Layer extends BaseObject {
     /**
      * Constructor
      *
@@ -62,40 +33,37 @@ var Layer = /** @class */ (function (_super) {
      * @param {number} [options.hitTolerance=5] Hit-detection tolerance in css pixels. Pixels inside the radius around the given position will be checked for features.
      * @param {Object} [options.properties={}] Application-specific layer properties.
      */
-    function Layer(options) {
-        if (options === void 0) { options = {}; }
-        var _this = _super.call(this) || this;
-        _this.defineProperties(options);
-        _this.setProperties(options.properties);
-        _this.visible = options.visible === undefined ? true : !!options.visible;
-        _this.group = options.group;
-        _this.copyrights = options.copyrights;
-        _this.children = options.children;
+    constructor(options = {}) {
+        super();
+        this.defineProperties(options);
+        this.setProperties(options.properties);
+        this.visible = options.visible === undefined ? true : !!options.visible;
+        this.group = options.group;
+        this.copyrights = options.copyrights;
+        this.children = options.children;
         // Listen for group visiblity change
         // if a layer from a group is newly visible we hide the others.
-        _this.on("change:visible:group", function (evt) {
+        this.on(`change:visible:group`, (evt) => {
             // We hide layer of the same group
-            if (_this.group === evt.target.group &&
-                _this !== evt.target &&
-                _this.visible) {
-                _this.visible = false;
+            if (this.group === evt.target.group &&
+                this !== evt.target &&
+                this.visible) {
+                this.visible = false;
                 // Propagate event to parent
             }
-            else if (_this.children) {
-                _this.children.forEach(function (child) { return child.dispatchEvent(evt); });
+            else if (this.children) {
+                this.children.forEach((child) => child.dispatchEvent(evt));
             }
         });
-        return _this;
     }
     /**
      * Define layer's properties that needs custom get and set.
      *
      * @ignore
      */
-    Layer.prototype.defineProperties = function (options) {
-        var _this = this;
-        var _a = __assign({}, options), name = _a.name, key = _a.key, properties = _a.properties, hitTolerance = _a.hitTolerance;
-        var uid = (0, uuid_1.v4)();
+    defineProperties(options) {
+        const { name, key, properties, hitTolerance } = Object.assign({}, options);
+        const uid = uuid();
         Object.defineProperties(this, {
             /* Layer's information properties */
             name: {
@@ -105,18 +73,18 @@ var Layer = /** @class */ (function (_super) {
                 value: key || uid,
             },
             group: {
-                get: function () { return _this.get('group'); },
-                set: function (newGroup) {
-                    _this.set('group', newGroup);
+                get: () => this.get('group'),
+                set: (newGroup) => {
+                    this.set('group', newGroup);
                 },
             },
             copyrights: {
-                get: function () { return _this.get('copyrights'); },
-                set: function (newCopyrights) {
-                    var arrValue = newCopyrights && !Array.isArray(newCopyrights)
+                get: () => this.get('copyrights'),
+                set: (newCopyrights) => {
+                    const arrValue = newCopyrights && !Array.isArray(newCopyrights)
                         ? [newCopyrights]
                         : newCopyrights;
-                    _this.set('copyrights', arrValue || []);
+                    this.set('copyrights', arrValue || []);
                 },
             },
             // options is used for clone function.
@@ -128,47 +96,47 @@ var Layer = /** @class */ (function (_super) {
             },
             /* Layer's state properties */
             visible: {
-                get: function () { return _this.get('visible'); },
-                set: function (newVisible) {
-                    if (newVisible === _this.visible) {
+                get: () => this.get('visible'),
+                set: (newVisible) => {
+                    if (newVisible === this.visible) {
                         return;
                     }
-                    _this.set('visible', newVisible);
-                    if (_this.visible) {
-                        if (_this.parent && !_this.parent.visible) {
-                            _this.parent.visible = true;
+                    this.set('visible', newVisible);
+                    if (this.visible) {
+                        if (this.parent && !this.parent.visible) {
+                            this.parent.visible = true;
                         }
-                        if (_this.children && _this.children.find(function (child) { return child.group; })) {
-                            var child = _this.children.find(function (childd) { return !!childd.group; });
+                        if (this.children && this.children.find((child) => child.group)) {
+                            const child = this.children.find((childd) => !!childd.group);
                             // Make visible only radioGroup layers
                             child.visible = true;
                         }
                         // Warn the same group that a new layer is visible
-                        if (_this.parent && _this.group) {
+                        if (this.parent && this.group) {
                             // We search for the higher parent then it will dispatch to all the tree.
-                            var higherParent = _this.parent;
+                            let higherParent = this.parent;
                             while (higherParent.parent) {
                                 higherParent = higherParent.parent;
                             }
                             higherParent.dispatchEvent({
-                                type: "change:visible:group",
-                                target: _this,
+                                type: `change:visible:group`,
+                                target: this,
                             });
                         }
                     }
-                    else if (!_this.visible) {
-                        if (_this.parent &&
-                            _this.parent.visible &&
-                            !_this.parent.children.find(function (child) { return child.visible; })) {
-                            _this.parent.visible = false;
+                    else if (!this.visible) {
+                        if (this.parent &&
+                            this.parent.visible &&
+                            !this.parent.children.find((child) => child.visible)) {
+                            this.parent.visible = false;
                         }
                     }
                 },
             },
             disabled: {
-                get: function () { return _this.get('disabled'); },
-                set: function (newValue) {
-                    _this.set('disabled', newValue);
+                get: () => this.get('disabled'),
+                set: (newValue) => {
+                    this.set('disabled', newValue);
                 },
             },
             /* Layer's hierarchy properties */
@@ -177,19 +145,19 @@ var Layer = /** @class */ (function (_super) {
                 writable: true,
             },
             children: {
-                get: function () { return _this.get('children') || []; },
-                set: function (newValue) {
-                    (_this.children || []).forEach(function (child) {
+                get: () => this.get('children') || [],
+                set: (newValue) => {
+                    (this.children || []).forEach((child) => {
                         // eslint-disable-next-line no-param-reassign
                         child.parent = null;
                     });
                     if (Array.isArray(newValue)) {
-                        newValue.forEach(function (child) {
+                        newValue.forEach((child) => {
                             // eslint-disable-next-line no-param-reassign
-                            child.parent = _this;
+                            child.parent = this;
                         });
                     }
-                    _this.set('children', newValue || []);
+                    this.set('children', newValue || []);
                 },
             },
             /* Layer's query properties */
@@ -199,33 +167,33 @@ var Layer = /** @class */ (function (_super) {
             },
             /* Custom app specific properties */
             properties: {
-                value: __assign({}, (properties || {})),
+                value: Object.assign({}, (properties || {})),
             },
         });
-    };
+    }
     /**
      * Initialize the layer with the map passed in parameters.
      *
      * @param {ol/Map~Map|mapboxgl.Map} map A map.
      */
-    Layer.prototype.attachToMap = function (map) {
+    attachToMap(map) {
         this.detachFromMap();
         /** @ignore */
         this.map = map;
         if (this.children) {
-            this.children.forEach(function (child) {
+            this.children.forEach((child) => {
                 child.attachToMap(map);
             });
         }
-    };
+    }
     /**
      * Terminate what was initialized in init function. Remove layer, events...
      */
     // eslint-disable-next-line class-methods-use-this
-    Layer.prototype.detachFromMap = function () {
+    detachFromMap() {
         /** @ignore */
         this.map = null;
-    };
+    }
     /**
      * Request feature information for a given coordinate.
      * This function must be implemented by inheriting layers.
@@ -235,7 +203,7 @@ var Layer = /** @class */ (function (_super) {
      * @return {Promise<FeatureInfo>} An empty response.
      */
     // eslint-disable-next-line no-unused-vars,@typescript-eslint/no-unused-vars
-    Layer.prototype.getFeatureInfoAtCoordinate = function (coordinate, options) {
+    getFeatureInfoAtCoordinate(coordinate, options) {
         // eslint-disable-next-line no-console
         console.error('getFeatureInfoAtCoordinate must be implemented by inheriting layers', this.key);
         // This layer returns no feature info.
@@ -243,15 +211,13 @@ var Layer = /** @class */ (function (_super) {
         return Promise.resolve({
             layer: this,
             features: [],
-            coordinate: coordinate,
+            coordinate,
         });
-    };
+    }
     /**
      * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
      */
-    Layer.prototype.flat = function () {
-        return (0, getLayersAsFlatArray_1.default)(this);
-    };
-    return Layer;
-}(Object_1.default));
-exports.default = Layer;
+    flat() {
+        return getLayersAsFlatArray(this);
+    }
+}

package/common/layers/Layer.test.d.ts

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

package/common/layers/Layer.test.d.ts.map

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

package/common/layers/Layer.test.js

@@ -0,0 +1,137 @@
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import Layer from './Layer';
+const olLayer = new VectorLayer({ source: new VectorSource() });
+describe('Layer', () => {
+    test('should initialize.', () => {
+        const layer = new Layer({ name: 'Layer', olLayer });
+        expect(layer).toBeInstanceOf(Layer);
+    });
+    test('should define default properties.', () => {
+        const options = {
+            name: 'Layer',
+            key: 'Layerkey',
+            olLayer,
+        };
+        const layer = new Layer(options);
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.options).toEqual(options);
+        expect(layer.name).toEqual(options.name);
+        expect(layer.key).toEqual('Layerkey');
+        expect(layer.hitTolerance).toBe(5);
+        expect(layer.copyrights).toEqual([]);
+        expect(layer.visible).toBe(true);
+        expect(layer.properties).toEqual({});
+        expect(layer.map).toBe(undefined);
+        expect(layer.group).toBe(undefined);
+    });
+    test('should be visible by default.', () => {
+        const layer = new Layer();
+        expect(layer.visible).toBe(true);
+    });
+    test('should be hidden using constructor.', () => {
+        const layer = new Layer({ visible: false });
+        expect(layer.visible).toBe(false);
+    });
+    test('should be hidden using setter.', () => {
+        const layer = new Layer();
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should visibility stay unchanged', () => {
+        const layer = new Layer();
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should return its name.', () => {
+        const layer = new Layer({ name: 'Layer' });
+        expect(layer.name).toEqual('Layer');
+    });
+    test('should called detachFromMap on initialization.', () => {
+        const layer = new Layer();
+        const spy = jest.spyOn(layer, 'detachFromMap');
+        layer.attachToMap();
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    test('should properties correctly set and get.', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            olLayer,
+            properties: {
+                abc: 'foo',
+            },
+        });
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.get('abc')).toEqual('foo');
+        layer.set('abc', 'bar');
+        expect(layer.get('abc')).toEqual('bar');
+    });
+    test('should set children', () => {
+        const layer = new Layer({
+            children: [new Layer(), new Layer()],
+        });
+        expect(layer.children.length).toBe(2);
+        expect(layer.children[0].parent).toBe(layer);
+        expect(layer.children[1].parent).toBe(layer);
+    });
+    test('should initialize copyrights property.', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            olLayer,
+            copyrights: ['&copy: copyright', 'another copyright'],
+        });
+        expect(layer.copyrights[0]).toEqual('&copy: copyright');
+    });
+    test('should set and get copyright property.', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            olLayer,
+        });
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.copyright).toEqual(undefined);
+        layer.copyright = '© OSM Contributors';
+        expect(layer.copyright).toEqual('© OSM Contributors');
+    });
+    describe('#attachToMap()', () => {
+        test('should set map.', () => {
+            const layer = new Layer({
+                name: 'Layer',
+                olLayer,
+            });
+            expect(layer.map).toBe(undefined);
+            const obj = {};
+            layer.attachToMap(obj);
+            expect(layer.map).toBe(obj);
+        });
+        test('should call terminate.', () => {
+            const layer = new Layer({
+                name: 'Layer',
+                olLayer,
+            });
+            const spy = jest.spyOn(layer, 'detachFromMap');
+            layer.attachToMap();
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('#getFeatureInfoAtCoordinate()', () => {
+        test('return an empty fetaureInfo object and display an error message', (done) => {
+            // eslint-disable-next-line no-console
+            console.error = jest.fn();
+            const layer = new Layer({
+                name: 'Layer',
+                olLayer,
+            });
+            const coord = [0, 0];
+            layer.getFeatureInfoAtCoordinate(coord).then((featureInfo) => {
+                expect(featureInfo.features).toEqual([]);
+                expect(featureInfo.layer).toEqual(layer);
+                expect(featureInfo.coordinate).toEqual(coord);
+                // eslint-disable-next-line no-console
+                expect(console.error).toHaveBeenCalledTimes(1);
+                done();
+                // eslint-disable-next-line no-console
+                console.error.mockRestore();
+            });
+        });
+    });
+});