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

package/common/controls/Control.js

@@ -1,81 +1,170 @@
-import BaseObject from "ol/Object";
-class Control extends BaseObject {
-  constructor(options = {}) {
-    super(options);
-    this.defineProperties(options);
-    const { active } = {
-      active: options.active !== false,
-      ...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);
     };
-    this.active = active;
-  }
-  defineProperties(options) {
-    const { target, element, render } = {
-      ...options
+    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.defineProperties(this, {
-      active: {
-        get: () => this.get("active"),
-        set: (newActive) => {
-          this.set("active", newActive);
-          if (newActive) {
-            this.activate();
-          } else {
-            this.deactivate();
-          }
-          this.render();
+})();
+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];
         }
-      },
-      map: {
-        get: () => this.get("map"),
-        set: (map) => {
-          if (this.map && this.element && this.element.parentNode) {
-            this.element.parentNode.removeChild(this.element);
-          }
-          this.deactivate();
-          this.set("map", map);
-          if (this.map) {
-            const targett = this.target || this.map.getTargetElement && this.map.getTargetElement() || this.map.getContainer && this.map.getContainer();
-            if (!this.element) {
-              this.createDefaultElement();
-            }
-            if (this.element) {
-              targett.appendChild(this.element);
-            }
-            if (this.active) {
-              this.activate();
-            }
-          }
-          this.render();
-        }
-      },
-      target: {
-        value: target
-      },
-      element: {
-        value: element,
-        writable: true
-      },
-      render: {
-        value: render || this.render,
-        writable: true
-      }
-    });
-  }
-  attachToMap(map) {
-    this.map = map;
-  }
-  detachFromMap() {
-    this.map = null;
-  }
-  activate() {
-    this.deactivate();
-  }
-  deactivate() {
-  }
-  render() {
-  }
-  createDefaultElement() {
-  }
-}
-export default Control;
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Object_1 = require("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.
+ */
+var Control = /** @class */ (function (_super) {
+    __extends(Control, _super);
+    /**
+     * 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.
+     */
+    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;
+        /**
+         * @ignore
+         */
+        _this.active = active;
+        return _this;
+    }
+    /**
+     * 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;
+        Object.defineProperties(this, {
+            active: {
+                get: function () { return _this.get('active'); },
+                set: function (newActive) {
+                    _this.set('active', newActive);
+                    if (newActive) {
+                        _this.activate();
+                    }
+                    else {
+                        _this.deactivate();
+                    }
+                    _this.render();
+                },
+            },
+            map: {
+                get: function () { return _this.get('map'); },
+                set: function (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);
+                    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();
+                        }
+                        if (_this.element) {
+                            targett.appendChild(_this.element);
+                        }
+                        // Add listeners
+                        if (_this.active) {
+                            _this.activate();
+                        }
+                    }
+                    _this.render();
+                },
+            },
+            target: {
+                value: target,
+            },
+            element: {
+                value: element,
+                writable: true,
+            },
+            render: {
+                /** @ignore */
+                value: render || this.render,
+                writable: true,
+            },
+        });
+    };
+    /**
+     * Attach the control to the map. Add events, html element ...
+     */
+    Control.prototype.attachToMap = function (map) {
+        this.map = map;
+    };
+    /**
+     * Detach the control From the map. Remove events, html element ..
+     */
+    Control.prototype.detachFromMap = function () {
+        this.map = null;
+    };
+    /**
+     * Add listeners then renders the control.
+     * To be defined in inherited classes.
+     */
+    Control.prototype.activate = function () {
+        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 () { };
+    /**
+     * The default render function. It renders content in the HTML element.
+     * To be defined in inherited classes.
+     *
+     * @private
+     */
+    Control.prototype.render = function () { };
+    /**
+     * 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
+    Control.prototype.createDefaultElement = function () { };
+    return Control;
+}(Object_1.default));
+exports.default = Control;

package/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./utils";
+export * from "./styles";
+//# sourceMappingURL=index.d.ts.map

package/common/index.d.ts.map

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

package/common/index.js

@@ -1,2 +1,18 @@
-export * from "./utils";
-export * from "./styles";
+"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);

package/common/layers/Layer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ */
+export default class Layer extends BaseObject {
+    /**
+     * 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.
+     */
+    constructor(options?: {
+        key?: string;
+        name?: string;
+        copyrights?: string[];
+        children?: Array<Layer>;
+        visible?: boolean;
+        disabled?: boolean;
+        hitTolerance?: number;
+        properties?: any;
+    });
+    visible: boolean;
+    group: any;
+    copyrights: string[];
+    children: Layer[];
+    /**
+     * Define layer's properties that needs custom get and set.
+     *
+     * @ignore
+     */
+    defineProperties(options: any): void;
+    /**
+     * Initialize the layer with the map passed in parameters.
+     *
+     * @param {ol/Map~Map|mapboxgl.Map} map A map.
+     */
+    attachToMap(map: any): void;
+    /** @ignore */
+    map: any;
+    /**
+     * Terminate what was initialized in init function. Remove layer, events...
+     */
+    detachFromMap(): void;
+    /**
+     * 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.
+     */
+    getFeatureInfoAtCoordinate(coordinate: any, options: any): Promise<FeatureInfo>;
+    /**
+     * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
+     */
+    flat(): any[];
+}
+import BaseObject from "ol/Object";
+//# sourceMappingURL=Layer.d.ts.map

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

@@ -0,0 +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"}