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

package/common/utils/realtimeConfig.d.ts

@@ -0,0 +1,64 @@
+import { AnyCanvasContext, RealtimeMot } from '../../types';
+/**
+ * @private
+ */
+export declare const MOTS_ONLY_RAIL: RealtimeMot[];
+/**
+ * @private
+ */
+export declare const MOTS_WITH_CABLE: RealtimeMot[];
+/**
+ * @private
+ */
+export declare const MOTS_WITHOUT_CABLE: RealtimeMot[];
+/**
+ * @private
+ */
+export declare const MOTS_ALL: RealtimeMot[];
+/**
+ * Trajserv value: 'Tram',  'Subway / Metro / S-Bahn',  'Train', 'Bus', 'Ferry', 'Cable Car', 'Gondola', 'Funicular', 'Long distance bus', 'Rail',
+ * New endpoint use Rail instead of Train.
+ * New tracker values:  null, "tram", "subway", "rail", "bus", "ferry", "cablecar", "gondola", "funicular", "coach".
+ *
+ * @private
+ */
+export declare const types: RegExp[];
+/**
+ * @private
+ */
+export declare const bgColors: string[];
+/**
+ * @private
+ */
+export declare const textColors: string[];
+/**
+ * @private
+ */
+export declare const getTypeIndex: (type: RealtimeMot) => number;
+/**
+ * @private
+ */
+export declare const getRadius: (type: RealtimeMot, zoom: number) => number;
+/**
+ * @private
+ */
+export declare const getBgColor: (type: RealtimeMot) => string;
+/**
+ * @private
+ */
+export declare const getTextColor: (type: RealtimeMot) => string;
+/**
+ * @private
+ */
+export declare const getTextSize: (ctx: AnyCanvasContext, markerSize: number, text: string, fontSize: number, getTextFont: (fontSize: number, text?: string) => string) => number;
+/**
+ * @private
+ * @param {number} delayInMs Delay in milliseconds.
+ * @param {boolean} cancelled true if the journey is cancelled.
+ * @param {boolean} isDelayText true if the color is used for delay text of the symbol.
+ */
+export declare const getDelayColor: (delayInMs: number | null, cancelled?: boolean, isDelayText?: boolean) => string;
+/**
+ * @private
+ */
+export declare const getDelayText: (delayInMs: number, cancelled: boolean) => string;

package/common/utils/removeDuplicate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This function remove duplicates lower case string value of an array.
+ * It removes also null, undefined or non string values.
+ *
+ * @param {array} array Array of values.
+ * @private
+ */
+declare const removeDuplicate: (array: any[]) => any[];
+export default removeDuplicate;

package/common/utils/renderTrajectories.d.ts

@@ -0,0 +1,16 @@
+import { AnyCanvas, RealtimeRenderState, RealtimeStyleFunction, RealtimeStyleOptions, RealtimeTrajectories, ViewState } from '../../types';
+/**
+ * Draw all the trajectories available in a canvas.
+ * @param {HTMLCanvas|HTMLOffscreenCanvas} canvas The canvas where to draw the trajectories.
+ * @param {ViewState} trajectories An array of trajectories.
+ * @param {Function} style A function that returns a canvas representing a vehicle of a specific trajectory.
+ * @param {ViewState} viewState The view state of the map.
+ * @param {boolean} options.hoverVehicleId The id of the vehicle to highlight.
+ * @param {boolean} options.selectedVehicleId The id of the vehicle to select.
+ * @param {boolean} options.noInterpolate If true trajectories are not interpolated but
+ *   drawn at the last known coordinate. Use this for performance optimization
+ *   during map navigation.
+ * @private
+ */
+declare const renderTrajectories: (canvas: AnyCanvas, trajectories: RealtimeTrajectories, style: RealtimeStyleFunction, viewState: ViewState, options: RealtimeStyleOptions) => RealtimeRenderState;
+export default renderTrajectories;

package/common/utils/renderTrajectories.js

@@ -1,8 +1,8 @@
-import { compose, apply, create } from 'ol/transform';
+import { apply, compose, create } from 'ol/transform';
 import getVehiclePosition from './getVehiclePosition';
 /**
  * Draw all the trajectories available in a canvas.
- * @param {HTMLCanvas|HTMLOffscreenCanvas} The canvas where to draw the trajectories.
+ * @param {HTMLCanvas|HTMLOffscreenCanvas} canvas The canvas where to draw the trajectories.
  * @param {ViewState} trajectories An array of trajectories.
  * @param {Function} style A function that returns a canvas representing a vehicle of a specific trajectory.
  * @param {ViewState} viewState The view state of the map.
@@ -17,13 +17,13 @@ const renderTrajectories = (canvas, trajectories, style, viewState, options) =>
     if (!canvas) {
         return { renderedTrajectories: [] };
     }
-    const { time = Date.now(), size = [], center, resolution, rotation = 0, pixelRatio = 1, } = viewState;
+    const { center, pixelRatio = 1, resolution, rotation = 0, size = [], time = Date.now(), } = viewState;
     if (!resolution || !center) {
         return { renderedTrajectories: [] };
     }
-    const { noInterpolate = false, hoverVehicleId, selectedVehicleId, filter, getScreenPixel = (pixel, viewStat) => (viewStat.zoom || 0) < 12
+    const { filter, getScreenPixel = (pixel, viewStat) => (viewStat.zoom || 0) < 12
         ? pixel.map((coord) => Math.floor(coord))
-        : pixel, } = options;
+        : pixel, hoverVehicleId, noInterpolate = false, selectedVehicleId, } = options;
     const context = canvas.getContext('2d');
     context === null || context === void 0 ? void 0 : context.clearRect(0, 0, canvas.width, canvas.height);
     const [width, height] = size;
@@ -49,7 +49,7 @@ const renderTrajectories = (canvas, trajectories, style, viewState, options) =>
             continue;
         }
         // We simplify the trajectory object
-        const { train_id: id, timeOffset } = trajectory.properties;
+        const { timeOffset, train_id: id } = trajectory.properties;
         // We set the rotation and the timeFraction of the trajectory (used by tralis).
         // if rotation === null that seems there is no rotation available.
         const { coord, rotation: rotationIcon } = getVehiclePosition(time - (timeOffset || 0), trajectory, noInterpolate);

package/common/utils/sortAndFilterDepartures.d.ts

@@ -0,0 +1,15 @@
+import { RealtimeAPIDeparturesById } from '../../api/RealtimeAPI';
+import type { RealtimeDepartureExtended } from '../../types';
+/**
+ * This function sort Departures by arrival time and filter out unwanted departures:
+ *  - when dparture time is in the past
+ *  - when departure are duplicated
+ *  - when departure is not in the next 30 min
+ *
+ * @param {Object} depObject The object containing departures by id.
+ * @param {boolean} [sortByMinArrivalTime=false] If true sort departures by arrival time.
+ * @return {RealtimeDeparture[]} Return departures array.
+ * @private
+ */
+declare const sortAndfilterDepartures: (depObject: RealtimeAPIDeparturesById, sortByMinArrivalTime?: boolean, maxDepartureAge?: number) => RealtimeDepartureExtended[];
+export default sortAndfilterDepartures;

package/common/utils/sortAndFilterDepartures.js

@@ -7,7 +7,7 @@ import compareDepartures from './compareDepartures';
  *
  * @param {Object} depObject The object containing departures by id.
  * @param {boolean} [sortByMinArrivalTime=false] If true sort departures by arrival time.
- * @return {Array<Departure>} Return departures array.
+ * @return {RealtimeDeparture[]} Return departures array.
  * @private
  */
 const sortAndfilterDepartures = (depObject, sortByMinArrivalTime = false, maxDepartureAge = 30) => {

package/common/utils/sortByDelay.d.ts

@@ -0,0 +1,3 @@
+import { RealtimeTrajectory } from '../../types';
+declare const sortByDelay: (traj1: RealtimeTrajectory, traj2: RealtimeTrajectory) => number;
+export default sortByDelay;

package/common/utils/sortByDelay.js

@@ -1,4 +1,3 @@
-/** @private */
 const sortByDelay = (traj1, traj2) => {
     const props1 = traj1.properties;
     const props2 = traj2.properties;
@@ -10,12 +9,17 @@ const sortByDelay = (traj1, traj2) => {
     }
     // We put cancelled train inbetween green and yellow trains
     // >=180000ms corresponds to yellow train
+    // @ts-expect-error
     if (props1.cancelled && !props2.cancelled) {
+        // @ts-expect-error
         return props2.delay < 180000 ? -1 : 1;
     }
+    // @ts-expect-error
     if (props2.cancelled && !props1.cancelled) {
+        // @ts-expect-error
         return props1.delay < 180000 ? 1 : -1;
     }
+    // @ts-expect-error
     return props2.delay - props1.delay;
 };
 export default sortByDelay;

package/common/utils/timeUtils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get a Date object as UTC date string .
+ * ex: 2019 09 01
+ * @private
+ */
+export declare const getUTCDateString: (now?: Date) => string;
+/**
+ * Get the UTC time string of Date object.
+ * ex: 09:05:01.123
+ * @private
+ */
+export declare const getUTCTimeString: (date: Date) => string;
+/**
+ * Returns a string representation of a number, with a zero if the number is lower than 10.
+ * @private
+ */
+export declare const pad: (integer: number) => string;
+/**
+ * Returns a 'hh:mm' string from a time in ms.
+ * @param {Number} timeInMs Time in milliseconds.
+ * @private
+ */
+export declare const getHoursAndMinutes: (timeInMs: number) => string;

package/common/utils/toMercatorExtent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare const toMercatorExtent: (bounds: maplibregl.LngLatBounds) => import("ol/extent").Extent;
+export default toMercatorExtent;

package/iife.d.ts

@@ -0,0 +1,2 @@
+export default mbt;
+import mbt from './index';

package/index.d.ts

@@ -0,0 +1,9 @@
+export * as ol from "./ol";
+export * as maplibre from "./maplibre";
+declare namespace _default {
+    export { ol };
+    export { maplibre };
+}
+export default _default;
+import * as ol from './ol';
+import * as maplibre from './maplibre';

package/maplibre/controls/CopyrightControl.d.ts

@@ -0,0 +1,35 @@
+import { ControlPosition, IControl } from 'maplibre-gl';
+/**
+ * Display layer's copyrights.
+ *
+ * @example
+ * import { Map } from 'Maplibre-gl';
+ * import { CopyrightControl } from 'mobility-toolbox-js/Maplibre';
+ *
+ * const map = new Map({
+ *   container: 'map',
+ *   style: `https://maps.geops.io/styles/travic_v2/style.json?key=${window.apiKey}`,
+ * });
+ *
+ * const control = new CopyrightControl();
+ * map.addControl(control);
+ *
+ *
+ * @see <a href="/example/mb-copyright">Maplibre copyright example</a>
+ *
+ */
+declare class CopyrightControl implements IControl {
+    map?: maplibregl.Map;
+    container?: HTMLElement;
+    content?: string;
+    options?: {
+        customAttribution?: string | string[];
+        separator?: string;
+    };
+    constructor(options?: {});
+    onAdd(map: maplibregl.Map): HTMLElement;
+    onRemove(): HTMLElement | undefined;
+    getDefaultPosition(): ControlPosition;
+    render(): void;
+}
+export default CopyrightControl;

package/maplibre/controls/index.d.ts

@@ -0,0 +1 @@
+export { default as CopyrightControl } from "./CopyrightControl";

package/maplibre/index.d.ts

@@ -0,0 +1,5 @@
+export * from "../api";
+export * from "../common";
+export * from "./controls";
+export * from "./layers";
+export * from "./utils";

package/maplibre/layers/Layer.d.ts

@@ -0,0 +1,28 @@
+import { CustomLayerInterface, Evented } from 'maplibre-gl';
+import type { AnyMapGlMap } from '../../types';
+export type LayerOptions = {
+    id?: string;
+};
+/**
+ * A class representing a layer to display on an Maplibre map.
+ *
+ * @example
+ * import { Layer } from 'mobility-toolbox-js/Maplibre';
+ *
+ * const layer = new Layer({ id:'MyLayer' });
+ *
+ * @implements {maplibregl.CustomLayerInterface}
+ * @extends {maplibregl.Evented}
+ * @private
+ */
+declare class Layer extends Evented implements CustomLayerInterface {
+    id: string;
+    map: AnyMapGlMap | undefined;
+    options: LayerOptions;
+    type: 'custom';
+    constructor(options?: LayerOptions);
+    onAdd(map: AnyMapGlMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    onRemove(map: AnyMapGlMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+}
+export default Layer;

package/maplibre/layers/Layer.js

@@ -8,7 +8,7 @@ import { Evented } from 'maplibre-gl';
  *
  * const layer = new Layer({ id:'MyLayer' });
  *
- * @implements {maplibregl.CustomLayer}
+ * @implements {maplibregl.CustomLayerInterface}
  * @extends {maplibregl.Evented}
  * @private
  */

package/maplibre/layers/RealtimeLayer.d.ts

@@ -0,0 +1,181 @@
+import { RealtimeLayerMixinOptions } from '../../common/mixins/RealtimeLayerMixin';
+import Layer, { LayerOptions } from './Layer';
+import type { AnyMapGlMap, ViewState } from '../../types';
+import type { RealtimeTrajectory } from '../../api/typedefs';
+export type RealtimeLayerOptions = LayerOptions & RealtimeLayerMixinOptions;
+declare const RealtimeLayer_base: {
+    new (options: RealtimeLayerMixinOptions): {
+        [x: string]: any;
+        [x: symbol]: any;
+        api: import("..").RealtimeAPI;
+        bboxParameters?: Record<string, boolean | boolean[] | number | number[] | string | string[]>;
+        canvas?: import("../../types").AnyCanvas;
+        debounceRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
+        debug: boolean;
+        filter?: import("../../common/typedefs").FilterFunction;
+        format: import("ol/format").GeoJSON;
+        generalizationLevel?: import("../../types").RealtimeGeneralizationLevel;
+        generalizationLevelByZoom: import("../../types").RealtimeGeneralizationLevel[];
+        getGeneralizationLevelByZoom: (zoom: number) => import("../../types").RealtimeGeneralizationLevel;
+        getMotsByZoom: (zoom: number) => import("../../types").RealtimeMot[];
+        getRenderTimeIntervalByZoom: (zoom: number) => number;
+        hoverVehicleId?: import("../../types").RealtimeTrainId;
+        isUpdateBboxOnMoveEnd: boolean;
+        live?: boolean;
+        minZoomInterpolation: number;
+        mode: import("../../types").RealtimeMode;
+        mots?: import("../../types").RealtimeMot[];
+        motsByZoom: import("../../types").RealtimeMot[][];
+        onStart?: ((realtimeLayer: import("../../types").AnyLayer) => void) | undefined;
+        onStop?: ((realtimeLayer: import("../../types").AnyLayer) => void) | undefined;
+        pixelRatio?: number;
+        renderState?: import("../../types").RealtimeRenderState;
+        renderTimeIntervalByZoom: number[];
+        requestId?: number;
+        selectedVehicle: import("../../types").RealtimeTrajectory;
+        selectedVehicleId?: import("../../types").RealtimeTrainId;
+        sort?: import("../../common/typedefs").SortFunction;
+        speed?: number;
+        style?: import("../../types").RealtimeStyleFunction;
+        styleOptions?: import("../../types").RealtimeStyleOptions;
+        tenant: import("../../types").RealtimeTenant;
+        throttleRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
+        time?: Date;
+        trajectories?: Record<import("../../types").RealtimeTrainId, import("../../types").RealtimeTrajectory>;
+        updateTimeDelay?: number;
+        updateTimeInterval?: number;
+        useDebounce?: boolean;
+        useRequestAnimationFrame?: boolean;
+        useThrottle?: boolean;
+        visibilityRef: import("ol/events").EventsKey;
+        addTrajectory(trajectory: import("../../types").RealtimeTrajectory): void;
+        attachToMap(map: import("../../types").AnyMap): void;
+        defineProperties(options: RealtimeLayerMixinOptions): void;
+        detachFromMap(): void;
+        getFeatureInfoAtCoordinate(coordinate: import("ol/coordinate").Coordinate, options: import("../../types").LayerGetFeatureInfoOptions): Promise<import("../../types").LayerGetFeatureInfoResponse>;
+        getRefreshTimeInMs(zoom?: number | undefined): number;
+        getTrajectoryInfos(id: import("../../types").RealtimeTrainId): Promise<{
+            fullTrajectory: import("../../api/WebSocketAPI").WebSocketAPIMessageEventData<import("../../types").RealtimeStopSequence[]> | import("../../api/WebSocketAPI").WebSocketAPIMessageEventData<import("../../types").RealtimeFullTrajectory>;
+            stopSequence: import("../../api/WebSocketAPI").WebSocketAPIMessageEventData<import("../../types").RealtimeStopSequence[]> | import("../../api/WebSocketAPI").WebSocketAPIMessageEventData<import("../../types").RealtimeFullTrajectory>;
+        }>;
+        getVehicle(filterFc: import("../../common/typedefs").FilterFunction): import("../../types").RealtimeTrajectory[];
+        highlightVehicle(id: import("../../types").RealtimeTrainId): void;
+        onDeleteTrajectoryMessage(data: import("../../api/WebSocketAPI").WebSocketAPIMessageEventData<import("../../types").RealtimeTrainId>): void;
+        onDocumentVisibilityChange(): void;
+        onTrajectoryMessage(data: import("../../api/WebSocketAPI").WebSocketAPIMessageEventData<import("../../types").RealtimeTrajectory>): void;
+        onZoomEnd(): void;
+        purgeOutOfDateTrajectories(): void;
+        purgeTrajectory(trajectory: import("../../types").RealtimeTrajectory, extent: [number, number, number, number], zoom: number): boolean;
+        removeTrajectory(trajectoryOrId: import("../../types").RealtimeTrainId | import("../../types").RealtimeTrajectory): void;
+        renderTrajectories(viewState: undefined | ViewState, noInterpolate: boolean | undefined): void;
+        renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
+        selectVehicle(id: import("../../types").RealtimeTrainId): void;
+        setBbox(extent: [number, number, number, number], zoom: number): void;
+        start(): void;
+        startUpdateTime(): void;
+        stop(): void;
+        stopUpdateTime(): void;
+    };
+} & typeof Layer;
+/**
+ * A Maplibre layer able to display data from the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
+ *
+ * @example
+ * import { Map } from 'maplibre-gl';
+ * import { RealtimeLayer } from 'mobility-toolbox-js/maplibre';
+ *
+ * // Define the map
+ * const map = new Map({ ... });
+ *
+ * // Define your layer map
+ * const layer = new RealtimeLayer({
+ *   apiKey: "yourApiKey"
+ *   // url: "wss://api.geops.io/tracker-ws/v1/",
+ * });
+ *
+ * // Add the layer to your map *
+ * map.on('load', () => {
+ *   map.addLayer(layer);
+ * });
+ *
+ *
+ * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ * @see <a href="/example/mb-realtime>Live example</a>
+ *
+ * @implements {maplibregl.CustomLayerInterface}
+ * @extends {maplibregl.Evented}
+ * @classproperty {function} filter - Filter out a train. This function must be fast, it is executed for every trajectory on every render frame.
+ * @classproperty {RealtimeMode} mode - The realtime mode to use.
+ * @classproperty {RealtimeMot[]} mots - Filter trains by its mode of transportation. It filters trains on backend side.
+ * @classproperty {RealtimeTenant} tenant - Filter trains by its tenant. It filters trains on backend side.
+ * @classproperty {function} sort - Sort trains. This function must be fast, it is executed on every render frame.
+ * @classproperty {function} style - Function to style the vehicles.
+ s
+ * @public
+ */
+declare class RealtimeLayer extends RealtimeLayer_base {
+    /**
+     * Constructor.
+     *
+     * @param {RealtimeLayerOptions} options
+     * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {FilterFunction} options.filter Filter out a train. This function must be fast, it is executed for every trajectory on every render frame.
+     * @param {getMotsByZoomFunction} options.getMotsByZoom Returns for each zoom level the list of MOTs to display. It filters trains on backend side.
+     * @param {number} [options.minZoomInterpolation=8] Minimal zoom level where to start to interpolate train positions.
+     * @param {RealtimeMode} [options.mode='topographic'] The realtime mode to use.
+     * @param {SortFunction} options.sort Sort trains. This function must be fast, it is executed on every render frame.
+     * @param {RealtimeStyleFunction} options.style Function to style the vehicles.
+     * @param {RealtimeTenant} options.tenant Filter trains by its tenant. It filters trains on backend side.
+     * @param {string} [options.url="wss://api.geops.io/tracker-ws/v1/"] The geOps Realtime API url.
+     */
+    constructor(options?: {});
+    /**
+     * Add sources, layers and listeners to the map.
+     */
+    onAdd(map: AnyMapGlMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * Remove source, layers and listeners from the map.
+     */
+    onRemove(map: AnyMapGlMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    onLoad(): void;
+    /**
+     * Start updating vehicles position.
+     *
+     * @public
+     */
+    start(): void;
+    /**
+     * Stop updating vehicles position.
+     *
+     * @public
+     */
+    stop(): void;
+    /**
+     * Render the trajectories using current map's size, resolution and rotation.
+     * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
+     * @private
+     */
+    renderTrajectories(noInterpolate?: boolean): void;
+    /**
+     * Return the delay in ms before the next rendering.
+     */
+    getRefreshTimeInMs(): number;
+    /**
+     * Remove the trajectory form the list if necessary.
+     */
+    purgeTrajectory(trajectory: RealtimeTrajectory, extent: [number, number, number, number], zoom: number): boolean;
+    /**
+     * Send the current bbox to the websocket
+     */
+    setBbox(extent?: [number, number, number, number], zoom?: number): void;
+    renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
+    /**
+     * Callback on 'move' event.
+     */
+    onMove(): void;
+    /**
+     * Callback on 'moveend' event.
+     */
+    onMoveEnd(): void;
+}
+export default RealtimeLayer;

package/maplibre/layers/RealtimeLayer.js

@@ -8,21 +8,39 @@ import Layer from './Layer';
 import { getSourceCoordinates } from '../utils';
 import toMercatorExtent from '../../common/utils/toMercatorExtent';
 /**
- * Responsible for loading and display data from a geOps Realtime API.
+ * A Maplibre layer able to display data from the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
  *
  * @example
- * import { RealtimeLayer } from 'mobility-toolbox-js/Maplibre';
+ * import { Map } from 'maplibre-gl';
+ * import { RealtimeLayer } from 'mobility-toolbox-js/maplibre';
  *
+ * // Define the map
+ * const map = new Map({ ... });
+ *
+ * // Define your layer map
  * const layer = new RealtimeLayer({
  *   apiKey: "yourApiKey"
  *   // url: "wss://api.geops.io/tracker-ws/v1/",
  * });
  *
+ * // Add the layer to your map *
+ * map.on('load', () => {
+ *   map.addLayer(layer);
+ * });
+ *
  *
  * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ * @see <a href="/example/mb-realtime>Live example</a>
  *
- * @implements {maplibregl.CustomLayer}
+ * @implements {maplibregl.CustomLayerInterface}
  * @extends {maplibregl.Evented}
+ * @classproperty {function} filter - Filter out a train. This function must be fast, it is executed for every trajectory on every render frame.
+ * @classproperty {RealtimeMode} mode - The realtime mode to use.
+ * @classproperty {RealtimeMot[]} mots - Filter trains by its mode of transportation. It filters trains on backend side.
+ * @classproperty {RealtimeTenant} tenant - Filter trains by its tenant. It filters trains on backend side.
+ * @classproperty {function} sort - Sort trains. This function must be fast, it is executed on every render frame.
+ * @classproperty {function} style - Function to style the vehicles.
+ s
  * @public
  */
 class RealtimeLayer extends RealtimeLayerMixin(Layer) {
@@ -31,13 +49,19 @@ class RealtimeLayer extends RealtimeLayerMixin(Layer) {
      *
      * @param {RealtimeLayerOptions} options
      * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {FilterFunction} options.filter Filter out a train. This function must be fast, it is executed for every trajectory on every render frame.
+     * @param {getMotsByZoomFunction} options.getMotsByZoom Returns for each zoom level the list of MOTs to display. It filters trains on backend side.
+     * @param {number} [options.minZoomInterpolation=8] Minimal zoom level where to start to interpolate train positions.
+     * @param {RealtimeMode} [options.mode='topographic'] The realtime mode to use.
+     * @param {SortFunction} options.sort Sort trains. This function must be fast, it is executed on every render frame.
+     * @param {RealtimeStyleFunction} options.style Function to style the vehicles.
+     * @param {RealtimeTenant} options.tenant Filter trains by its tenant. It filters trains on backend side.
      * @param {string} [options.url="wss://api.geops.io/tracker-ws/v1/"] The geOps Realtime API url.
-     *
      */
     constructor(options = {}) {
         var _a;
         const canvas = document.createElement('canvas');
-        super(Object.assign({ canvas }, options));
+        super(Object.assign({ canvas, id: 'realtime' }, options));
         /** @private */
         this.source = {
             id: this.id,

package/maplibre/layers/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Layer } from "./Layer";
+export { default as RealtimeLayer } from "./RealtimeLayer";

package/maplibre/utils/getMercatorResolution.d.ts

@@ -0,0 +1,7 @@
+import { AnyMapGlMap } from '../../types';
+/**
+ * Get the current resolution of a Maplibre map.
+ * @param {maplibregl.Map} map A map object.
+ */
+declare const getMercatorResolution: (map: AnyMapGlMap) => number;
+export default getMercatorResolution;

package/maplibre/utils/getSourceCoordinates.d.ts

@@ -0,0 +1,7 @@
+import { AnyMapGlMap } from '../../types';
+/**
+ * Get the canvas source coordinates of the current map's extent.
+ * @param {maplibregl.Map} map A map object.
+ */
+export declare const getSourceCoordinates: (map: AnyMapGlMap, pixelRatio?: number) => number[][];
+export default getSourceCoordinates;

package/maplibre/utils/getSourceCoordinates.js

@@ -4,17 +4,17 @@
  */
 export const getSourceCoordinates = (map, pixelRatio = 1) => {
     // Requesting getBounds is not enough when we rotate the map, so we request manually each corner.
-    const { width, height } = map.getCanvas();
-    // @ts-ignore
+    const { height, width } = map.getCanvas();
+    // @ts-expect-error
     const leftTop = map.unproject({ x: 0, y: 0 });
-    // @ts-ignore
+    // @ts-expect-error
     const leftBottom = map.unproject({ x: 0, y: height / pixelRatio }); // southWest
-    // @ts-ignore
+    // @ts-expect-error
     const rightBottom = map.unproject({
         x: width / pixelRatio,
         y: height / pixelRatio,
     });
-    // @ts-ignore
+    // @ts-expect-error
     const rightTop = map.unproject({ x: width / pixelRatio, y: 0 }); // north east
     return [
         [leftTop.lng, leftTop.lat],

package/maplibre/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { default as getSourceCoordinates } from "./getSourceCoordinates";
+export { default as getMercatorResolution } from "./getMercatorResolution";