mobility-toolbox-js 2.0.0-beta.33 → 2.0.0-beta.36

package/ol/layers/MaplibreLayer.js

@@ -0,0 +1,35 @@
+import { Map } from 'maplibre-gl';
+import Layer from './Layer';
+import mixin from '../../common/mixins/MapboxLayerMixin';
+import { getMaplibreRender } from '../../common/utils';
+/**
+ * A class representing MaplibreLayer to display on BasicMap
+ *
+ * @example
+ * import { MaplibreLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new MaplibreLayer({
+ *   url: 'https://maps.geops.io/styles/travic_v2/style.json',
+ *   apikey: 'yourApiKey',
+ * });
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+export default class MaplibreLayer extends mixin(Layer) {
+    getOlLayerRender() {
+        return getMaplibreRender(this);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getMapboxMapClass() {
+        return Map;
+    }
+    /**
+     * Create a copy of the MapboxLayer.
+     * @param {Object} newOptions Options to override
+     * @return {MapboxLayer} A MapboxLayer
+     */
+    clone(newOptions) {
+        return new MaplibreLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}

package/ol/layers/RealtimeLayer.d.ts

@@ -33,7 +33,7 @@ declare class RealtimeLayer extends Layer implements UserInteractionsLayerInterf
     /** @ignore */
     renderState: {
         center: number[];
-        zoom: any;
+        zoom: null;
         rotation: number;
     };
     attachToMap(map: any): void;
@@ -113,7 +113,7 @@ declare class RealtimeLayer extends Layer implements UserInteractionsLayerInterf
      * @param {Object} newOptions Options to override
      * @return {RealtimeLayer} A RealtimeLayer
      */
-    clone(newOptions: any): RealtimeLayer;
+    clone(newOptions: Object): RealtimeLayer;
 }
 import Layer from "./Layer";
 //# sourceMappingURL=RealtimeLayer.d.ts.map

package/ol/layers/RealtimeLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RealtimeLayer.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAHgB,8BAA8B,EAC9B,sBAAsB;IAGpC;;;;;OAKG;IACH,sBA2FC;IApFC,cAAc;IACd,aAsEI;IApDQ,0BAA8C;IAI9C,mCAAuD;IAmDnE,iBAAmD;IAInD,cAAc;IACd;;;;MAIC;IAGH,4BAqBC;IANO,iBAAuB;IAgB/B;;;;OAIG;IACH,qDAYC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAiBjB;IAED;;;;OAIG;IACH,4CAuBC;IAPG,uBAAyC;IAS7C;;OAEG;IACH,0BAEC;IAED,+DAMC;IAED;;;;;OAKG;IACH,2BAaC;IAED;;;;;;OAMG;IAEH,2BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;OAIG;IACH,wBAMC;IAED;;;;OAIG;IACH,gBAQC;IAED;;;OAGG;IACH,4BAiBC;IAED;;;;OAIG;IACH,wBAFY,aAAa,CAIxB;CACF"}
+{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RealtimeLayer.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAHgB,8BAA8B,EAC9B,sBAAsB;IAGpC;;;;;OAKG;IACH,sBA2FC;IApFC,cAAc;IACd,aAsEI;IApDQ,0BAA8C;IAI9C,mCAAuD;IAmDnE,iBAAmD;IAInD,cAAc;IACd;;;;MAIC;IAGH,4BAqBC;IANO,iBAAuB;IAgB/B;;;;OAIG;IACH,qDAYC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAiBjB;IAED;;;;OAIG;IACH,4CAuBC;IAPG,uBAAyC;IAS7C;;OAEG;IACH,0BAEC;IAED,+DAMC;IAED;;;;;OAKG;IACH,2BAaC;IAED;;;;;;OAMG;IAEH,2BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;OAIG;IACH,wBAMC;IAED;;;;OAIG;IACH,gBAQC;IAED;;;OAGG;IACH,4BAiBC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,aAAa,CAIxB;CACF"}

package/ol/layers/RealtimeLayer.js

@@ -0,0 +1,294 @@
+import GeoJSON from 'ol/format/GeoJSON';
+import { Layer as OLLayer, Group, Vector as VectorLayer } from 'ol/layer';
+import Source from 'ol/source/Source';
+import { composeCssTransform } from 'ol/transform';
+import { Vector as VectorSource } from 'ol/source';
+import Layer from './Layer';
+import mixin from '../../common/mixins/RealtimeLayerMixin';
+import { fullTrajectoryStyle } from '../styles';
+/** @private */
+const format = new GeoJSON();
+/**
+ * Responsible for loading and display data from a Realtime service.
+ *
+ * @example
+ * import { RealtimeLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new RealtimeLayer({
+ *   url: [yourUrl],
+ *   apiKey: [yourApiKey],
+ * });
+ *
+ *
+ * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ *
+ * @extends {Layer}
+ * @implements {UserInteractionsLayerInterface}
+ * @implements {RealtimeLayerInterface}
+ */
+class RealtimeLayer extends mixin(Layer) {
+    /**
+     * Constructor.
+     *
+     * @param {Object} options
+     * @private
+     */
+    constructor(options = {}) {
+        // We use a group to be able to add custom vector layer in extended class.
+        // For example TrajservLayer use a vectorLayer to display the complete trajectory.
+        super(Object.assign({}, options));
+        /** @ignore */
+        this.olLayer =
+            options.olLayer ||
+                new Group({
+                    layers: [
+                        new VectorLayer({
+                            source: new VectorSource({ features: [] }),
+                            style: (feature, resolution) => {
+                                return (options.fullTrajectoryStyle || fullTrajectoryStyle)(feature, resolution, this.styleOptions);
+                            },
+                        }),
+                        new OLLayer({
+                            source: new Source({}),
+                            render: (frameState) => {
+                                if (!this.container) {
+                                    this.container = document.createElement('div');
+                                    this.container.style.position = 'absolute';
+                                    this.container.style.width = '100%';
+                                    this.container.style.height = '100%';
+                                    this.transformContainer = document.createElement('div');
+                                    this.transformContainer.style.position = 'absolute';
+                                    this.transformContainer.style.width = '100%';
+                                    this.transformContainer.style.height = '100%';
+                                    this.container.appendChild(this.transformContainer);
+                                    this.canvas.style.position = 'absolute';
+                                    this.canvas.style.top = '0';
+                                    this.canvas.style.left = '0';
+                                    this.canvas.style.transformOrigin = 'top left';
+                                    this.transformContainer.appendChild(this.canvas);
+                                }
+                                if (this.renderedViewState) {
+                                    const { center, resolution, rotation } = frameState.viewState;
+                                    const { center: renderedCenter, resolution: renderedResolution, rotation: renderedRotation, } = this.renderedViewState;
+                                    if (renderedResolution / resolution >= 3) {
+                                        // Avoid having really big points when zooming fast.
+                                        const context = this.canvas.getContext('2d');
+                                        context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+                                    }
+                                    else {
+                                        const pixelCenterRendered = this.map.getPixelFromCoordinate(renderedCenter);
+                                        const pixelCenter = this.map.getPixelFromCoordinate(center);
+                                        this.transformContainer.style.transform = composeCssTransform(pixelCenterRendered[0] - pixelCenter[0], pixelCenterRendered[1] - pixelCenter[1], renderedResolution / resolution, renderedResolution / resolution, rotation - renderedRotation, 0, 0);
+                                    }
+                                }
+                                return this.container;
+                            },
+                        }),
+                    ],
+                });
+        // We store the layer used to highlight the full Trajectory
+        this.vectorLayer = this.olLayer.getLayers().item(0);
+        // Options the last render run did happen. If something changes
+        // we have to render again
+        /** @ignore */
+        this.renderState = {
+            center: [0, 0],
+            zoom: null,
+            rotation: 0,
+        };
+    }
+    attachToMap(map) {
+        super.attachToMap(map);
+        if (this.map) {
+            this.olListenersKeys.push(this.map.on(['moveend', 'change:target'], (evt) => {
+                const view = this.map.getView();
+                if (view.getAnimating() || view.getInteracting()) {
+                    return;
+                }
+                const zoom = view.getZoom();
+                // Update the interval between render updates
+                if (this.currentZoom !== zoom) {
+                    this.onZoomEnd(evt);
+                }
+                this.currentZoom = zoom;
+                this.onMoveEnd(evt);
+            }));
+        }
+    }
+    /**
+     * Destroy the container of the tracker.
+     */
+    detachFromMap() {
+        super.detachFromMap();
+        this.container = null;
+    }
+    /**
+     * Detect in the canvas if there is data to query at a specific coordinate.
+     * @param {ol/coordinate~Coordinate}  coordinate The coordinate to test
+     * @returns
+     */
+    hasFeatureInfoAtCoordinate(coordinate) {
+        if (this.map && this.canvas) {
+            const context = this.canvas.getContext('2d');
+            const pixel = this.map.getPixelFromCoordinate(coordinate);
+            return !!context.getImageData(pixel[0] * this.pixelRatio, pixel[1] * this.pixelRatio, 1, 1).data[3];
+        }
+        return false;
+    }
+    /**
+     * Render the trajectories using current map's size, resolution and rotation.
+     * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
+     * @overrides
+     */
+    renderTrajectories(noInterpolate) {
+        const view = this.map.getView();
+        super.renderTrajectories({
+            size: this.map.getSize(),
+            center: this.map.getView().getCenter(),
+            extent: view.calculateExtent(),
+            resolution: view.getResolution(),
+            rotation: view.getRotation(),
+            zoom: view.getZoom(),
+            pixelRatio: this.pixelRatio,
+        }, noInterpolate);
+    }
+    /**
+     * Launch renderTrajectories. it avoids duplicating code in renderTrajectories methhod.
+     * @private
+     * @override
+     */
+    renderTrajectoriesInternal(viewState, noInterpolate) {
+        if (!this.map) {
+            return false;
+        }
+        let isRendered = false;
+        const blockRendering = this.map.getView().getAnimating() || this.map.getView().getInteracting();
+        // Don't render the map when the map is animating or interacting.
+        isRendered = blockRendering
+            ? false
+            : super.renderTrajectoriesInternal(viewState, noInterpolate);
+        // We update the current render state.
+        if (isRendered) {
+            this.renderedViewState = Object.assign({}, viewState);
+            if (this.transformContainer) {
+                this.transformContainer.style.transform = '';
+            }
+        }
+        return isRendered;
+    }
+    /**
+     * Return the delay in ms before the next rendering.
+     */
+    getRefreshTimeInMs() {
+        return super.getRefreshTimeInMs(this.map.getView().getZoom());
+    }
+    getFeatureInfoAtCoordinate(coordinate, options = {}) {
+        const resolution = this.map.getView().getResolution();
+        return super.getFeatureInfoAtCoordinate(coordinate, Object.assign({ resolution }, options));
+    }
+    /**
+     * On move end we update the websocket with the new bbox.
+     *
+     * @private
+     * @override
+     */
+    onMoveEnd() {
+        if (this.visible && this.isUpdateBboxOnMoveEnd) {
+            this.setBbox();
+        }
+        if (this.visible &&
+            this.isUpdateBboxOnMoveEnd &&
+            this.userClickInteractions &&
+            this.selectedVehicleId) {
+            this.highlightTrajectory(this.selectedVehicleId);
+        }
+    }
+    /**
+     * Function called on moveend event only when the zoom has changed.
+     *
+     * @param {ol/MapEvent~MapEvent} evt Moveend event.
+     * @private
+     * @override
+     */
+    // eslint-disable-next-line no-unused-vars
+    onZoomEnd(evt) {
+        super.onZoomEnd(evt);
+    }
+    /**
+     * Update the cursor style when hovering a vehicle.
+     *
+     * @private
+     * @override
+     */
+    onFeatureHover(features, layer, coordinate) {
+        super.onFeatureHover(features, layer, coordinate);
+        this.map.getTargetElement().style.cursor = features.length
+            ? 'pointer'
+            : 'auto';
+    }
+    /**
+     * Display the complete trajectory of the vehicle.
+     *
+     * @private
+     * @override
+     */
+    onFeatureClick(features, layer, coordinate) {
+        super.onFeatureClick(features, layer, coordinate);
+        if (!features.length && this.vectorLayer) {
+            this.vectorLayer.getSource().clear();
+        }
+        if (this.selectedVehicleId) {
+            this.highlightTrajectory(this.selectedVehicleId);
+        }
+    }
+    /**
+     * Remove the trajectory form the list if necessary.
+     *
+     * @private
+     */
+    purgeTrajectory(trajectory, extent, zoom) {
+        return super.purgeTrajectory(trajectory, extent || this.map.getView().calculateExtent(), zoom || this.map.getView().getZoom());
+    }
+    /**
+     * Send the current bbox to the websocket
+     *
+     * @private
+     */
+    setBbox(extent, zoom) {
+        let newExtent = extent;
+        let newZoom = zoom;
+        if (!newExtent && this.isUpdateBboxOnMoveEnd) {
+            newExtent = extent || this.map.getView().calculateExtent();
+            newZoom = Math.floor(this.map.getView().getZoom());
+        }
+        super.setBbox(newExtent, newZoom);
+    }
+    /**
+     * Highlight the trajectory of journey.
+     * @private
+     */
+    highlightTrajectory(id) {
+        this.api
+            .getFullTrajectory(id, this.mode, this.generalizationLevel)
+            .then((fullTrajectory) => {
+            const vectorSource = this.vectorLayer.getSource();
+            vectorSource.clear();
+            if (!fullTrajectory ||
+                !fullTrajectory.features ||
+                !fullTrajectory.features.length) {
+                return;
+            }
+            const features = format.readFeatures(fullTrajectory);
+            this.vectorLayer.getSource().addFeatures(features);
+        });
+    }
+    /**
+     * Create a copy of the RealtimeLayer.
+     * @param {Object} newOptions Options to override
+     * @return {RealtimeLayer} A RealtimeLayer
+     */
+    clone(newOptions) {
+        return new RealtimeLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}
+export default RealtimeLayer;

package/ol/layers/RoutingLayer.d.ts

@@ -11,14 +11,14 @@ declare class RoutingLayer extends Layer {
      * @param {Object} [options]
      * @param {ol/style/Style~StyleLike} [options.style] Style to be used for routes, uses (ol/StyleLike) [https://openlayers.org/en/latest/apidoc/module-ol_style_Style.html#~StyleLike] instances
      */
-    constructor(options?: any);
+    constructor(options?: Object | undefined);
     olLayer: any;
     /**
      * Create a copy of the RoutingLayer.
      * @param {Object} newOptions Options to override
      * @return {RoutingLayer} A RoutingLayer
      */
-    clone(newOptions: any): RoutingLayer;
+    clone(newOptions: Object): RoutingLayer;
 }
 import Layer from "./Layer";
 //# sourceMappingURL=RoutingLayer.d.ts.map

package/ol/layers/RoutingLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RoutingLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RoutingLayer.js"],"names":[],"mappings":";AA8DA;;;;;GAKG;AACH;IACE;;;;OAIG;IACH,2BASC;IANC,aAKI;IAGN;;;;OAIG;IACH,wBAFY,YAAY,CAIvB;CACF"}
+{"version":3,"file":"RoutingLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RoutingLayer.js"],"names":[],"mappings":";AA8DA;;;;;GAKG;AACH;IACE;;;;OAIG;IACH,0CASC;IANC,aAKI;IAGN;;;;OAIG;IACH,kBAHW,MAAM,GACL,YAAY,CAIvB;CACF"}

package/ol/layers/RoutingLayer.js

@@ -0,0 +1,84 @@
+import { Circle, Fill, Stroke, Style } from 'ol/style';
+import { Vector as VectorSource } from 'ol/source';
+import { Vector } from 'ol/layer';
+import Layer from './Layer';
+/** @private */
+const circleStyle = new Circle({
+    radius: 6,
+    fill: new Fill({
+        color: [255, 0, 0, 1],
+    }),
+    stroke: new Stroke({
+        color: [0, 0, 0, 1],
+        width: 1,
+    }),
+});
+/** @private */
+const blackBorder = new Style({
+    stroke: new Stroke({
+        color: [0, 0, 0, 1],
+        width: 5,
+    }),
+});
+/** @private */
+const redLine = new Style({
+    image: circleStyle,
+    stroke: new Stroke({
+        color: [255, 0, 0, 1],
+        width: 3,
+    }),
+});
+/** @private */
+const dashedRedLine = new Style({
+    image: circleStyle,
+    stroke: new Stroke({
+        color: [255, 0, 0, 1],
+        width: 3,
+        lineDash: [1, 10],
+    }),
+});
+/** @private */
+const defaultStyleFunction = (feature, resolution) => {
+    const minResolution = feature.get('minResolution');
+    const maxResolution = feature.get('maxResolution');
+    const inRange = resolution <= minResolution && resolution > maxResolution;
+    if (minResolution && maxResolution && !inRange) {
+        return null;
+    }
+    const mot = feature.get('mot');
+    if (mot !== 'foot') {
+        return [blackBorder, redLine];
+    }
+    return [dashedRedLine];
+};
+/**
+ * A class use to display vector data.
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+class RoutingLayer extends Layer {
+    /**
+     * Constructor.
+     * @param {Object} [options]
+     * @param {ol/style/Style~StyleLike} [options.style] Style to be used for routes, uses (ol/StyleLike) [https://openlayers.org/en/latest/apidoc/module-ol_style_Style.html#~StyleLike] instances
+     */
+    constructor(options = {}) {
+        super(options);
+        this.olLayer =
+            options.olLayer ||
+                new Vector({
+                    source: new VectorSource(),
+                    style: options.style || defaultStyleFunction,
+                });
+    }
+    /**
+     * Create a copy of the RoutingLayer.
+     * @param {Object} newOptions Options to override
+     * @return {RoutingLayer} A RoutingLayer
+     */
+    clone(newOptions) {
+        return new RoutingLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}
+export default RoutingLayer;

package/ol/layers/VectorLayer.d.ts

@@ -17,7 +17,7 @@ declare class VectorLayer extends Layer {
      * @param {Object} newOptions Options to override
      * @return {VectorLayer} A VectorLayer
      */
-    clone(newOptions: any): VectorLayer;
+    clone(newOptions: Object): VectorLayer;
 }
 import Layer from "./Layer";
 //# sourceMappingURL=VectorLayer.d.ts.map

package/ol/layers/VectorLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/VectorLayer.js"],"names":[],"mappings":";AAEA;;;;;GAKG;AACH;IACE;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAkB/B;IAED;;;;OAIG;IACH,wBAFY,WAAW,CAItB;CACF"}
+{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/VectorLayer.js"],"names":[],"mappings":";AAEA;;;;;GAKG;AACH;IACE;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAkB/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,WAAW,CAItB;CACF"}

package/ol/layers/VectorLayer.js

@@ -0,0 +1,38 @@
+import Layer from './Layer';
+/**
+ * A class use to display vector data.
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+class VectorLayer extends Layer {
+    /**
+     * Request feature information for a given coordinate.
+     * @param {ol/coordinate~Coordinate} coordinate the coordinate to request the information at.
+     * @return {Promise<FeatureInfo>} Promise with features, layer and coordinate.
+     */
+    getFeatureInfoAtCoordinate(coordinate) {
+        let features = [];
+        if (this.map) {
+            const pixel = this.map.getPixelFromCoordinate(coordinate);
+            features = this.map.getFeaturesAtPixel(pixel, {
+                layerFilter: (l) => l === this.olLayer,
+                hitTolerance: this.hitTolerance,
+            });
+        }
+        return Promise.resolve({
+            features,
+            layer: this,
+            coordinate,
+        });
+    }
+    /**
+     * Create a copy of the VectorLayer.
+     * @param {Object} newOptions Options to override
+     * @return {VectorLayer} A VectorLayer
+     */
+    clone(newOptions) {
+        return new VectorLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}
+export default VectorLayer;

package/ol/layers/WMSLayer.d.ts

@@ -31,7 +31,7 @@ declare class WMSLayer extends Layer {
      * @param {Object} newOptions Options to override
      * @return {WMSLayer} A WMSLayer
      */
-    clone(newOptions: any): WMSLayer;
+    clone(newOptions: Object): WMSLayer;
 }
 import Layer from "./Layer";
 import GeoJSON from "ol/format/GeoJSON";

package/ol/layers/WMSLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WMSLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/WMSLayer.js"],"names":[],"mappings":";AAGA;;;;;GAKG;AACH;IACE;;OAEG;IACH,0BAOC;IAJC,cAAc;IACd,iCAA4C;IAC5C,cAAc;IACd,gBAA2B;IAG7B;;;;OAIG;IACH,kCAaC;IAED;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAsB/B;IAED;;;;OAIG;IACH,wBAFY,QAAQ,CAInB;CACF"}
+{"version":3,"file":"WMSLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/WMSLayer.js"],"names":[],"mappings":";AAGA;;;;;GAKG;AACH;IACE;;OAEG;IACH,0BAOC;IAJC,cAAc;IACd,iCAA4C;IAC5C,cAAc;IACd,gBAA2B;IAG7B;;;;OAIG;IACH,kCAaC;IAED;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAsB/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,QAAQ,CAInB;CACF"}

package/ol/layers/WMSLayer.js

@@ -0,0 +1,72 @@
+import GeoJSON from 'ol/format/GeoJSON';
+import Layer from './Layer';
+/**
+ * Class use to display a WMS layer.
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+class WMSLayer extends Layer {
+    /**
+     * @override
+     */
+    constructor(options = {}) {
+        super(options);
+        /** @ignore */
+        this.abortController = new AbortController();
+        /** @ignore */
+        this.format = new GeoJSON();
+    }
+    /**
+     * Get features infos' Url.
+     * @param {ol/coordinate~Coordinate} coord
+     * @return {ol/layer/Layer~Layer}
+     */
+    getFeatureInfoUrl(coord) {
+        const projection = this.map.getView().getProjection();
+        const resolution = this.map.getView().getResolution();
+        if (this.olLayer.getSource().getFeatureInfoUrl) {
+            return this.olLayer
+                .getSource()
+                .getFeatureInfoUrl(coord, resolution, projection, {
+                info_format: 'application/json',
+                query_layers: this.olLayer.getSource().getParams().layers,
+            });
+        }
+        return false;
+    }
+    /**
+     * Request feature information for a given coordinate.
+     * @param {ol/coordinate~Coordinate} coordinate to request the information at.
+     * @return {Promise<FeatureInfo>} Promise with features, layer and coordinate.
+     */
+    getFeatureInfoAtCoordinate(coordinate) {
+        this.abortController.abort();
+        this.abortController = new AbortController();
+        const { signal } = this.abortController;
+        return fetch(this.getFeatureInfoUrl(coordinate), { signal })
+            .then((resp) => resp.json())
+            .then((r) => r.features)
+            .then((data) => ({
+            layer: this,
+            coordinate,
+            features: data.map((d) => this.format.readFeature(d)),
+        }))
+            .catch(() => 
+        // resolve an empty feature array something fails
+        Promise.resolve({
+            features: [],
+            coordinate,
+            layer: this,
+        }));
+    }
+    /**
+     * Create a copy of the WMSLayer.
+     * @param {Object} newOptions Options to override
+     * @return {WMSLayer} A WMSLayer
+     */
+    clone(newOptions) {
+        return new WMSLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}
+export default WMSLayer;

package/ol/layers/index.js

@@ -0,0 +1,8 @@
+export { default as Layer } from './Layer';
+export { default as MapboxLayer } from './MapboxLayer';
+export { default as MaplibreLayer } from './MaplibreLayer';
+export { default as MapboxStyleLayer } from './MapboxStyleLayer';
+export { default as RoutingLayer } from './RoutingLayer';
+export { default as RealtimeLayer } from './RealtimeLayer';
+export { default as VectorLayer } from './VectorLayer';
+export { default as WMSLayer } from './WMSLayer';

package/ol/styles/fullTrajectoryDelayStyle.js

@@ -0,0 +1,33 @@
+import { Style, Fill, Stroke, Circle } from 'ol/style';
+/** @private */
+const stroke = new Style({
+    zIndex: 2,
+    image: new Circle({
+        radius: 5,
+        fill: new Fill({
+            color: '#000000',
+        }),
+    }),
+    stroke: new Stroke({
+        color: '#000000',
+        width: 6,
+    }),
+});
+/** @private */
+const fill = new Style({
+    zIndex: 3,
+    image: new Circle({
+        radius: 4,
+        fill: new Fill({
+            color: '#a0a0a0',
+        }),
+    }),
+    stroke: new Stroke({
+        color: '#a0a0a0',
+        width: 4,
+    }),
+});
+const fullTrajectoryDelaystyle = () => {
+    return [stroke, fill];
+};
+export default fullTrajectoryDelaystyle;