mobility-toolbox-js 3.0.0-beta.32 → 3.0.0-beta.33

package/api/HttpAPI.js

@@ -14,9 +14,7 @@ import getUrlWithParams from '../common/utils/getUrlWithParams';
  */
 class HttpAPI {
     constructor(options) {
-        /** @private */
         this.url = options.url;
-        /** @private */
         this.apiKey = options.apiKey;
     }
     /**
@@ -29,7 +27,7 @@ class HttpAPI {
             if (!this.url) {
                 throw new Error(`No url defined for request to ${this.url}/${path}`);
             }
-            if (!this.url && !this.apiKey && !/key=/.test(this.url)) {
+            if (!this.url && !this.apiKey && !this.url.includes('key=')) {
                 // eslint-disable-next-line no-console
                 throw new Error(`No apiKey defined for request to ${this.url}`);
             }

package/api/RealtimeAPI.d.ts

@@ -60,13 +60,13 @@ export declare const RealtimeModes: {
  * @public
  */
 declare class RealtimeAPI {
-    _bbox?: RealtimeBbox;
-    _buffer?: number[];
-    _url: string;
     private pingInterval;
     private pingIntervalMs;
     private reconnectTimeout?;
     private reconnectTimeoutMs?;
+    _bbox?: RealtimeBbox;
+    _buffer?: number[];
+    _url: string;
     version: RealtimeVersion;
     wsApi: WebSocketAPI;
     /**

package/api/WebSocketAPI.js

@@ -71,7 +71,6 @@ class WebSocketAPI {
                 this.websocket.close();
             }
         }
-        /** @private */
         this.websocket = new WebSocket(url);
         if (!this.open) {
             this.websocket.addEventListener('open', () => {

package/common/styles/realtimeDefaultStyle.js

@@ -1,5 +1,4 @@
 import createCanvas from '../utils/createCanvas';
-/** @private */
 const cacheDelayBg = {};
 /**
  * Draw circle delay background
@@ -25,7 +24,6 @@ export const getDelayBgCanvas = (origin, radius, color) => {
     }
     return cacheDelayBg[key];
 };
-/** @private */
 const cacheDelayText = {};
 /**
  * Draw delay text
@@ -55,7 +53,6 @@ export const getDelayTextCanvas = (text, fontSize, font, delayColor, delayOutlin
     }
     return cacheDelayText[key];
 };
-/** @private */
 const cacheCircle = {};
 /**
  * Draw colored circle with black border
@@ -90,7 +87,6 @@ export const getCircleCanvas = (origin, radius, color, hasStroke, hasDash, pixel
     }
     return cacheCircle[key];
 };
-/** @private */
 const cacheText = {};
 /**
  * Draw text in the circle
@@ -129,7 +125,6 @@ export const getTextCanvas = (text, origin, textSize, fillColor, strokeColor, ha
     }
     return cacheText[key];
 };
-/** @private */
 const cache = {};
 /**
  * A tracker style that take in account the delay.

package/common/styles/realtimeHeadingStyle.js

@@ -1,16 +1,13 @@
 import createCanvas from '../utils/createCanvas';
 import { getBgColor } from '../utils/realtimeConfig';
 import realtimeDefaultStyle from './realtimeDefaultStyle';
-/** @private */
 const rotateCanvas = (canvas, rotation) => {
     const ctx = canvas.getContext('2d');
     ctx === null || ctx === void 0 ? void 0 : ctx.translate(canvas.width / 2, canvas.height / 2);
     ctx === null || ctx === void 0 ? void 0 : ctx.rotate(rotation);
     ctx === null || ctx === void 0 ? void 0 : ctx.translate(-canvas.width / 2, -canvas.height / 2);
 };
-/** @private */
 const arrowCache = {};
-/** @private */
 const getArrowCanvas = (fillColor) => {
     const key = `${fillColor}`;
     if (!arrowCache[key]) {
@@ -35,9 +32,7 @@ const getArrowCanvas = (fillColor) => {
     }
     return arrowCache[key];
 };
-/** @private */
 const bufferArrowCache = {};
-/** @private */
 const getBufferArrowCanvas = (canvas, fillColor, rotation) => {
     const margin = 20;
     const bufferKey = `${fillColor},${canvas.width},${canvas.height},${rotation}`;

package/common/styles/realtimeSimpleStyle.d.ts

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

package/common/styles/realtimeSimpleStyle.js

@@ -4,7 +4,6 @@ import createCanvas from '../utils/createCanvas';
  * Display blue point for each train.
  */
 let canvas;
-/** @private */
 const realtimeSimpleStyle = () => {
     if (!canvas) {
         canvas = createCanvas(15, 15);

package/common/utils/RealtimeEngine.d.ts

@@ -0,0 +1,224 @@
+import { FeatureCollection } from 'geojson';
+import GeoJSON from 'ol/format/GeoJSON';
+import { RealtimeAPI } from '../../api';
+import { WebSocketAPIMessageEventData } from '../../api/WebSocketAPI';
+import { AnyCanvas, AnyLayer, AnyRealtimeLayer, LayerGetFeatureInfoOptions, RealtimeGeneralizationLevel, RealtimeMode, RealtimeMot, RealtimeRenderState, RealtimeStyleFunction, RealtimeStyleOptions, RealtimeTenant, RealtimeTrainId, RealtimeTrajectory, ViewState } from '../../types';
+import { FilterFunction, SortFunction } from '../typedefs';
+import type { Coordinate } from 'ol/coordinate';
+export interface RealtimeEngineOptions {
+    api?: RealtimeAPI;
+    apiKey?: string;
+    bbox?: (number | string)[];
+    bboxParameters?: Record<string, boolean | boolean[] | number | number[] | string | string[]>;
+    buffer?: number[];
+    canvas?: HTMLCanvasElement;
+    debug?: boolean;
+    filter?: FilterFunction;
+    generalizationLevelByZoom?: RealtimeGeneralizationLevel[];
+    getGeneralizationLevelByZoom?: (zoom: number, generalizationLevelByZoom: RealtimeGeneralizationLevel[]) => RealtimeGeneralizationLevel;
+    getMotsByZoom?: (zoom: number, motsByZoom: RealtimeMot[][]) => RealtimeMot[];
+    getRenderTimeIntervalByZoom?: (zoom: number, renderTimeIntervalByZoom: number[]) => number;
+    getViewState?: () => ViewState;
+    hoverVehicleId?: RealtimeTrainId;
+    isUpdateBboxOnMoveEnd?: boolean;
+    live?: boolean;
+    minZoomInterpolation?: number;
+    mode?: RealtimeMode;
+    motsByZoom?: RealtimeMot[][];
+    onRender?: (renderState: RealtimeRenderState, viewState: ViewState) => void;
+    onStart?: (realtimeLayer: AnyRealtimeLayer) => void;
+    onStop?: (realtimeLayer: AnyRealtimeLayer) => void;
+    pingIntervalMs?: number;
+    pixelRatio?: number;
+    prefix?: string;
+    renderTimeIntervalByZoom?: number[];
+    selectedVehicleId?: RealtimeTrainId;
+    shouldRender?: () => boolean;
+    sort?: SortFunction;
+    speed?: number;
+    style?: RealtimeStyleFunction;
+    styleOptions?: RealtimeStyleOptions;
+    tenant?: RealtimeTenant;
+    time?: Date;
+    url?: string;
+    useDebounce?: boolean;
+    useRequestAnimationFrame?: boolean;
+    useThrottle?: boolean;
+}
+/**
+ * This class is responsible for drawing trajectories from a realtime API in a canvas,
+ * depending on the map's view state and at a specific time.
+ *
+ * This class is totally agnostic from Maplibre or OpenLayers and must stay taht way.
+ */
+declare class RealtimeEngine {
+    _mode: RealtimeMode;
+    _speed: number;
+    _style: RealtimeStyleFunction;
+    _time: Date;
+    api: RealtimeAPI;
+    bboxParameters?: Record<string, boolean | boolean[] | number | number[] | string | string[]>;
+    canvas?: AnyCanvas;
+    debounceRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
+    debug: boolean;
+    filter?: FilterFunction;
+    format: GeoJSON;
+    generalizationLevel?: RealtimeGeneralizationLevel;
+    generalizationLevelByZoom: RealtimeGeneralizationLevel[];
+    getGeneralizationLevelByZoom: (zoom: number) => RealtimeGeneralizationLevel;
+    getMotsByZoom: (zoom: number) => RealtimeMot[];
+    getRenderTimeIntervalByZoom: (zoom: number) => number;
+    getViewState: () => ViewState;
+    hoverVehicleId?: RealtimeTrainId;
+    isUpdateBboxOnMoveEnd: boolean;
+    live?: boolean;
+    minZoomInterpolation: number;
+    mots?: RealtimeMot[];
+    motsByZoom: RealtimeMot[][];
+    onRender?: (renderState: RealtimeRenderState, viewState: ViewState) => void;
+    onStart?: (realtimeLayer: AnyLayer) => void;
+    onStop?: (realtimeLayer: AnyLayer) => void;
+    pixelRatio?: number;
+    renderState?: RealtimeRenderState;
+    renderTimeIntervalByZoom: number[];
+    requestId?: number;
+    selectedVehicle: RealtimeTrajectory;
+    selectedVehicleId?: RealtimeTrainId;
+    shouldRender: () => boolean;
+    sort?: SortFunction;
+    styleOptions?: RealtimeStyleOptions;
+    tenant: RealtimeTenant;
+    throttleRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
+    trajectories?: Record<RealtimeTrainId, RealtimeTrajectory>;
+    updateTimeDelay?: number;
+    updateTimeInterval?: number;
+    useDebounce?: boolean;
+    useRequestAnimationFrame?: boolean;
+    useThrottle?: boolean;
+    constructor(options: RealtimeEngineOptions);
+    /**
+     * Add a trajectory.
+     * @param {RealtimeTrajectory} trajectory The trajectory to add.
+     * @private
+     */
+    addTrajectory(trajectory: RealtimeTrajectory): void;
+    attachToMap(): void;
+    detachFromMap(): void;
+    /**
+     * Get the duration before the next update depending on zoom level.
+     *
+     * @private
+     * @param {number} zoom
+     */
+    getRefreshTimeInMs(): number;
+    /**
+     * Get vehicle.
+     * @param {function} filterFc A function use to filter results.
+     * @return {Array<Object>} Array of vehicle.
+     */
+    getVehicle(filterFc: FilterFunction): RealtimeTrajectory[];
+    /**
+     * Request feature information for a given coordinate.
+     *
+     * @param {ol/coordinate~Coordinate} coordinate Coordinate.
+     * @param {Object} options Options See child classes to see which options are supported.
+     * @param {number} [options.resolution=1] The resolution of the map.
+     * @param {number} [options.nb=Infinity] The max number of vehicles to return.
+     * @return {Promise<FeatureInfo>} Promise with features, layer and coordinate.
+     */
+    getVehiclesAtCoordinate(coordinate: Coordinate, options?: LayerGetFeatureInfoOptions): FeatureCollection;
+    /**
+     * Callback on websocket's deleted_vehicles channel events.
+     * It removes the trajectory from the list.
+     *
+     * @private
+     * @override
+     */
+    onDeleteTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrainId>): void;
+    onDocumentVisibilityChange(): void;
+    /**
+     * Callback on websocket's trajectory channel events.
+     * It adds a trajectory to the list.
+     *
+     * @private
+     */
+    onTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrajectory>): void;
+    /**
+     * On zoomend we adjust the time interval of the update of vehicles positions.
+     *
+     * @param evt Event that triggered the function.
+     * @private
+     */
+    onZoomEnd(): void;
+    /**
+     * Remove all trajectories that are in the past.
+     */
+    purgeOutOfDateTrajectories(): void;
+    /**
+     * Determine if the trajectory is useless and should be removed from the list or not.
+     * By default, this function exclude vehicles:
+     *  - that have their trajectory outside the current extent and
+     *  - that aren't in the MOT list.
+     *
+     * @param {RealtimeTrajectory} trajectory
+     * @param {Array<number>} extent
+     * @param {number} zoom
+     * @return {boolean} if the trajectory must be displayed or not.
+     * @private
+     */
+    purgeTrajectory(trajectory: RealtimeTrajectory): boolean;
+    removeTrajectory(trajectoryOrId: RealtimeTrainId | RealtimeTrajectory): void;
+    /**
+     * Render the trajectories requesting an animation frame and cancelling the previous one.
+     * This function must be overrided by children to provide the correct parameters.
+     *
+     * @param {object} viewState The view state of the map.
+     * @param {number[2]} viewState.center Center coordinate of the map in mercator coordinate.
+     * @param {number[4]} viewState.extent Extent of the map in mercator coordinates.
+     * @param {number[2]} viewState.size Size ([width, height]) of the canvas to render.
+     * @param {number} [viewState.rotation = 0] Rotation of the map to render.
+     * @param {number} viewState.resolution Resolution of the map to render.
+     * @param {boolean} noInterpolate If true trajectories are not interpolated but
+     *   drawn at the last known coordinate. Use this for performance optimization
+     *   during map navigation.
+     * @private
+     */
+    renderTrajectories(noInterpolate?: boolean): void;
+    /**
+     * Launch renderTrajectories. it avoids duplicating code in renderTrajectories method.
+     *
+     * @param {object} viewState The view state of the map.
+     * @param {number[2]} viewState.center Center coordinate of the map in mercator coordinate.
+     * @param {number[4]} viewState.extent Extent of the map in mercator coordinates.
+     * @param {number[2]} viewState.size Size ([width, height]) of the canvas to render.
+     * @param {number} [viewState.rotation = 0] Rotation of the map to render.
+     * @param {number} viewState.resolution Resolution of the map to render.
+     * @param {boolean} noInterpolate If true trajectories are not interpolated but
+     *   drawn at the last known coordinate. Use this for performance optimization
+     *   during map navigation.
+     * @private
+     */
+    renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
+    setBbox(): void;
+    start(): void;
+    /**
+     * Start the clock.
+     * @private
+     */
+    startUpdateTime(): void;
+    stop(): void;
+    /**
+     * Stop the clock.
+     * @private
+     */
+    stopUpdateTime(): void;
+    get mode(): RealtimeMode;
+    set mode(newMode: RealtimeMode);
+    get speed(): number;
+    set speed(newSpeed: number);
+    get style(): RealtimeStyleFunction;
+    set style(newStyle: RealtimeStyleFunction);
+    get time(): Date;
+    set time(newTime: Date | number);
+}
+export default RealtimeEngine;