mobility-toolbox-js 3.0.1-beta.0 → 3.0.1-beta.2

package/ol/layers/RealtimeLayer.d.ts

@@ -1,181 +1,23 @@
+import { DebouncedFunc } from 'lodash';
 import { Map, MapEvent } from 'ol';
+import { EventsKey } from 'ol/events';
 import Feature, { FeatureLike } from 'ol/Feature';
-import GeoJSON from 'ol/format/GeoJSON';
-import { Vector as VectorLayer } from 'ol/layer';
 import Layer from 'ol/layer/Layer';
+import VectorLayer from 'ol/layer/Vector';
 import { ObjectEvent } from 'ol/Object';
-import Source from 'ol/source/Source';
+import { Vector as VectorSource } from 'ol/source';
+import { State } from 'ol/View';
 import { WebSocketAPIMessageEventData } from '../../api/WebSocketAPI';
-import { RealtimeLayerMixinOptions } from '../../common/mixins/RealtimeLayerMixin';
-import { RealtimeFullTrajectory, RealtimeTrainId, RealtimeTrajectory, ViewState } from '../../types';
+import { FilterFunction, SortFunction } from '../../common/typedefs';
+import RealtimeEngine, { RealtimeEngineOptions } from '../../common/utils/RealtimeEngine';
+import { RealtimeAPI } from '../../maplibre';
+import { RealtimeFullTrajectory, RealtimeMode, RealtimeRenderState, RealtimeTrainId, ViewState } from '../../types';
 import RealtimeLayerRenderer from '../renderers/RealtimeLayerRenderer';
 export type RealtimeLayerOptions = {
     allowRenderWhenAnimating?: boolean;
     fullTrajectoryStyle?: (feature: FeatureLike, resolution: number, options: any) => void;
-} & 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: 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?: 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: RealtimeTrajectory;
-        selectedVehicleId?: 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<RealtimeTrainId, RealtimeTrajectory>;
-        updateTimeDelay?: number;
-        updateTimeInterval?: number;
-        useDebounce?: boolean;
-        useRequestAnimationFrame?: boolean;
-        useThrottle?: boolean;
-        visibilityRef: import("ol/events").EventsKey;
-        addTrajectory(trajectory: 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: RealtimeTrainId): Promise<{
-            fullTrajectory: WebSocketAPIMessageEventData<import("../../types").RealtimeStopSequence[]> | WebSocketAPIMessageEventData<RealtimeFullTrajectory>;
-            stopSequence: WebSocketAPIMessageEventData<import("../../types").RealtimeStopSequence[]> | WebSocketAPIMessageEventData<RealtimeFullTrajectory>;
-        }>;
-        getVehicle(filterFc: import("../../common/typedefs").FilterFunction): RealtimeTrajectory[];
-        highlightVehicle(id: RealtimeTrainId): void;
-        onDeleteTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrainId>): void;
-        onDocumentVisibilityChange(): void;
-        onTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrajectory>): void;
-        onZoomEnd(): void;
-        purgeOutOfDateTrajectories(): void;
-        purgeTrajectory(trajectory: RealtimeTrajectory, extent: [number, number, number, number], zoom: number): boolean;
-        removeTrajectory(trajectoryOrId: RealtimeTrainId | RealtimeTrajectory): void;
-        renderTrajectories(viewState: undefined | ViewState, noInterpolate: boolean | undefined): void;
-        renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
-        selectVehicle(id: RealtimeTrainId): void;
-        setBbox(extent: [number, number, number, number], zoom: number): void;
-        start(): void;
-        startUpdateTime(): void;
-        stop(): void;
-        stopUpdateTime(): void;
-    };
-} & {
-    new (...args: any[]): {
-        olEventsKeys: import("ol/events").EventsKey[];
-        options?: import("../mixins/PropertiesLayerMixin").PropertiesLayerMixinOptions;
-        attachToMap(map: Map): void;
-        detachFromMap(): void;
-        flat(): any[];
-        onChildrenChange(oldValue: Layer[]): void;
-        setMapInternal: ((map: Map) => void) & ((map: import("ol/Map").default | null) => void);
-        children: Layer<Source, import("ol/renderer/Layer").default<any>>[];
-        get copyrights(): string;
-        set copyrights(newCopyrights: string | string[]);
-        disabled: boolean;
-        readonly group: string;
-        readonly hitTolerance: number;
-        readonly key: string;
-        readonly map: Map;
-        readonly name: string;
-        olLayer: Layer;
-        parent: Layer<Source, import("ol/renderer/Layer").default<any>>;
-        visible: boolean;
-        on: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
-        once: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
-        un: import("ol/layer/Layer").LayerOnSignature<void>;
-        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
-        getSource: () => Source | null;
-        getRenderSource: () => Source | null;
-        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<Array<import("ol/Feature").FeatureLike>>;
-        getData: (pixel: import("ol/pixel").Pixel) => Uint8ClampedArray | Uint8Array | Float32Array | DataView | null;
-        isVisible: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
-        getAttributions: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => Array<string>;
-        unrender: () => void;
-        getDeclutter: () => string;
-        renderDeclutter: (frameState: import("ol/Map").FrameState, layerState: import("ol/layer/Layer").State) => void;
-        renderDeferred: (frameState: import("ol/Map").FrameState) => void;
-        getMapInternal: () => import("ol/Map").default | null;
-        setMap: (map: import("ol/Map").default | null) => void;
-        setSource: (source: Source | null) => void;
-        getRenderer: () => import("ol/renderer/Layer").default<any> | null;
-        hasRenderer: () => boolean;
-        getBackground: () => import("ol/layer/Base").BackgroundColor | false;
-        getClassName: () => string;
-        getLayerState: (managed?: boolean | undefined) => import("ol/layer/Layer").State;
-        getLayersArray: (array?: import("ol/layer/Layer").default<import("ol/source/Source").default, import("ol/renderer/Layer").default<any>>[] | undefined) => Array<import("ol/layer/Layer").default>;
-        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => Array<import("ol/layer/Layer").State>;
-        getExtent: () => import("ol/extent").Extent | undefined;
-        getMaxResolution: () => number;
-        getMinResolution: () => number;
-        getMinZoom: () => number;
-        getMaxZoom: () => number;
-        getOpacity: () => number;
-        getSourceState: () => import("ol/source/Source").State;
-        getVisible: () => boolean;
-        getZIndex: () => number | undefined;
-        setBackground: (background?: import("ol/layer/Base").BackgroundColor | undefined) => void;
-        setExtent: (extent: import("ol/extent").Extent | undefined) => void;
-        setMaxResolution: (maxResolution: number) => void;
-        setMinResolution: (minResolution: number) => void;
-        setMaxZoom: (maxZoom: number) => void;
-        setMinZoom: (minZoom: number) => void;
-        setOpacity: (opacity: number) => void;
-        setVisible: (visible: boolean) => void;
-        setZIndex: (zindex: number) => void;
-        get: (key: string) => any;
-        getKeys: () => Array<string>;
-        getProperties: () => {
-            [x: string]: any;
-        };
-        getPropertiesInternal: () => {
-            [x: string]: any;
-        } | null;
-        hasProperties: () => boolean;
-        notify: (key: string, oldValue: any) => void;
-        addChangeListener: (key: string, listener: import("ol/events").Listener) => void;
-        removeChangeListener: (key: string, listener: import("ol/events").Listener) => void;
-        set: (key: string, value: any, silent?: boolean | undefined) => void;
-        setProperties: (values: {
-            [x: string]: any;
-        }, silent?: boolean | undefined) => void;
-        unset: (key: string, silent?: boolean | undefined) => void;
-        changed: () => void;
-        getRevision: () => number;
-        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
-        dispatchEvent: (event: import("ol/events/Event").default | string) => boolean | undefined;
-        getListeners: (type: string) => Array<import("ol/events").Listener> | undefined;
-        hasListener: (type?: string | undefined) => boolean;
-        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
-        dispose: () => void;
-    };
-} & typeof Layer;
+    maxNbFeaturesRequested?: number;
+} & RealtimeEngineOptions;
 /**
  * An OpenLayers layer able to display data from the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
  *
@@ -190,94 +32,119 @@ declare const RealtimeLayer_base: {
  *
  *
  * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ * @see <a href="/example/ol-realtime">OpenLayers Realtime layer example</a>
+ *
  *
  * @extends {ol/layer/Layer~Layer}
  *
+ *
  * @classproperty {boolean} allowRenderWhenAnimating - Allow rendering of the layer when the map is animating.
  * @public
  */
-declare class RealtimeLayer extends RealtimeLayer_base {
-    /** @private */
+declare class RealtimeLayer extends Layer {
     allowRenderWhenAnimating?: boolean;
-    vectorLayer: VectorLayer<Feature>;
+    currentZoom?: number;
+    engine: RealtimeEngine;
+    maxNbFeaturesRequested: number;
+    olEventsKeys: EventsKey[];
+    onMoveEndDebounced: DebouncedFunc<(evt: MapEvent | ObjectEvent) => void>;
+    onZoomEndDebounced: DebouncedFunc<(evt: MapEvent | ObjectEvent) => void>;
+    renderedViewState: State | undefined;
+    vectorLayer: VectorLayer<VectorSource>;
+    get api(): RealtimeAPI;
+    set api(api: RealtimeAPI);
+    get canvas(): import("../../types").AnyCanvas | undefined;
+    get filter(): FilterFunction | undefined;
+    set filter(filter: FilterFunction);
+    get hoverVehicleId(): RealtimeTrainId | undefined;
+    set hoverVehicleId(id: RealtimeTrainId);
+    get mode(): RealtimeMode;
+    set mode(mode: RealtimeMode);
+    get pixelRatio(): number | undefined;
+    get selectedVehicleId(): RealtimeTrainId | undefined;
+    set selectedVehicleId(id: RealtimeTrainId);
+    get sort(): SortFunction | undefined;
+    set sort(sort: SortFunction);
+    get trajectories(): Record<string, import("../../types").RealtimeTrajectory> | undefined;
     /**
      * Constructor.
      *
      * @param {RealtimeLayerOptions} options
      * @param {boolean} [options.allowRenderWhenAnimating=false] Allow rendering of the layer when the map is animating.
-     * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
-     * @param {string} [options.url="wss://api.geops.io/tracker-ws/v1/"] The geOps Realtime API url.
-     *
+     * @param {string} options.apiKey Access key for [geOps APIs](https://developer.geops.io/).
+     * @param {string} [options.url="wss://api.geops.io/tracker-ws/v1/"] The [geOps Realtime API](https://developer.geops.io/apis/realtime/) url.
+     * @public
      */
     constructor(options: RealtimeLayerOptions);
-    /** @private */
-    attachToMap(map: Map): void;
+    attachToMap(): void;
     /**
      * Create a copy of the RealtimeLayer.
-     * @param {Object} newOptions Options to override
+     *
+     * @param {Object} newOptions Options to override. See constructor.
      * @return {RealtimeLayer} A RealtimeLayer
+     * @public
      */
     clone(newOptions: RealtimeLayerOptions): RealtimeLayer;
-    /**
-     * @private
-     */
     createRenderer(): RealtimeLayerRenderer;
-    /**
-     * Render the trajectories using current map's size, resolution and rotation.
-     * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
-     * @overrides
-     * @private
-     */
     /**
      * Destroy the container of the tracker.
-     * @private
      */
     detachFromMap(): void;
     /**
-     * Return the delay in ms before the next rendering.
-     * @private
-     */
-    getRefreshTimeInMs(): number;
-    highlight(feature: Feature): void;
-    /**
-     * On move end we update the websocket with the new bbox.
+     * Get some informations about a trajectory.
      *
-     * @private
-     * @override
+     * @param {RealtimeTrainId} id A vehicle's id.
+     * @returns
      */
+    getTrajectoryInfos(id: RealtimeTrainId): Promise<{
+        fullTrajectory: WebSocketAPIMessageEventData<RealtimeFullTrajectory> | WebSocketAPIMessageEventData<import("../../types").RealtimeStopSequence[]>;
+        stopSequence: WebSocketAPIMessageEventData<RealtimeFullTrajectory> | WebSocketAPIMessageEventData<import("../../types").RealtimeStopSequence[]>;
+    }>;
+    getVehicles(filterFunc: FilterFunction): import("../../types").RealtimeTrajectory[];
+    getViewState(): {
+        center?: undefined;
+        extent?: undefined;
+        pixelRatio?: undefined;
+        resolution?: undefined;
+        rotation?: undefined;
+        size?: undefined;
+        visible?: undefined;
+        zoom?: undefined;
+    } | {
+        center: import("ol/coordinate").Coordinate | undefined;
+        extent: import("ol/extent").Extent;
+        pixelRatio: number | undefined;
+        resolution: number | undefined;
+        rotation: number;
+        size: import("ol/size").Size | undefined;
+        visible: boolean;
+        zoom: number | undefined;
+    };
+    highlight(feature: Feature): void;
     /**
      * Highlight the trajectory of journey.
-     * @private
      */
     highlightTrajectory(id: RealtimeTrainId): Promise<Feature[] | undefined>;
+    onMoveEnd(): void;
     /**
-     * Function called on moveend event only when the zoom has changed.
-     *
-     * @param {ol/MapEvent~MapEvent} evt Moveend event.
-     * @private
-     * @override
+     * Callback when the RealtimeEngine has rendered successfully.
      */
-    onMoveEnd(evt: MapEvent | ObjectEvent): void;
+    onRealtimeEngineRender(renderState: RealtimeRenderState, viewState: ViewState): void;
     onZoomEnd(): void;
+    select(feature: Feature): void;
+    setMapInternal(map: Map): void;
+    shouldRender(): boolean | undefined;
     /**
-     * Remove the trajectory form the list if necessary.
+     * Start the rendering.
      *
-     * @private
+     * @public
      */
-    purgeTrajectory(trajectory: RealtimeTrajectory, extent: [number, number, number, number], zoom: number): boolean;
-    renderTrajectories(noInterpolate: boolean): void;
-    /**
-     * Launch renderTrajectories. it avoids duplicating code in renderTrajectories methhod.
-     * @private
-     * @override
-     */
-    renderTrajectoriesInternal(viewState: ViewState, noInterpolate: boolean): boolean;
-    select(feature: Feature): void;
+    start(): void;
     /**
-     * Send the current bbox to the websocket
+     * Stop the rendering.
      *
-     * @private
+     * @public
      */
-    setBbox(extent?: [number, number, number, number], zoom?: number): void;
+    stop(): void;
 }
 export default RealtimeLayer;