mobility-toolbox-js 3.0.0-beta.7 → 3.0.0-beta.9

package/common/mixins/RealtimeLayerMixin.d.ts

@@ -0,0 +1,273 @@
+import GeoJSON from 'ol/format/GeoJSON';
+import { EventsKey } from 'ol/events';
+import { Coordinate } from 'ol/coordinate';
+import { Options } from 'ol/layer/Layer';
+import { RealtimeAPI } from '../../api';
+import { AnyCanvas, AnyLayerClass, AnyMap, AnyRealtimeLayer, LayerGetFeatureInfoOptions, RealtimeGeneralizationLevel, RealtimeMode, RealtimeMot, RealtimeRenderState, RealtimeStyleFunction, RealtimeStyleOptions, RealtimeTenant, RealtimeTrainId, ViewState, AnyLayer, LayerGetFeatureInfoResponse } from '../../types';
+import { RealtimeTrajectory } from '../../api/typedefs';
+import { WebSocketAPIMessageEventData } from '../../api/WebSocketAPI';
+import { FilterFunction, SortFunction } from '../typedefs';
+export type RealtimeLayerMixinOptions = Options & {
+    debug?: boolean;
+    mode?: RealtimeMode;
+    api?: RealtimeAPI;
+    tenant?: RealtimeTenant;
+    minZoomInterpolation?: number;
+    isUpdateBboxOnMoveEnd?: boolean;
+    motsByZoom?: RealtimeMot[][];
+    generalizationLevelByZoom?: RealtimeGeneralizationLevel[];
+    renderTimeIntervalByZoom?: number[];
+    style?: RealtimeStyleFunction;
+    speed?: number;
+    pixelRatio?: number;
+    hoverVehicleId?: RealtimeTrainId;
+    selectedVehicleId?: RealtimeTrainId;
+    filter?: FilterFunction;
+    sort?: SortFunction;
+    time?: number;
+    live?: boolean;
+    canvas?: HTMLCanvasElement;
+    styleOptions?: RealtimeStyleOptions;
+    useRequestAnimationFrame?: boolean;
+    useDebounce?: boolean;
+    useThrottle?: boolean;
+    getMotsByZoom?: (zoom: number, motsByZoom: RealtimeMot[][]) => RealtimeMot[];
+    getGeneralizationLevelByZoom?: (zoom: number, generalizationLevelByZoom: RealtimeGeneralizationLevel[]) => RealtimeGeneralizationLevel;
+    getRenderTimeIntervalByZoom?: (zoom: number, renderTimeIntervalByZoom: number[]) => number;
+    onStart?: (realtimeLayer: AnyRealtimeLayer) => void;
+    onStop?: (realtimeLayer: AnyRealtimeLayer) => void;
+    url?: string;
+    apiKey?: string;
+    prefix?: string;
+    bbox?: (number | string)[];
+    buffer?: number[];
+    pingIntervalMs?: number;
+    bboxParameters?: {
+        [index: string]: string | number | boolean | string[] | boolean[] | number[];
+    };
+};
+/**
+ * RealtimeLayerInterface.
+ * @private
+ */
+export declare class RealtimeLayerInterface {
+    /**
+     * Start the clock.
+     */
+    start(): void;
+    /**
+     * Stop the clock.
+     */
+    stop(): void;
+    /**
+     * Set the Realtime api's bbox.
+     *
+     * @param {Array<number>} extent  Extent to request, [minX, minY, maxX, maxY].
+     * @param {number} zoom  Zoom level to request. Must be an integer.
+     */
+    setBbox(extent: [number, number, number, number], zoom: number): void;
+    /**
+     * Render the trajectories
+     */
+    renderTrajectories(): void;
+    /**
+     * Request the stopSequence and the fullTrajectory informations for a vehicle.
+     *
+     * @param {string} id The vehicle identifier (the  train_id property).
+     * @param {RealtimeMode} mode The mode to request. If not defined, the layer´s mode propetrty will be used.
+     * @return {Promise<{stopSequence: StopSequence, fullTrajectory: FullTrajectory>} A promise that will be resolved with the trajectory informations.
+     */
+    getTrajectoryInfos(id: string, mode: RealtimeMode): void;
+}
+/**
+ * Mixin for RealtimeLayerInterface.
+ *
+ * @param {Class} Base A class to extend with {RealtimeLayerInterface} functionnalities.
+ * @return {Class}  A class that implements {RealtimeLayerInterface} class and extends Base;
+ * @private
+ */
+declare function RealtimeLayerMixin<T extends AnyLayerClass>(Base: T): {
+    new (options: RealtimeLayerMixinOptions): {
+        [x: string]: any;
+        debug: boolean;
+        trajectories?: {
+            [key: string]: GeoJSONFeature;
+        } | undefined;
+        canvas?: AnyCanvas | undefined;
+        mode: RealtimeMode;
+        api: RealtimeAPI;
+        tenant: RealtimeTenant;
+        bboxParameters?: {
+            [index: string]: string | number | boolean | string[] | number[] | boolean[];
+        } | undefined;
+        time?: Date | undefined;
+        live?: boolean | undefined;
+        speed?: number | undefined;
+        filter?: Function | undefined;
+        sort?: Function | undefined;
+        style?: RealtimeStyleFunction | undefined;
+        styleOptions?: RealtimeStyleOptions | undefined;
+        pixelRatio?: number | undefined;
+        minZoomInterpolation: number;
+        isUpdateBboxOnMoveEnd: boolean;
+        hoverVehicleId?: string | undefined;
+        selectedVehicleId?: string | undefined;
+        renderState?: RealtimeRenderState | undefined;
+        useRequestAnimationFrame?: boolean | undefined;
+        useDebounce?: boolean | undefined;
+        useThrottle?: boolean | undefined;
+        mots?: RealtimeMot[] | undefined;
+        motsByZoom: RealtimeMot[][];
+        generalizationLevel?: RealtimeGeneralizationLevel | undefined;
+        generalizationLevelByZoom: RealtimeGeneralizationLevel[];
+        renderTimeIntervalByZoom: number[];
+        format: GeoJSON;
+        requestId?: number | undefined;
+        updateTimeInterval?: number | undefined;
+        updateTimeDelay?: number | undefined;
+        visibilityRef: EventsKey;
+        selectedVehicle: GeoJSONFeature;
+        getMotsByZoom: (zoom: number) => RealtimeMot[];
+        getGeneralizationLevelByZoom: (zoom: number) => RealtimeGeneralizationLevel;
+        getRenderTimeIntervalByZoom: (zoom: number) => number;
+        throttleRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
+        debounceRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
+        onStart?: ((realtimeLayer: AnyLayer) => void) | undefined;
+        onStop?: ((realtimeLayer: AnyLayer) => void) | undefined;
+        /**
+         * Define layer's properties.
+         *
+         * @private
+         */
+        defineProperties(options: RealtimeLayerMixinOptions): void;
+        attachToMap(map: AnyMap): void;
+        detachFromMap(): void;
+        start(): void;
+        /**
+         * Start the clock.
+         * @private
+         */
+        startUpdateTime(): void;
+        stop(): void;
+        /**
+         * Stop the clock.
+         * @private
+         */
+        stopUpdateTime(): 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;
+        /**
+         * 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(viewState: ViewState | undefined, noInterpolate: boolean | undefined): void;
+        setBbox(extent: [number, number, number, number], zoom: number): void;
+        /**
+         * Get the duration before the next update depending on zoom level.
+         *
+         * @private
+         * @param {number} zoom
+         */
+        getRefreshTimeInMs(zoom?: number | undefined): number;
+        /**
+         * Get vehicle.
+         * @param {function} filterFc A function use to filter results.
+         * @return {Array<Object>} Array of vehicle.
+         */
+        getVehicle(filterFc: FilterFunction): GeoJSONFeature[];
+        /**
+         * 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.
+         */
+        getFeatureInfoAtCoordinate(coordinate: Coordinate, options: LayerGetFeatureInfoOptions): Promise<LayerGetFeatureInfoResponse>;
+        /**
+         * Request the stopSequence and the fullTrajectory informations for a vehicle.
+         *
+         * @param {string} id The vehicle identifier (the  train_id property).
+         * @return {Promise<{stopSequence: StopSequence, fullTrajectory: FullTrajectory>} A promise that will be resolved with the trajectory informations.
+         */
+        getTrajectoryInfos(id: RealtimeTrainId): Promise<{
+            stopSequence: WebSocketAPIMessageEventData<import("../../types").RealtimeFullTrajectory> | WebSocketAPIMessageEventData<GeoJSONFeature[]>;
+            fullTrajectory: WebSocketAPIMessageEventData<import("../../types").RealtimeFullTrajectory> | WebSocketAPIMessageEventData<GeoJSONFeature[]>;
+        }>;
+        /**
+         * 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: GeoJSONFeature, extent: [number, number, number, number], zoom: number): boolean;
+        /**
+         * Add a trajectory.
+         * @param {RealtimeTrajectory} trajectory The trajectory to add.
+         * @private
+         */
+        addTrajectory(trajectory: GeoJSONFeature): void;
+        removeTrajectory(trajectoryOrId: RealtimeTrajectory | RealtimeTrainId): void;
+        /**
+         * On zoomend we adjust the time interval of the update of vehicles positions.
+         *
+         * @param evt Event that triggered the function.
+         * @private
+         */
+        onZoomEnd(): void;
+        onDocumentVisibilityChange(): void;
+        /**
+         * Callback on websocket's trajectory channel events.
+         * It adds a trajectory to the list.
+         *
+         * @private
+         */
+        onTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrajectory>): void;
+        /**
+         * Callback on websocket's deleted_vehicles channel events.
+         * It removes the trajectory from the list.
+         *
+         * @private
+         * @override
+         */
+        onDeleteTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrainId>): void;
+        highlightVehicle(id: RealtimeTrainId): void;
+        selectVehicle(id: RealtimeTrainId): void;
+    };
+} & T;
+export default RealtimeLayerMixin;

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/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/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,212 @@
+export default dummy;
+export type FilterFunction = Function;
+export type SortFunction = 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: any;
+    /**
+     * A size ([width, height]).
+     */
+    size: any;
+    /**
+     * 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: any;
+};
+export type MaplibreLayerOptions = {
+    /**
+     * Access key for [geOps apis](https://developer.geops.io/).
+     */
+    apiKey: string;
+    /**
+     * geOps Maps api key name.
+     */
+    apiKeyName: string;
+    /**
+     * Maplibre map options.
+     */
+    mapOptions: 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: any;
+    /**
+     * 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 {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.mapOptions 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/utils/compareDepartures.d.ts

@@ -0,0 +1,10 @@
+import { RealtimeDeparture } from '../../types';
+/**
+ * Compare two given departures for sort alogithm,
+ * @param {Departure} a First departure.
+ * @param {Departure} 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/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) | undefined, 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;