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

package/common/layers/Layer.js

@@ -1,140 +1,257 @@
-import BaseObject from "ol/Object";
-import { v4 as uuid } from "uuid";
-import getLayersAsFlatArray from "../utils/getLayersAsFlatArray";
-export default class Layer extends BaseObject {
-  constructor(options = {}) {
-    super();
-    this.defineProperties(options);
-    this.setProperties(options.properties);
-    this.visible = options.visible === void 0 ? true : !!options.visible;
-    this.group = options.group;
-    this.copyrights = options.copyrights;
-    this.children = options.children;
-    this.on(`change:visible:group`, (evt) => {
-      if (this.group === evt.target.group && this !== evt.target && this.visible) {
-        this.visible = false;
-      } else if (this.children) {
-        this.children.forEach((child) => child.dispatchEvent(evt));
-      }
-    });
-  }
-  defineProperties(options) {
-    const { name, key, properties, hitTolerance } = {
-      ...options
+"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);
     };
-    const uid = uuid();
-    Object.defineProperties(this, {
-      name: {
-        value: name
-      },
-      key: {
-        value: key || uid
-      },
-      group: {
-        get: () => this.get("group"),
-        set: (newGroup) => {
-          this.set("group", newGroup);
-        }
-      },
-      copyrights: {
-        get: () => this.get("copyrights"),
-        set: (newCopyrights) => {
-          const arrValue = newCopyrights && !Array.isArray(newCopyrights) ? [newCopyrights] : newCopyrights;
-          this.set("copyrights", arrValue || []);
+    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];
         }
-      },
-      options: {
-        value: options
-      },
-      map: {
-        writable: true
-      },
-      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;
-            }
-            if (this.children && this.children.find((child) => child.group)) {
-              const child = this.children.find((childd) => !!childd.group);
-              child.visible = true;
-            }
-            if (this.parent && this.group) {
-              let higherParent = this.parent;
-              while (higherParent.parent) {
-                higherParent = higherParent.parent;
-              }
-              higherParent.dispatchEvent({
-                type: `change:visible:group`,
-                target: this
-              });
+        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");
+/**
+ * A class representing a layer to display on map.
+ *
+ * @example
+ * const layer = new Layer({
+ *   name: 'My Layer',
+ * });
+ *
+ * @classproperty {string} key - Identifier of the layer. Must be unique.
+ * @classproperty {string} name - Name of the layer
+ * @classproperty {string[]} copyrights - Array of copyrights.
+ * @classproperty {Layer[]} children - List of children layers.
+ * @classproperty {boolean} visible - Define if the layer is currently display on the map.
+ * @classproperty {boolean} disabled - Define if the layer is currently display on the map but can't be seen (extent, zoom ,data restrictions).
+ * @classproperty {number} hitTolerance - Hit-detection tolerance in css pixels. Pixels inside the radius around the given position will be checked for features.
+ * @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);
+    /**
+     * Constructor
+     *
+     * @param {Object} options
+     * @param {string} [options.key=uuid()] Identifier of the layer. Muste be unique. Default use a generated uuid.
+     * @param {string} [options.name] Name of the layer.
+     * @param {string[]} [options.copyrights] Array of copyrights.
+     * @param {Array<Layer>} [options.children=[]] Sublayers, all child layers will have a parent property associated to this layer.
+     * @param {boolean} [options.visible=true]  Define if the layer is currently display on the map.
+     * @param {boolean} [options.disabled=false] Define if the layer is currently display on the map but can't be seen (extent, zoom ,data restrictions).
+     * @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;
+        // 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) {
+            // We hide layer of the same group
+            if (_this.group === evt.target.group &&
+                _this !== evt.target &&
+                _this.visible) {
+                _this.visible = false;
+                // Propagate event to parent
             }
-          } else if (!this.visible) {
-            if (this.parent && this.parent.visible && !this.parent.children.find((child) => child.visible)) {
-              this.parent.visible = false;
+            else if (_this.children) {
+                _this.children.forEach(function (child) { return child.dispatchEvent(evt); });
             }
-          }
-        }
-      },
-      disabled: {
-        get: () => this.get("disabled"),
-        set: (newValue) => {
-          this.set("disabled", newValue);
-        }
-      },
-      parent: {
-        value: null,
-        writable: true
-      },
-      children: {
-        get: () => this.get("children") || [],
-        set: (newValue) => {
-          (this.children || []).forEach((child) => {
-            child.parent = null;
-          });
-          if (Array.isArray(newValue)) {
-            newValue.forEach((child) => {
-              child.parent = this;
+        });
+        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)();
+        Object.defineProperties(this, {
+            /* Layer's information properties */
+            name: {
+                value: name,
+            },
+            key: {
+                value: key || uid,
+            },
+            group: {
+                get: function () { return _this.get('group'); },
+                set: function (newGroup) {
+                    _this.set('group', newGroup);
+                },
+            },
+            copyrights: {
+                get: function () { return _this.get('copyrights'); },
+                set: function (newCopyrights) {
+                    var arrValue = newCopyrights && !Array.isArray(newCopyrights)
+                        ? [newCopyrights]
+                        : newCopyrights;
+                    _this.set('copyrights', arrValue || []);
+                },
+            },
+            // options is used for clone function.
+            options: {
+                value: options,
+            },
+            map: {
+                writable: true,
+            },
+            /* Layer's state properties */
+            visible: {
+                get: function () { return _this.get('visible'); },
+                set: function (newVisible) {
+                    if (newVisible === _this.visible) {
+                        return;
+                    }
+                    _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; });
+                            // Make visible only radioGroup layers
+                            child.visible = true;
+                        }
+                        // Warn the same group that a new layer is visible
+                        if (_this.parent && _this.group) {
+                            // We search for the higher parent then it will dispatch to all the tree.
+                            var higherParent = _this.parent;
+                            while (higherParent.parent) {
+                                higherParent = higherParent.parent;
+                            }
+                            higherParent.dispatchEvent({
+                                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;
+                        }
+                    }
+                },
+            },
+            disabled: {
+                get: function () { return _this.get('disabled'); },
+                set: function (newValue) {
+                    _this.set('disabled', newValue);
+                },
+            },
+            /* Layer's hierarchy properties */
+            parent: {
+                value: null,
+                writable: true,
+            },
+            children: {
+                get: function () { return _this.get('children') || []; },
+                set: function (newValue) {
+                    (_this.children || []).forEach(function (child) {
+                        // eslint-disable-next-line no-param-reassign
+                        child.parent = null;
+                    });
+                    if (Array.isArray(newValue)) {
+                        newValue.forEach(function (child) {
+                            // eslint-disable-next-line no-param-reassign
+                            child.parent = _this;
+                        });
+                    }
+                    _this.set('children', newValue || []);
+                },
+            },
+            /* Layer's query properties */
+            hitTolerance: {
+                value: hitTolerance || 5,
+                writable: true,
+            },
+            /* Custom app specific properties */
+            properties: {
+                value: __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) {
+        this.detachFromMap();
+        /** @ignore */
+        this.map = map;
+        if (this.children) {
+            this.children.forEach(function (child) {
+                child.attachToMap(map);
             });
-          }
-          this.set("children", newValue || []);
         }
-      },
-      hitTolerance: {
-        value: hitTolerance || 5,
-        writable: true
-      },
-      properties: {
-        value: { ...properties || {} }
-      }
-    });
-  }
-  attachToMap(map) {
-    this.detachFromMap();
-    this.map = map;
-    if (this.children) {
-      this.children.forEach((child) => {
-        child.attachToMap(map);
-      });
-    }
-  }
-  detachFromMap() {
-    this.map = null;
-  }
-  getFeatureInfoAtCoordinate(coordinate, options) {
-    console.error("getFeatureInfoAtCoordinate must be implemented by inheriting layers", this.key);
-    return Promise.resolve({
-      layer: this,
-      features: [],
-      coordinate
-    });
-  }
-  flat() {
-    return getLayersAsFlatArray(this);
-  }
-}
+    };
+    /**
+     * Terminate what was initialized in init function. Remove layer, events...
+     */
+    // eslint-disable-next-line class-methods-use-this
+    Layer.prototype.detachFromMap = function () {
+        /** @ignore */
+        this.map = null;
+    };
+    /**
+     * Request feature information for a given coordinate.
+     * This function must be implemented by inheriting layers.
+     *
+     * @param {ol/coordinate~Coordinate} coordinate Coordinate.
+     * @param {Object} options Some options. See child classes to see which are supported.
+     * @return {Promise<FeatureInfo>} An empty response.
+     */
+    // eslint-disable-next-line no-unused-vars,@typescript-eslint/no-unused-vars
+    Layer.prototype.getFeatureInfoAtCoordinate = function (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.
+        // The function is implemented by inheriting layers.
+        return Promise.resolve({
+            layer: this,
+            features: [],
+            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;

package/common/mixins/CopyrightMixin.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright control interface.
+ *
+ */
+export class CopyrightInterface {
+    /**
+     * Return an array of layer's copyright.
+     *
+     * @return {String[]} A list of copyrights to render.
+     */
+    getCopyrights(): string[];
+}
+export default CopyrightMixin;
+/**
+ * Mixin for CopyrightInterface.
+ *
+ * @param {Class} Base  A class to extend with {CopyrightInterface} functionnalities.
+ * @return {Class}  A class that implements <CopyrightInterface> class and extends Base;
+ * @private
+ */
+declare function CopyrightMixin(Base: Class): Class;
+//# sourceMappingURL=CopyrightMixin.d.ts.map

package/common/mixins/CopyrightMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CopyrightMixin.d.ts","sourceRoot":"","sources":["../../../src/common/mixins/CopyrightMixin.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACE;;;;OAIG;IACH,iBAFY,QAAQ,CAEF;CACnB;;AAED;;;;;;GAMG;AACH,oDAsBG"}

package/common/mixins/CopyrightMixin.js

@@ -1,24 +1,72 @@
-export class CopyrightInterface {
-  getCopyrights() {
-  }
-}
-const CopyrightMixin = (Base) => class extends Base {
-  render() {
-    if (!this.element) {
-      return;
+"use strict";
+/* eslint-disable class-methods-use-this */
+/* eslint-disable max-classes-per-file */
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyrightInterface = void 0;
+/**
+ * Copyright control interface.
+ *
+ */
+var CopyrightInterface = /** @class */ (function () {
+    function CopyrightInterface() {
     }
-    this.element.innerHTML = this.active ? this.getCopyrights().join(" | ") : "";
-  }
-  createDefaultElement() {
-    this.element = document.createElement("div");
-    this.element.id = "mbt-copyright";
-    Object.assign(this.element.style, {
-      position: "absolute",
-      bottom: 0,
-      right: 0,
-      fontSize: ".8rem",
-      padding: "0 10px"
-    });
-  }
+    /**
+     * Return an array of layer's copyright.
+     *
+     * @return {String[]} A list of copyrights to render.
+     */
+    CopyrightInterface.prototype.getCopyrights = function () { };
+    return CopyrightInterface;
+}());
+exports.CopyrightInterface = CopyrightInterface;
+/**
+ * Mixin for CopyrightInterface.
+ *
+ * @param {Class} Base  A class to extend with {CopyrightInterface} functionnalities.
+ * @return {Class}  A class that implements <CopyrightInterface> class and extends Base;
+ * @private
+ */
+var CopyrightMixin = function (Base) {
+    return /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        class_1.prototype.render = function () {
+            if (!this.element) {
+                return;
+            }
+            this.element.innerHTML = this.active
+                ? this.getCopyrights().join(' | ')
+                : '';
+        };
+        class_1.prototype.createDefaultElement = function () {
+            this.element = document.createElement('div');
+            this.element.id = 'mbt-copyright';
+            Object.assign(this.element.style, {
+                position: 'absolute',
+                bottom: 0,
+                right: 0,
+                fontSize: '.8rem',
+                padding: '0 10px',
+            });
+        };
+        return class_1;
+    }(Base));
 };
-export default CopyrightMixin;
+exports.default = CopyrightMixin;

package/common/mixins/MapboxLayerMixin.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MapboxLayerInterface
+ */
+export class MapboxLayerInterface {
+    /**
+     * Return the render function function for the ol layer.
+     *
+     */
+    getOlLayerRender(): void;
+    /**
+     * Return the Class to instanciate for the mapbox map.
+     *
+     * @return {mapboxgl.Map|maplibregl.Map} map
+     */
+    getMapboxMapClass(): mapboxgl.Map | maplibregl.Map;
+}
+export default MapboxLayerMixin;
+/**
+ * Mixin for MapboxLayerLayerInterface.
+ * It's used to share code between Mapbox and Maplibre layers without importing both libs
+ *
+ * @param {Class} Base A class to extend with {MapboxLayerLayerInterface} functionnalities.
+ * @return {Class}  A class that implements {MapboxLayerLayerInterface} class and extends Base;
+ * @private
+ */
+declare function MapboxLayerMixin(Base: Class): Class;
+//# sourceMappingURL=MapboxLayerMixin.d.ts.map

package/common/mixins/MapboxLayerMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapboxLayerMixin.d.ts","sourceRoot":"","sources":["../../../src/common/mixins/MapboxLayerMixin.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IACE;;;OAGG;IAEH,yBAAqB;IAErB;;;;OAIG;IAEH,qBAHY,eAAa,cAAc,CAGjB;CACvB;;AAED;;;;;;;GAOG;AACH,sDA6MG"}