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

package/common/styles/index.d.ts

@@ -0,0 +1,4 @@
+export { default as realtimeDefaultStyle } from "./realtimeDefaultStyle";
+export { default as realtimeDelayStyle } from "./realtimeDelayStyle";
+export { default as realtimeSimpleStyle } from "./realtimeSimpleStyle";
+export * from "./realtimeDefaultStyle";

package/common/styles/realtimeDefaultStyle.d.ts

@@ -0,0 +1,36 @@
+import type { RealtimeStyleFunction } from '../../types';
+/**
+ * Draw circle delay background
+ *
+ * @private
+ */
+export declare const getDelayBgCanvas: (origin: number, radius: number, color: string) => import("../../types").AnyCanvas | null;
+/**
+ * Draw delay text
+ *
+ * @private
+ */
+export declare const getDelayTextCanvas: (text: string, fontSize: number, font: string, delayColor: string, delayOutlineColor?: string, pixelRatio?: number) => import("../../types").AnyCanvas | null;
+/**
+ * Draw colored circle with black border
+ *
+ * @private
+ */
+export declare const getCircleCanvas: (origin: number, radius: number, color: string, hasStroke: boolean, hasDash: boolean, pixelRatio: number) => import("../../types").AnyCanvas | null;
+/**
+ * Draw text in the circle
+ *
+ * @private
+ */
+export declare const getTextCanvas: (text: string, origin: number, textSize: number, fillColor: string, strokeColor: string, hasStroke: boolean, pixelRatio: number, getTextFont: (fontSize: number, text?: string) => string) => import("../../types").AnyCanvas | null;
+/**
+ * A tracker style that take in account the delay.
+ *
+ * @param {RealtimeTrajectory} trajectory The trajectory to render.
+ * @param {ViewState} viewState The view state of the map.
+ * @param {RealtimeStyleOptions} options Some options to change the rendering
+ * @return a canvas
+ * @private
+ */
+declare const realtimeDefaultStyle: RealtimeStyleFunction;
+export default realtimeDefaultStyle;

package/common/styles/realtimeDefaultStyle.js

@@ -141,11 +141,11 @@ const cache = {};
  * @private
  */
 const realtimeDefaultStyle = (trajectory, viewState, options) => {
-    const { hoverVehicleId, selectedVehicleId, useDelayStyle, delayOutlineColor = '#000', delayDisplay = 300000, getRadius = () => 0, getBgColor = () => '#000', getDelayColor = () => '#000', getDelayText = () => null, getDelayFont = (fontSize) => `bold ${fontSize}px arial, sans-serif`, getText = (text) => text, getTextFont = (fontSize) => `bold ${fontSize}px arial, sans-serif`, getTextColor = () => '#000', getTextSize = () => 14, getMaxRadiusForText = () => 10, getMaxRadiusForStrokeAndDelay = () => 7, } = options;
-    const { zoom, pixelRatio = 1 } = viewState;
+    const { delayDisplay = 300000, delayOutlineColor = '#000', getBgColor = () => '#000', getDelayColor = () => '#000', getDelayFont = (fontSize) => `bold ${fontSize}px arial, sans-serif`, getDelayText = () => null, getMaxRadiusForStrokeAndDelay = () => 7, getMaxRadiusForText = () => 10, getRadius = () => 0, getText = (text) => text, getTextColor = () => '#000', getTextFont = (fontSize) => `bold ${fontSize}px arial, sans-serif`, getTextSize = () => 14, hoverVehicleId, selectedVehicleId, useDelayStyle, } = options;
+    const { pixelRatio = 1, zoom } = viewState;
     let { type } = trajectory.properties;
-    const { train_id: id, line, delay, state, operator_provides_realtime_journey: operatorProvidesRealtime, } = trajectory.properties;
-    let { name, text_color: textColor, color } = line || {};
+    const { delay, line, operator_provides_realtime_journey: operatorProvidesRealtime, state, train_id: id, } = trajectory.properties;
+    let { color, name, text_color: textColor } = line || {};
     name = getText(name);
     const cancelled = state === 'JOURNEY_CANCELLED';
     if (!type) {
@@ -157,10 +157,10 @@ const realtimeDefaultStyle = (trajectory, viewState, options) => {
     if (!textColor) {
         textColor = '#000000';
     }
-    if (color && color[0] !== '#') {
+    if (color && !color.startsWith('#')) {
         color = `#${color}`;
     }
-    if (textColor[0] !== '#') {
+    if (!textColor.startsWith('#')) {
         textColor = `#${textColor}`;
     }
     const z = Math.min(Math.floor(zoom || 1), 16);

package/common/styles/realtimeDelayStyle.d.ts

@@ -0,0 +1,12 @@
+import type { RealtimeStyleFunction } from '../../types';
+/**
+ * A tracker style that display the delay as backgroundColor.
+ *
+ * @param {*} trajectory The trajectory to render.
+ * @param {*} viewState The view state of the map.
+ * @param {*} options Some options to change the rendering
+ * @return a canvas
+ * @private
+ */
+declare const realtimeDelayStyle: RealtimeStyleFunction;
+export default realtimeDelayStyle;

package/common/styles/realtimeHeadingStyle.d.ts

@@ -0,0 +1,12 @@
+import type { RealtimeStyleFunction } from '../../types';
+/**
+ * A tracker style that take in account the delay.
+ *
+ * @param {RealtimeTrajectory} trajectory The trajectory to render.
+ * @param {ViewState} viewState The view state of the map.
+ * @param {RealtimeStyleOptions} options Some options to change the rendering
+ * @return a canvas
+ * @private
+ */
+declare const realtimeHeadingStyle: RealtimeStyleFunction;
+export default realtimeHeadingStyle;

package/common/styles/realtimeHeadingStyle.js

@@ -67,9 +67,8 @@ const getBufferArrowCanvas = (canvas, fillColor, rotation) => {
  * @private
  */
 const realtimeHeadingStyle = (trajectory, viewState, options) => {
-    var _a, _b;
-    // @ts-ignore
-    const { rotation, type, line } = trajectory.properties;
+    // @ts-expect-error improve types
+    const { line, rotation, type } = trajectory.properties;
     const { color } = line || {};
     const canvas = realtimeDefaultStyle(trajectory, viewState, options);
     if (canvas && rotation !== null) {
@@ -78,8 +77,9 @@ const realtimeHeadingStyle = (trajectory, viewState, options) => {
         if (bufferArrow) {
             const bufferSize = (bufferArrow.width - canvas.width) / 2;
             const vehicleWithArrow = createCanvas(bufferArrow.width, bufferArrow.height);
-            (_a = vehicleWithArrow === null || vehicleWithArrow === void 0 ? void 0 : vehicleWithArrow.getContext('2d')) === null || _a === void 0 ? void 0 : _a.drawImage(bufferArrow, 0, 0, bufferArrow.width, bufferArrow.height);
-            (_b = vehicleWithArrow === null || vehicleWithArrow === void 0 ? void 0 : vehicleWithArrow.getContext('2d')) === null || _b === void 0 ? void 0 : _b.drawImage(canvas, bufferSize, bufferSize, canvas.width, canvas.height);
+            const context = vehicleWithArrow === null || vehicleWithArrow === void 0 ? void 0 : vehicleWithArrow.getContext('2d');
+            context === null || context === void 0 ? void 0 : context.drawImage(bufferArrow, 0, 0, bufferArrow.width, bufferArrow.height);
+            context === null || context === void 0 ? void 0 : context.drawImage(canvas, bufferSize, bufferSize, canvas.width, canvas.height);
             return vehicleWithArrow;
         }
     }

package/common/styles/realtimeSimpleStyle.d.ts

@@ -0,0 +1,4 @@
+import type { RealtimeStyleFunction } from '../../types';
+/** @private */
+declare const realtimeSimpleStyle: RealtimeStyleFunction;
+export default realtimeSimpleStyle;

package/common/typedefs.d.ts

@@ -0,0 +1,219 @@
+export default dummy;
+export type FilterFunction = Function;
+export type SortFunction = Function;
+export type getMotsByZoomFunction = Function;
+export type ViewState = {
+    /**
+     * A time in ms.
+     */
+    time: number | undefined;
+    /**
+     * A center in mercator coordinate.
+     */
+    center: number[2] | undefined;
+    /**
+     * An Extent in mercator coordinates.
+     */
+    extent: number[4];
+    /**
+     * A size ([width, height]).
+     */
+    size: number[2];
+    /**
+     * A rotation in radians.
+     */
+    rotation: number;
+    /**
+     * A resolution.
+     */
+    resolution: number;
+    /**
+     * A zoom level.
+     */
+    zoom: number;
+    /**
+     * A pixel ratio.
+     */
+    pixelRatio: number | undefined;
+};
+export type FeatureInfo = {
+    /**
+     * A layer.
+     */
+    layer: Layer;
+    /**
+     * An array of features.
+     */
+    features: Feature[];
+    /**
+     * The coordinate where to find the featue.
+     */
+    coordinate: number[2];
+};
+export type MaplibreLayerOptions = {
+    /**
+     * Access key for [geOps apis](https://developer.geops.io/).
+     */
+    apiKey: string;
+    /**
+     * geOps Maps api key name.
+     */
+    apiKeyName: string;
+    /**
+     * Maplibre map options.
+     */
+    mapLibreOptions: maplibregl.MapOptions;
+    /**
+     * geOps Maps api style.
+     */
+    style: string;
+    /**
+     * geOps Maps api url.
+     */
+    url: string;
+};
+export type ControlCommonOptions = {
+    /**
+     * Whether the control is active or not.
+     */
+    active?: boolean | undefined;
+    /**
+     * The HTML element used to render the control.
+     */
+    element: HTMLElement;
+    /**
+     * The HTML element where to render the element property. Default is the map's element.
+     */
+    target: HTMLElement;
+    /**
+     * Render function called whenever the control needs to be rerendered.
+     */
+    render: Function;
+};
+export type LayerCommonOptions = {
+    /**
+     * Identifier of the layer. Must be unique.
+     */
+    key: string;
+    /**
+     * Name of the layer.
+     */
+    name: string;
+    /**
+     * Group of the layer.
+     */
+    group: string;
+    /**
+     * List of copyrights.
+     */
+    copyrights: string[];
+    /**
+     * List of children layers.
+     */
+    children: Layer[];
+    /**
+     * Define if the layer is currently display on the map.
+     */
+    visible: boolean;
+    /**
+     * Define if the layer is currently display on the map but can't be seen (extent, zoom ,data restrictions).
+     */
+    disabled: boolean;
+    /**
+     * Hit-detection tolerance in css pixels. Pixels inside the radius around the given position will be checked for features.
+     */
+    hittolerance: number;
+    /**
+     * - Custom properties.
+     */
+    properties: Object;
+    /**
+     * - The map used to display the layer.
+     */
+    map: AnyMap;
+};
+export type VehiclePosition = {
+    /**
+     * Coordinate of the vehicle position in Mercator .
+     */
+    coord: number[2];
+    /**
+     * An angle in radians representing the direction (from the true north) towards which the vehicle is facing.
+     */
+    rotation: number;
+};
+/**
+ * /Map~Map|maplibregl.Map} AnyMap
+ */
+type dummy = ol;
+/**
+ * @typedef {function} FilterFunction
+ * @param {Vehicle} vehicle Vehicle to filter.
+ * @returns boolean
+ */
+/**
+ * @typedef {function} SortFunction
+ * @param {any} a Object a to compare.
+ * @param {any} b Object b to compare.
+ * @returns number
+ */
+/**
+ * @typedef {function} getMotsByZoomFunction
+ * @param {number} zoom Curent zoom level.
+ * @param {RealtimeMot[][]} motsByZoom Default array of mots by zoom.
+ * @returns number
+ */
+/**
+ * @typedef {Object} ViewState
+ * @property {number|undefined} time A time in ms.
+ * @property {number[2]|undefined} center A center in mercator coordinate.
+ * @property {number[4]} extent An Extent in mercator coordinates.
+ * @property {number[2]} size A size ([width, height]).
+ * @property {number} rotation A rotation in radians.
+ * @property {number} resolution A resolution.
+ * @property {number} zoom A zoom level.
+ * @property {number|undefined} pixelRatio A pixel ratio.
+ */
+/**
+ * @typedef {Object} FeatureInfo
+ * @property {Layer} layer A layer.
+ * @property {Feature[]} features  An array of features.
+ * @property {number[2]} coordinate The coordinate where to find the featue.
+ */
+/**
+ * @typedef {ol/Map~Map|maplibregl.Map} AnyMap
+ */
+/**
+ * @typedef {Object} MaplibreLayerOptions
+ * @property {string} apiKey Access key for [geOps apis](https://developer.geops.io/).
+ * @property {string} apiKeyName geOps Maps api key name.
+ * @property {maplibregl.MapOptions} options.mapLibreOptions Maplibre map options.
+ * @property {string} style geOps Maps api style.
+ * @property {string} url geOps Maps api url.
+ */
+/**
+ * @typedef {Object} ControlCommonOptions
+ * @property {boolean} [active = true] Whether the control is active or not.
+ * @property {HTMLElement} element The HTML element used to render the control.
+ * @property {HTMLElement} target The HTML element where to render the element property. Default is the map's element.
+ * @property {function} render Render function called whenever the control needs to be rerendered.
+ */
+/**
+ * @typedef {Object} LayerCommonOptions
+ * @property {string!} key Identifier of the layer. Must be unique.
+ * @property {string!} name  Name of the layer.
+ * @property {string!} group Group of the layer.
+ * @property {string[]!} copyrights List of copyrights.
+ * @property {Layer[]!} children List of children layers.
+ * @property {boolean!} visible  Define if the layer is currently display on the map.
+ * @property {boolean!} disabled Define if the layer is currently display on the map but can't be seen (extent, zoom ,data restrictions).
+ * @property {number!} hittolerance Hit-detection tolerance in css pixels. Pixels inside the radius around the given position will be checked for features.
+ * @property {Object!} properties - Custom properties.
+ * @property {AnyMap!} map - The map used to display the layer.
+ */
+/**
+ * @typedef {Object} VehiclePosition
+ * @property {number[2]} coord Coordinate of the vehicle position in Mercator .
+ * @property {number!} rotation  An angle in radians representing the direction (from the true north) towards which the vehicle is facing.
+ */
+declare function dummy(): void;

package/common/typedefs.js

@@ -9,6 +9,12 @@
  * @param {any} b Object b to compare.
  * @returns number
  */
+/**
+ * @typedef {function} getMotsByZoomFunction
+ * @param {number} zoom Curent zoom level.
+ * @param {RealtimeMot[][]} motsByZoom Default array of mots by zoom.
+ * @returns number
+ */
 /**
  * @typedef {Object} ViewState
  * @property {number|undefined} time A time in ms.
@@ -33,7 +39,7 @@
  * @typedef {Object} MaplibreLayerOptions
  * @property {string} apiKey Access key for [geOps apis](https://developer.geops.io/).
  * @property {string} apiKeyName geOps Maps api key name.
- * @property {maplibregl.MapOptions} options.mapOptions Maplibre map options.
+ * @property {maplibregl.MapOptions} options.mapLibreOptions Maplibre map options.
  * @property {string} style geOps Maps api style.
  * @property {string} url geOps Maps api url.
  */

package/common/utils/compareDepartures.d.ts

@@ -0,0 +1,10 @@
+import { RealtimeDeparture } from '../../types';
+/**
+ * Compare two given departures for sort alogithm,
+ * @param {RealtimeDeparture} a First departure.
+ * @param {RealtimeDeparture} b Second departure.
+ * @param {boolean} [sortByMinArrivalTime=false] Sort departures by arrival time.
+ * @private
+ */
+declare const compareDepartures: (a: RealtimeDeparture, b: RealtimeDeparture, sortByMinArrivalTime?: boolean) => number;
+export default compareDepartures;

package/common/utils/compareDepartures.js

@@ -1,7 +1,7 @@
 /**
  * Compare two given departures for sort alogithm,
- * @param {Departure} a First departure.
- * @param {Departure} b Second departure.
+ * @param {RealtimeDeparture} a First departure.
+ * @param {RealtimeDeparture} b Second departure.
  * @param {boolean} [sortByMinArrivalTime=false] Sort departures by arrival time.
  * @private
  */

package/common/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const VECTOR_TILE_FEATURE_PROPERTY = "vectorTileFeature";
+declare const _default: {
+    VECTOR_TILE_FEATURE_PROPERTY: string;
+};
+export default _default;

package/common/utils/createCanvas.d.ts

@@ -0,0 +1,10 @@
+import { AnyCanvas } from '../../types';
+/**
+ * This function try to create a canvas element and return it.
+ * it uses document.createElement('canvas') if document is available
+ * or new OffscreenCanvas(width, height) if OffscreenCanvas is avalaible (for web worker)
+ * or it returns null if neither is available.
+ * @private
+ */
+declare const createCanvas: (width: number, height: number) => AnyCanvas | null;
+export default createCanvas;

package/common/utils/createDefaultCopyrightElt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare const createDefaultCopyrightElement: () => HTMLDivElement;
+export default createDefaultCopyrightElement;

package/common/utils/createDefaultStopFinderElt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare const createDefaultStopFinderElement: () => HTMLDivElement;
+export default createDefaultStopFinderElement;

package/common/utils/createRealtimeFilters.d.ts

@@ -0,0 +1,12 @@
+import { RealtimeTrajectory } from '../../types';
+/**
+ * Return a filter functions based on some parameters of a vehicle.
+ *
+ * @param {string|Array<string>} line - A list of vehicle's name to filter. Names can be separated by a comma. Ex: 'S1,S2,S3'
+ * @param {string|Array<string} route - A list of vehicle's route (contained in route_identifier property) to filter. Indentifiers can be separated by a comma. Ex: 'id1,id2,id3'
+ * @param {string|Array<string} operator  A list of vehicle's operator to filter. Operators can be separated by a comma. Ex: 'SBB,DB'
+ * @param {Regexp} regexLine - A regex aplly of vehcile's name.
+ * @private
+ */
+declare const createRealtimeFilters: (line: string | string[], route: string | string[], operator: string | string[], regexLine: string | string[]) => ((trajectory: RealtimeTrajectory) => boolean) | null;
+export default createRealtimeFilters;

package/common/utils/debounceDeparturesMessages.d.ts

@@ -0,0 +1,12 @@
+import type { RealtimeDeparture, RealtimeDepartureExtended } from '../../types';
+import type { WebSocketAPIMessageCallback } from '../../api/WebSocketAPI';
+/**
+ * This function returns a WebSocket api callback, and call the onDeparturesUpdate function with the list of current departures to display.
+ * @param {function(departures: RealtimeDeparture[])} onDeparturesUpdate callback when list of departures changes, called after 100 ms
+ * @param {boolean} [sortByMinArrivalTime = true] Sort departures by arrival time
+ * @param {number} [maxDepartureAge = 30] max departure age of departures in minutes
+ * @param {number} [timeout = 100] debounce timeout in ms
+ * @private
+ */
+declare const debounceDeparturesMessages: (onDeparturesUpdate: (departures: RealtimeDepartureExtended[]) => {}, sortByMinArrivalTime?: boolean, maxDepartureAge?: number, timeout?: number) => WebSocketAPIMessageCallback<RealtimeDeparture>;
+export default debounceDeparturesMessages;

package/common/utils/debounceWebsocketMessages.d.ts

@@ -0,0 +1,11 @@
+import type { WebSocketAPIMessageCallback } from '../../api/WebSocketAPI';
+/**
+ * This function returns a WebSocket api callback, and call the onUpdate function with the list of of subscribed objects changes.
+ *
+ * @param {function(objects: any[])} onUpdate callback when list of subscribed objects changes, called after 100 ms
+ * @param {function(object: any)} [getObjectId = true] function returning the id of an object
+ * @param {number} [timeout = 100] debounce timeout in ms
+ * @private
+ */
+declare const debounceWebsocketMessages: (onUpdate: (objects: any[]) => void, getObjectId?: (object: any) => string, timeout?: number) => WebSocketAPIMessageCallback<any>;
+export default debounceWebsocketMessages;

package/common/utils/getLayersAsFlatArray.d.ts

@@ -0,0 +1,3 @@
+/** @private */
+declare const getLayersAsFlatArray: (layersOrLayer: any | any[]) => any[];
+export default getLayersAsFlatArray;

package/common/utils/getLayersAsFlatArray.js

@@ -7,8 +7,12 @@ const getLayersAsFlatArray = (layersOrLayer) => {
     }
     let flatLayers = [];
     layers.forEach((layer) => {
+        var _a, _b;
         flatLayers.push(layer);
-        const children = layer.children || layer.get('children') || {};
+        // Handle children property and ol.layer.Group
+        const children = layer.children ||
+            layer.get('children') ||
+            ((_b = (_a = layer.getLayers) === null || _a === void 0 ? void 0 : _a.call(layer)) === null || _b === void 0 ? void 0 : _b.getArray());
         flatLayers = flatLayers.concat(getLayersAsFlatArray(children || []));
     });
     return flatLayers;

package/common/utils/getMapGlCopyrights.d.ts

@@ -0,0 +1,17 @@
+export interface Source {
+    attribution: string;
+    options: {
+        attribution: string;
+    };
+}
+export interface SourceCache {
+    getSource: () => Source;
+    used: boolean;
+}
+/**
+ * Return the copyright a Maplibre map.
+ * @param {maplibregl.Map} map A Maplibre map
+ * @private
+ */
+declare const getMapGlCopyrights: (map: maplibregl.Map) => any[];
+export default getMapGlCopyrights;

package/common/utils/getMapGlCopyrights.js

@@ -8,7 +8,6 @@ const getMapGlCopyrights = (map) => {
     if (!map) {
         return [];
     }
-    // @ts-ignore
     const { style } = map;
     if (!style) {
         return [];
@@ -16,10 +15,11 @@ const getMapGlCopyrights = (map) => {
     const { sourceCaches } = style;
     let copyrights = [];
     Object.values(sourceCaches).forEach((value) => {
+        var _a;
         if (value.used) {
             const source = value.getSource();
-            const attribution = // @ts-ignore
-             source.attribution || (source.options && source.options.attribution);
+            // @ts-expect-error improve types
+            const attribution = source.attribution || ((_a = source.options) === null || _a === void 0 ? void 0 : _a.attribution);
             if (attribution) {
                 copyrights = copyrights.concat(attribution.replace(/&copy;/g, '©').split(/(<a.*?<\/a>)/));
             }

package/common/utils/getRealtimeModeSuffix.d.ts

@@ -0,0 +1,10 @@
+import type { RealtimeMode } from '../../types';
+import type { RealtimeModesType } from '../../api/RealtimeAPI';
+/**
+ * Get the websocket channel suffix, depending on the current mode.
+ * @param {String} mode Mode 'topographic' ou 'schematic'.
+ * @param {String[]} modes List of modes
+ * @private
+ */
+declare const getModeSuffix: (mode: RealtimeMode, modes: RealtimeModesType) => string;
+export default getModeSuffix;

package/common/utils/getRealtimeModeSuffix.js

@@ -1,6 +1,7 @@
 /**
  * Get the websocket channel suffix, depending on the current mode.
  * @param {String} mode Mode 'topographic' ou 'schematic'.
+ * @param {String[]} modes List of modes
  * @private
  */
 const getModeSuffix = (mode, modes) => mode === modes.SCHEMATIC ? '_schematic' : '';

package/common/utils/getUrlWithParams.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return the styleUrl with apiKey parameters set.
+ * @param {string} url a url.
+ * @param {Object<String,String>} params a list of key/value pair to add to the url.
+ * @private
+ */
+declare const getUrlWithParams: (url: string, params: Object) => URL;
+export default getUrlWithParams;

package/common/utils/getVehiclePosition.d.ts

@@ -0,0 +1,17 @@
+import { Coordinate } from 'ol/coordinate';
+import { RealtimeTrajectory } from '../../types';
+export interface VehiclePosition {
+    coord: Coordinate;
+    rotation?: number;
+}
+/**
+ * Interpolate or not the vehicle position from a trajectory at a specific date.
+ *
+ * @param {number} now Current date to interpolate a position with. In ms.
+ * @param {RealtimeTrajectory} trajectory The trajectory to interpolate.
+ * @param {boolean} noInterpolate If true, the vehicle position is not interpolated on each render but only once.
+ * @returns {VehiclePosition}
+ * @private
+ */
+declare const getVehiclePosition: (now: number, trajectory: RealtimeTrajectory, noInterpolate: boolean) => VehiclePosition;
+export default getVehiclePosition;

package/common/utils/getVehiclePosition.js

@@ -9,14 +9,20 @@ import { LineString } from 'ol/geom';
  * @private
  */
 const getVehiclePosition = (now, trajectory, noInterpolate) => {
-    const { time_intervals: timeIntervals, olGeometry, coordinate, } = trajectory.properties;
-    const { coordinates } = trajectory.geometry;
-    let { type } = trajectory.geometry;
+    const { 
+    // @ts-expect-error  coordinate is added by the RealtimeLayer
+    coordinate, 
+    // @ts-expect-error  olGeometry is added by the RealtimeLayer
+    olGeometry, time_intervals: timeIntervals, } = trajectory.properties;
+    // @ts-expect-error
+    let { coordinates, type } = trajectory.geometry;
     let geometry = olGeometry;
     let coord;
     let rotation;
+    // If an olGeometry exists we use it. It avoids to create one each time.
     if (olGeometry) {
         type = geometry.getType();
+        coordinates = geometry.getCoordinates();
     }
     if (noInterpolate && coordinate) {
         coord = coordinate;

package/common/utils/index.d.ts

@@ -0,0 +1,16 @@
+export { default as getUrlWithParams } from "./getUrlWithParams";
+export { default as getMapGlCopyrights } from "./getMapGlCopyrights";
+export { default as removeDuplicate } from "./removeDuplicate";
+export { default as createRealtimeFilters } from "./createRealtimeFilters";
+export { default as getLayersAsFlatArray } from "./getLayersAsFlatArray";
+export * from "./timeUtils";
+export * from "./constants";
+export { default as sortByDelay } from "./sortByDelay";
+export { default as renderTrajectories } from "./renderTrajectories";
+export { default as debounceDeparturesMessages } from "./debounceDeparturesMessages";
+export { default as debounceWebsocketMessages } from "./debounceWebsocketMessages";
+export { default as sortAndFilterDepartures } from "./sortAndFilterDepartures";
+export { default as compareDepartures } from "./compareDepartures";
+export { default as createCanvas } from "./createCanvas";
+export { default as getVehiclePosition } from "./getVehiclePosition";
+export * as realtimeConfig from "./realtimeConfig";