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

package/ol/controls/CopyrightControl.d.ts

@@ -0,0 +1,31 @@
+export default CopyrightControl;
+/**
+ * Display layer's copyrights.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { CopyrightControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ * const control = new CopyrightControl();
+ * control.attachToMap(map)
+ *
+ *
+ * @see <a href="/example/ol-copyright">Openlayers copyright example</a>
+ *
+ * @extends {Control}
+ * @implements {CopyrightInterface}
+ */
+declare class CopyrightControl extends Control implements CopyrightInterface {
+    constructor(options: any);
+    onPostRender(evt: any): void;
+    getCopyrights(): any[];
+    /**
+     * @ignore
+     */
+    frameState: any;
+}
+import Control from "../../common/controls/Control";
+//# sourceMappingURL=CopyrightControl.d.ts.map

package/ol/controls/CopyrightControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CopyrightControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/CopyrightControl.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAFgB,kBAAkB;IAGhC,0BAGC;IAwCD,6BAQC;IA9CD,uBAsBC;IAkBG;;OAEG;IACH,gBAAgC;CAIrC"}

package/ol/controls/CopyrightControl.js

@@ -1,42 +1,90 @@
-import { inView } from "ol/layer/Layer";
-import Control from "../../common/controls/Control";
-import mixin from "../../common/mixins/CopyrightMixin";
-import removeDuplicate from "../../common/utils/removeDuplicate";
-class CopyrightControl extends mixin(Control) {
-  constructor(options) {
-    super(options);
-    this.onPostRender = this.onPostRender.bind(this);
-  }
-  getCopyrights() {
-    if (!this.frameState) {
-      return [];
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Layer_1 = require("ol/layer/Layer");
+var Control_1 = require("../../common/controls/Control");
+var CopyrightMixin_1 = require("../../common/mixins/CopyrightMixin");
+var removeDuplicate_1 = require("../../common/utils/removeDuplicate");
+/**
+ * Display layer's copyrights.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { CopyrightControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ * const control = new CopyrightControl();
+ * control.attachToMap(map)
+ *
+ *
+ * @see <a href="/example/ol-copyright">Openlayers copyright example</a>
+ *
+ * @extends {Control}
+ * @implements {CopyrightInterface}
+ */
+var CopyrightControl = /** @class */ (function (_super) {
+    __extends(CopyrightControl, _super);
+    function CopyrightControl(options) {
+        var _this = _super.call(this, options) || this;
+        _this.onPostRender = _this.onPostRender.bind(_this);
+        return _this;
     }
-    let copyrights = [];
-    this.frameState.layerStatesArray.forEach((layerState) => {
-      const { layer } = layerState;
-      if (inView(layerState, this.frameState.viewState) && layer && layer.getSource && layer.getSource() && layer.getSource().getAttributions()) {
-        copyrights = copyrights.concat(layer.getSource().getAttributions()(this.frameState));
-      }
-    });
-    return removeDuplicate(copyrights);
-  }
-  activate() {
-    super.activate();
-    if (this.map) {
-      this.map.on("postrender", this.onPostRender);
-    }
-  }
-  deactivate() {
-    if (this.map) {
-      this.map.un("postrender", this.onPostRender);
-    }
-    super.deactivate();
-  }
-  onPostRender(evt) {
-    if (this.map && this.element) {
-      this.frameState = evt.frameState;
-      this.render();
-    }
-  }
-}
-export default CopyrightControl;
+    CopyrightControl.prototype.getCopyrights = function () {
+        var _this = this;
+        if (!this.frameState) {
+            return [];
+        }
+        var copyrights = [];
+        // This code loop comes mainly from ol.
+        this.frameState.layerStatesArray.forEach(function (layerState) {
+            var layer = layerState.layer;
+            if ((0, Layer_1.inView)(layerState, _this.frameState.viewState) &&
+                layer &&
+                layer.getSource &&
+                layer.getSource() &&
+                layer.getSource().getAttributions()) {
+                copyrights = copyrights.concat(layer.getSource().getAttributions()(_this.frameState));
+            }
+        });
+        return (0, removeDuplicate_1.default)(copyrights);
+    };
+    CopyrightControl.prototype.activate = function () {
+        _super.prototype.activate.call(this);
+        if (this.map) {
+            this.map.on('postrender', this.onPostRender);
+        }
+    };
+    CopyrightControl.prototype.deactivate = function () {
+        if (this.map) {
+            this.map.un('postrender', this.onPostRender);
+        }
+        _super.prototype.deactivate.call(this);
+    };
+    CopyrightControl.prototype.onPostRender = function (evt) {
+        if (this.map && this.element) {
+            /**
+             * @ignore
+             */
+            this.frameState = evt.frameState;
+            this.render();
+        }
+    };
+    return CopyrightControl;
+}((0, CopyrightMixin_1.default)(Control_1.default)));
+exports.default = CopyrightControl;

package/ol/controls/RoutingControl.d.ts

@@ -0,0 +1,180 @@
+export default RoutingControl;
+/**
+ * Display a route of a specified mean of transport.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { RoutingControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map'
+ * });
+ *
+ * const control = new RoutingControl();
+ *
+ * control.attachToMap(map)
+ *
+ * @classproperty {string} apiKey - Key used for RoutingApi requests.
+ * @classproperty {string} stopsApiKey - Key used for Stop lookup requests (defaults to apiKey).
+ * @classproperty {string} stopsApiUrl - Url used for Stop lookup requests (defaults to https://api.geops.io/stops/v1/lookup/).
+ * @classproperty {Array.<Array<graph="osm", minZoom=0, maxZoom=99>>} graphs - Array of routing graphs and min/max zoom levels. If you use the control in combination with the [geOps Maps API](https://developer.geops.io/apis/maps/), you may want to use the optimal level of generalizations: "[['gen4', 0, 8], ['gen3', 8, 9], ['gen2', 9, 11], ['gen1', 11, 13], ['osm', 13, 99]]"
+ * @classproperty {string} mot - Mean of transport to be used for routing.
+ * @classproperty {object} routingApiParams - object of additional parameters to pass to the routing api request.
+ * @classproperty {object} snapToClosestStation - If true, the routing will snap the coordinate to the closest station. Default to false.
+ * @classproperty {boolean} useRawViaPoints - Experimental property. Wen true, it allows the user to add via points using different kind of string. See "via" parameter defined by the [geOps Routing API](https://developer.geops.io/apis/routing/). Default to false, only array of coordinates and station's id are supported as via points.
+ * @classproperty {RoutingLayer|Layer} routingLayer - Layer for adding route features.
+ * @classproperty {function} onRouteError - Callback on error.
+ * @classproperty {boolean} loading - True if the control is requesting the backend.
+ * @see <a href="/example/ol-routing">Openlayers routing example</a>
+ *
+ * @extends {Control}
+ * @implements {RoutingInterface}
+ */
+declare class RoutingControl extends Control implements RoutingInterface {
+    /**
+     * Calculate at which resolutions corresponds each generalizations.
+     *
+     * @private
+     */
+    private static getGraphsResolutions;
+    constructor(options?: {});
+    /** True if the control is requesting the backend. */
+    loading: boolean;
+    /** @ignore */
+    graphs: any;
+    /** @ignore */
+    mot: any;
+    /** @ignore */
+    modify: boolean;
+    /** @ignore */
+    routingApiParams: any;
+    /** @ignore */
+    useRawViaPoints: any;
+    /** @ignore */
+    snapToClosestStation: any;
+    /** @ignore */
+    cacheStationData: {};
+    /** @ignore */
+    abortControllers: any[];
+    /** @ignore */
+    apiKey: any;
+    /** @ignore */
+    stopsApiKey: any;
+    /** @ignore */
+    segments: any[];
+    /** @ignore */
+    stopsApiUrl: any;
+    /** @ignore */
+    api: RoutingAPI;
+    /** @ignore */
+    routingLayer: any;
+    /** @ignore */
+    onRouteError: any;
+    /** @ignore */
+    viaPoints: any[];
+    /**
+     * Used on click on map while control is active:
+     *   By default adds a viaPoint to the end of array.
+     *   If an existing viaPoint is clicked removes the clicked viaPoint.
+     * @private
+     */
+    private onMapClick;
+    /**
+     * Used on end of the modify interaction. Resolves feature modification:
+     *   Line drag creates new viaPoint at the final coordinate of drag.
+     *   Point drag replaces old viaPoint.
+     * @private
+     */
+    private onModifyEnd;
+    /**
+     * Used on start of the modify interaction. Stores relevant data
+     * in this.initialRouteDrag object
+     * @private
+     */
+    private onModifyStart;
+    /** @ignore */
+    apiChangeListener: () => Promise<any>;
+    /**
+     * Adds/Replaces a viaPoint to the viaPoints array and redraws route:
+     *   Adds a viaPoint at end of array by default.
+     *   If an index is passed a viaPoint is added at the specified index.
+     *   If an index is passed and overwrite x is > 0, x viaPoints at the specified
+     *     index are replaced with a single new viaPoint.
+     * @param {number[]|string} coordinates Array of coordinates
+     * @param {number} [index=-1] Integer representing the index of the added viaPoint. If not specified, the viaPoint is added at the end of the array.
+     * @param {number} [overwrite=0] Marks the number of viaPoints that are removed at the specified index on add.
+     */
+    addViaPoint(coordinatesOrString: any, index?: number, overwrite?: number): void;
+    /**
+     * Removes a viaPoint at the passed array index and redraws route
+     * By default the last viaPoint is removed.
+     * @param {number} index Integer representing the index of the viaPoint to delete.
+     */
+    removeViaPoint(index?: number): void;
+    /**
+     * Replaces the current viaPoints with a new coordinate array.
+     * @param {Array<Array<number>>} coordinateArray Array of nested coordinates
+     */
+    setViaPoints(coordinateArray: Array<Array<number>>): void;
+    /**
+     * Removes all viaPoints, clears the source and triggers a change event
+     */
+    reset(): void;
+    /**
+     * Aborts viapoint and route requests
+     * @private
+     */
+    private abortRequests;
+    /**
+     * Draws route on map using an array of coordinates:
+     *   If a single coordinate is passed a single point feature is added to map.
+     *   If two or more coordinates are passed a request to the RoutingAPI fetches
+     *       the route using the passed coordinates and the current mot.
+     * @private
+     */
+    private drawRoute;
+    /**
+     * Draw a via point. This function can parse all the possibilitiies
+     *
+     * @private
+     */
+    private drawViaPoint;
+    /** @ignore */
+    initialRouteDrag: {
+        viaPoint: any;
+        oldRoute: any;
+        segmentIndex: number;
+    };
+    /** @ignore */
+    element: HTMLButtonElement;
+    /**
+     * Create the interaction used to modify vertexes of features.
+     * @private
+     */
+    private createModifyInteraction;
+    /**
+     * @type {ol.interaction.Modify}
+     * @private
+     */
+    private modifyInteraction;
+    /**
+     * Add click listener to map.
+     * @private
+     */
+    private addListeners;
+    /** @ignore */
+    onMapClickKey: any;
+    /**
+     * Remove click listener from map.
+     * @private
+     */
+    private removeListeners;
+    /** @ignore */
+    format: GeoJSON;
+    /** @ignore */
+    graphsResolutions: any;
+}
+import Control from "../../common/controls/Control";
+import { RoutingAPI } from "../../api";
+import { GeoJSON } from "ol/format";
+//# sourceMappingURL=RoutingControl.d.ts.map

package/ol/controls/RoutingControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutingControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/RoutingControl.js"],"names":[],"mappings":";AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wDAFgB,gBAAgB;IAoH9B;;;;OAIG;IACH,oCAMC;IA5HD,0BA+GC;IAlFC,qDAAqD;IACrD,iBAAoB;IAEpB,cAAc;IACd,YAAgD;IAEhD,cAAc;IACd,SAA+B;IAE/B,cAAc;IACd,gBAAsC;IAEtC,cAAc;IACd,sBAAsD;IAEtD,cAAc;IACd,qBAAuD;IAEvD,cAAc;IACd,0BAAiE;IAEjE,cAAc;IACd,qBAA0B;IAE1B,cAAc;IACd,wBAA0B;IAE1B,cAAc;IACd,YAA4B;IAE5B,cAAc;IACd,iBAAqD;IAErD,cAAc;IACd,gBAAkB;IAElB,cAAc;IACd,iBAA0E;IAE1E,cAAc;IACd,gBAEE;IAEF,cAAc;IACd,kBAKI;IAEJ,cAAc;IACd,kBAUI;IAEJ,cAAc;IACd,iBAAmB;IAoXrB;;;;;OAKG;IACH,mBAeC;IA4CD;;;;;OAKG;IACH,oBAqBC;IArED;;;;OAIG;IACH,sBAmCC;IAxaC,cAAc;IACd,sCAA+C;IAmBjD;;;;;;;;;OASG;IACH,8CAHW,MAAM,cACN,MAAM,QAchB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,8BAFW,MAAM,MAAM,MAAM,CAAC,CAAC,QAS9B;IAED;;OAEG;IACH,cASC;IAED;;;OAGG;IACH,sBAeC;IAED;;;;;;OAMG;IACH,kBA0HC;IAED;;;;OAIG;IACH,qBAkHC;IA2DC,cAAc;IACd;;;;MAIC;IAsCD,cAAc;IACd,2BAA+C;IAYjD;;;OAGG;IACH,gCA8BC;IA7BC;;;OAGG;IAEH,0BAoBE;IAMJ;;;OAGG;IACH,qBAOC;IAFC,cAAc;IACd,mBAAgE;IAGlE;;;OAGG;IACH,wBAEC;IAKG,cAAc;IACd,gBAEE;IAEF,cAAc;IACd,uBAGC;CA2BN"}