mobility-toolbox-js 3.0.0-beta.2 → 3.0.0-beta.21

package/ol/controls/CopyrightControl.d.ts

@@ -0,0 +1,31 @@
+import { MapEvent } from 'ol';
+import Control, { Options } from 'ol/control/Control';
+export type CopyrightControlOptions = Options & {
+    className?: 'string';
+    format?: (copyrights: string[]) => string;
+};
+/**
+ * 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();
+ * map.addControl(control);
+ *
+ *
+ * @see <a href="/example/ol-copyright">Openlayers copyright example</a>
+ *
+ * @extends {ol/control/Control}
+ */
+declare class CopyrightControl extends Control {
+    format: (copyrights: string[]) => string;
+    constructor(options?: CopyrightControlOptions);
+    render({ frameState }: MapEvent): void;
+}
+export default CopyrightControl;

package/ol/controls/CopyrightControl.js

@@ -26,6 +26,11 @@ class CopyrightControl extends Control {
         const element = createDefaultCopyrightElement();
         element.className = options.className || 'mbt-copyright';
         super(Object.assign({ element }, options));
+        this.format =
+            options.format ||
+                ((copyrights) => {
+                    return copyrights === null || copyrights === void 0 ? void 0 : copyrights.join(' | ');
+                });
     }
     render({ frameState }) {
         if (!frameState) {
@@ -35,18 +40,23 @@ class CopyrightControl extends Control {
         let copyrights = [];
         // This code loop comes mainly from ol.
         frameState === null || frameState === void 0 ? void 0 : frameState.layerStatesArray.forEach((layerState) => {
+            var _a;
             const { layer } = layerState;
-            if (frameState &&
-                inView(layerState, frameState.viewState) &&
-                layer &&
-                layer.getSource &&
-                layer.getSource() &&
-                layer.getSource().getAttributions()) {
-                copyrights = copyrights.concat(layer.getSource().getAttributions()(frameState));
+            if (frameState && inView(layerState, frameState.viewState)) {
+                if ((_a = layer === null || layer === void 0 ? void 0 : layer.getSource()) === null || _a === void 0 ? void 0 : _a.getAttributions()) {
+                    copyrights = copyrights.concat(layer.getSource().getAttributions()(frameState));
+                }
+                if (layer === null || layer === void 0 ? void 0 : layer.get('copyrights')) {
+                    let copyProp = layer.get('copyrights');
+                    copyProp = !Array.isArray(copyProp) ? [copyProp] : copyProp;
+                    if (copyProp === null || copyProp === void 0 ? void 0 : copyProp.length) {
+                        copyrights.push(...copyProp);
+                    }
+                }
             }
         });
         const unique = removeDuplicate(copyrights) || [];
-        this.element.innerHTML = unique.join(' | ');
+        this.element.innerHTML = this.format(unique);
     }
 }
 export default CopyrightControl;

package/ol/controls/RoutingControl.d.ts

@@ -0,0 +1,202 @@
+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 { 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;
+    graphs?: RoutingGraph[];
+    modify?: boolean;
+    mot?: string;
+    onRouteError?: () => void;
+    routingApiParams?: RoutingParameters;
+    routingLayer?: VectorLayer<Feature>;
+    snapToClosestStation?: boolean;
+    stopsApiKey?: string;
+    stopsApiUrl?: string;
+    style?: StyleLike;
+    useRawViaPoints?: boolean;
+} & Options;
+export type AbotControllersByGraph = 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();
+ *
+ * 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 {VectorLayer} 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}
+ * @public
+ */
+declare class RoutingControl extends Control {
+    abortControllers: Record<string, AbortController>;
+    api?: RoutingAPI;
+    apiKey?: string;
+    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;
+    routingApiParams?: RoutingParameters;
+    routingLayer?: VectorLayer<Feature>;
+    segments: Feature<LineString>[];
+    snapToClosestStation: boolean;
+    stopsApiKey?: string;
+    stopsApiUrl?: string;
+    useRawViaPoints: boolean;
+    viaPoints: RoutingViaPoint[];
+    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 {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.
+     * @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;