mobility-toolbox-js 3.0.0-beta.8 → 3.0.0

package/ol/controls/CopyrightControl.d.ts

@@ -0,0 +1,39 @@
+import { MapEvent } from 'ol';
+import Control, { Options } from 'ol/control/Control';
+export type CopyrightControlOptions = {
+    className?: 'string';
+    format?: (copyrights: string[]) => string;
+} & Options;
+/**
+ * Display layer's copyrights. Adding the possibility to format them as you wish.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { CopyrightControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ *
+ * const control = new CopyrightControl();
+ * map.addControl(control);
+ *
+ *
+ * @see <a href="/example/ol-realtime>OpenLayers Realtime layer example</a>
+ *
+ * @extends {ol/control/Control~Control}
+ *
+ */
+declare class CopyrightControl extends Control {
+    format: (copyrights: string[]) => string;
+    /**
+     * Constructor.
+     *
+     * @param {Object} options
+     * @param {Function} format Function used to format the list of copyrights available to a single string. By default join all the copyrights with a |.
+     * @public
+     */
+    constructor(options?: CopyrightControlOptions);
+    render({ frameState }: MapEvent): void;
+}
+export default CopyrightControl;

package/ol/controls/CopyrightControl.js

@@ -1,9 +1,9 @@
-import { inView } from 'ol/layer/Layer';
 import Control from 'ol/control/Control';
-import removeDuplicate from '../../common/utils/removeDuplicate';
+import { inView } from 'ol/layer/Layer';
 import createDefaultCopyrightElement from '../../common/utils/createDefaultCopyrightElt';
+import removeDuplicate from '../../common/utils/removeDuplicate';
 /**
- * Display layer's copyrights.
+ * Display layer's copyrights. Adding the possibility to format them as you wish.
  *
  * @example
  * import { Map } from 'ol';
@@ -17,11 +17,19 @@ import createDefaultCopyrightElement from '../../common/utils/createDefaultCopyr
  * map.addControl(control);
  *
  *
- * @see <a href="/example/ol-copyright">Openlayers copyright example</a>
+ * @see <a href="/example/ol-realtime>OpenLayers Realtime layer example</a>
+ *
+ * @extends {ol/control/Control~Control}
  *
- * @extends {ol/control/Control}
  */
 class CopyrightControl extends Control {
+    /**
+     * Constructor.
+     *
+     * @param {Object} options
+     * @param {Function} format Function used to format the list of copyrights available to a single string. By default join all the copyrights with a |.
+     * @public
+     */
     constructor(options = {}) {
         const element = createDefaultCopyrightElement();
         element.className = options.className || 'mbt-copyright';

package/ol/controls/RoutingControl.d.ts

@@ -0,0 +1,213 @@
+import { Feature } from 'ol';
+import Control, { Options } from 'ol/control/Control';
+import { EventsKey } from 'ol/events';
+import { GeoJSON } from 'ol/format';
+import { Geometry, LineString, Point } from 'ol/geom';
+import { Modify } from 'ol/interaction';
+import { ModifyEvent } from 'ol/interaction/Modify';
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import { RoutingAPI } from '../../api';
+import type { Map, MapBrowserEvent } from 'ol';
+import type { Coordinate } from 'ol/coordinate';
+import type { StyleLike } from 'ol/style/Style';
+import type { RoutingGraph, RoutingMot, RoutingParameters, RoutingViaPoint } from '../../types';
+export type RoutingControlOptions = {
+    active?: boolean;
+    apiKey?: string;
+    apiParams?: RoutingParameters;
+    graphs?: RoutingGraph[];
+    modify?: boolean;
+    mot?: string;
+    onRouteError?: () => void;
+    routingLayer?: VectorLayer<VectorSource>;
+    snapToClosestStation?: boolean;
+    stopsApiKey?: string;
+    stopsApiUrl?: string;
+    style?: StyleLike;
+    useRawViaPoints?: boolean;
+} & Options;
+export type AbortControllersByGraph = Record<string, AbortController>;
+/**
+ * This OpenLayers control allows the user to add and modifiy via points to
+ * a map and request a route from the [geOps Routing API](https://developer.geops.io/apis/routing/).
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { RoutingControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map'
+ * });
+ *
+ * const control = new RoutingControl();
+ *
+ * map.addControl(control);
+ *
+ * @classproperty {string} mot - Mean of transport to be used for routing.
+ * @classproperty {VectorLayer} routingLayer - Layer for adding route features.
+ * @classproperty {boolean} loading - True if the control is requesting the backend.
+ *
+ * @see <a href="/example/ol-routing">Openlayers routing example</a>
+ *
+ * @extends {ol/control/Control~Control}
+ *
+ * @public
+ */
+declare class RoutingControl extends Control {
+    abortControllers: Record<string, AbortController>;
+    api?: RoutingAPI;
+    apiKey?: string;
+    apiParams?: RoutingParameters;
+    cacheStationData: Record<string, Coordinate>;
+    format: GeoJSON;
+    graphs: RoutingGraph[];
+    graphsResolutions?: [number, number][];
+    initialRouteDrag?: {
+        oldRoute?: Feature<LineString>;
+        segmentIndex?: number;
+        viaPoint?: Feature<Point>;
+    };
+    map?: Map;
+    modifyInteraction?: Modify;
+    onMapClickKey?: EventsKey;
+    onRouteError: (error?: Error, control?: RoutingControl) => void;
+    routingLayer?: VectorLayer<VectorSource>;
+    segments: Feature<LineString>[];
+    snapToClosestStation: boolean;
+    stopsApiKey?: string;
+    stopsApiUrl?: string;
+    useRawViaPoints: boolean;
+    viaPoints: RoutingViaPoint[];
+    /**
+     * Constructor.
+     *
+     * @param {Object} options
+     * @param {string} options.apiKey Access key for [geOps APIs](https://developer.geops.io/).
+     * @param {Object} options.apiParams Request parameters. See [geOps Routing API documentation](https://developer.geops.io/apis/routing/).
+     * @param {Array.<Array<graph="osm", minZoom=0, maxZoom=99>>} [options.graphs=[['osm', 0, 99]]] - 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]]".
+     * @param {string} [options.mot="bus"] Mean of transport to be used for routing.
+     * @param {function} options.onRouteError Callback on request errors.
+     * @param {VectorLayer} [options.routingLayer=new VectorLayer()] Vector layer for adding route features.
+     * @param {boolean} [options.snapToClosestStation=false] If true, the routing will snap the coordinate to the closest station. Default to false.
+     * @param {StyleLike} options.style Style of the default vector layer.
+     * @param {boolean} [options.useRawViaPoints=fale] Experimental property. If 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.
+     * @param {string} [options.url='https://api.geops.io/routing/v1/'] [geOps Realtime API](https://developer.geops.io/apis/realtime/) url.
+     * @public
+     */
+    constructor(options?: RoutingControlOptions);
+    /**
+     * Calculate at which resolutions corresponds each generalizations.
+     *
+     * @private
+     */
+    static getGraphsResolutions(graphs: RoutingGraph[], map: Map): [number, number][];
+    /**
+     * Aborts viapoint and route requests
+     * @private
+     */
+    abortRequests(): void;
+    activate(): void;
+    /**
+     * Add click listener to map.
+     * @private
+     */
+    addListeners(): void;
+    /**
+     * 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 {string | Coordinate} coordinatesOrString Array of coordinates or a string representing a station
+     * @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.
+     * @public
+     */
+    addViaPoint(coordinatesOrString: RoutingViaPoint, index?: number, overwrite?: number): void;
+    /**
+     * Define a default element.
+     *
+     * @private
+     */
+    createDefaultElement(): void;
+    /**
+     * Create the interaction used to modify vertexes of features.
+     * @private
+     */
+    createModifyInteraction(): void;
+    deactivate(): void;
+    /**
+     * 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
+     */
+    drawRoute(): Promise<void | Feature<Geometry>> | Promise<Feature<Geometry> | null> | Promise<(void | never[])[]> | null;
+    /**
+     * Draw a via point. This function can parse all the possibilitiies
+     *
+     * @private
+     */
+    drawViaPoint(viaPoint: RoutingViaPoint, idx: number, abortController: AbortController): Promise<void | Feature<Geometry>> | Promise<Feature<Geometry> | null>;
+    /**
+     * Activet7deactivate the control when activ eproperty changes
+     * @private
+     */
+    onActiveChange(): void;
+    /**
+     * 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
+     */
+    onMapClick(evt: MapBrowserEvent<MouseEvent>): void;
+    /**
+     * 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
+     */
+    onModifyEnd(evt: ModifyEvent): void | Promise<never>;
+    /**
+     * Used on start of the modify interaction. Stores relevant data
+     * in this.initialRouteDrag object
+     * @private
+     */
+    onModifyStart(evt: ModifyEvent): void;
+    /**
+     * Remove click listener from map.
+     * @private
+     */
+    removeListeners(): 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.
+     * @public
+     */
+    removeViaPoint(index?: number): void;
+    render(): void;
+    /**
+     * Removes all viaPoints, clears the source and triggers a change event
+     * @public
+     */
+    reset(): void;
+    setMap(map: Map): void;
+    /**
+     * Replaces the current viaPoints with a new coordinate array.
+     * @param {Array<Array<number>>} coordinateArray Array of nested coordinates
+     * @public
+     */
+    setViaPoints(coordinateArray: Coordinate[]): void;
+    get active(): boolean;
+    set active(newValue: boolean);
+    get loading(): boolean;
+    set loading(newValue: boolean);
+    get modify(): any;
+    set modify(newValue: any);
+    get mot(): RoutingMot;
+    set mot(newValue: RoutingMot);
+}
+export default RoutingControl;