mobility-toolbox-js 2.0.0-beta.47 → 2.0.0-beta.48

package/common/utils/getMapboxRender.d.ts

@@ -1,7 +1,7 @@
 import { FrameState } from 'ol/PluggableMap';
-import type { AnyMapboxLayer } from '../../types';
+import { MapboxLayer } from '../../ol';
 /**
  * Return the render function fo the olLayer of a MaplibreLayer
  */
-export default function getMapboxRender(mapoxLayer: AnyMapboxLayer): (frameState: FrameState) => HTMLElement;
+export default function getMapboxRender(mapoxLayer: MapboxLayer): (frameState: FrameState) => HTMLElement;
 //# sourceMappingURL=getMapboxRender.d.ts.map

package/common/utils/getMapboxRender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMapboxRender.d.ts","sourceRoot":"","sources":["../../../src/common/utils/getMapboxRender.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,UAAU,EAAE,cAAc,GACzB,CAAC,UAAU,EAAE,UAAU,KAAK,WAAW,CA4EzC"}
+{"version":3,"file":"getMapboxRender.d.ts","sourceRoot":"","sources":["../../../src/common/utils/getMapboxRender.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,UAAU,EAAE,WAAW,GACtB,CAAC,UAAU,EAAE,UAAU,KAAK,WAAW,CAuFzC"}

package/common/utils/getMapboxRender.js

@@ -6,59 +6,68 @@ export default function getMapboxRender(mapoxLayer) {
     return (frameState) => {
         const { map, mbMap, renderState, olLayer } = mapoxLayer;
         if (!map || !mbMap) {
-            return null;
+            return document.createElement('div');
         }
         let changed = false;
         const canvas = mbMap.getCanvas();
         const { viewState } = frameState;
-        const visible = olLayer.getVisible();
-        if (renderState.visible !== visible) {
+        const visible = olLayer === null || olLayer === void 0 ? void 0 : olLayer.getVisible();
+        if (renderState && (renderState === null || renderState === void 0 ? void 0 : renderState.visible) !== visible) {
             canvas.style.display = visible ? 'block' : 'none';
             renderState.visible = visible;
             // Needed since mapbox-gl 1.9.0.
             // Without you don't see others ol layers on top.
             canvas.style.position = 'absolute';
         }
-        const opacity = olLayer.getOpacity();
-        if (renderState.opacity !== opacity) {
+        const opacity = olLayer === null || olLayer === void 0 ? void 0 : olLayer.getOpacity();
+        if (canvas && renderState && renderState.opacity !== opacity) {
+            // @ts-ignore
             canvas.style.opacity = opacity;
             renderState.opacity = opacity;
         }
         // adjust view parameters in mapbox
         const { rotation } = viewState;
-        if (renderState.rotation !== rotation) {
+        if (renderState && renderState.rotation !== rotation) {
             mbMap.rotateTo((-(rotation || 0) * 180) / Math.PI, {
                 animate: false,
             });
             changed = true;
             renderState.rotation = rotation;
         }
-        if (renderState.zoom !== viewState.zoom ||
-            renderState.center[0] !== viewState.center[0] ||
-            renderState.center[1] !== viewState.center[1]) {
+        if (renderState &&
+            renderState.center &&
+            (renderState.zoom !== viewState.zoom ||
+                renderState.center[0] !== viewState.center[0] ||
+                renderState.center[1] !== viewState.center[1])) {
             mbMap.jumpTo({
                 center: toLonLat(viewState.center),
                 zoom: viewState.zoom - 1,
-                animate: false,
             });
             changed = true;
             renderState.zoom = viewState.zoom;
             renderState.center = viewState.center;
         }
         const size = map.getSize() || [0, 0];
-        if (renderState.size[0] !== size[0] || renderState.size[1] !== size[1]) {
+        if (renderState &&
+            renderState.size &&
+            (renderState.size[0] !== size[0] || renderState.size[1] !== size[1])) {
             changed = true;
             renderState.size = size;
         }
         // cancel the scheduled update & trigger synchronous redraw
         // see https://github.com/mapbox/mapbox-gl-js/issues/7893#issue-408992184
         // NOTE: THIS MIGHT BREAK WHEN UPDATING MAPBOX
+        // @ts-ignore
         if (mbMap && mbMap.style && mbMap.isStyleLoaded() && changed) {
             try {
+                // @ts-ignore
                 if (mbMap._frame) {
+                    // @ts-ignore
                     mbMap._frame.cancel();
+                    // @ts-ignore
                     mbMap._frame = null;
                 }
+                // @ts-ignore
                 mbMap._render();
             }
             catch (err) {

package/mapbox/index.d.ts

@@ -2,4 +2,5 @@ export * from "../api";
 export * from "../common";
 export * from "./controls";
 export * from "./layers";
+export * from "./utils";
 //# sourceMappingURL=index.d.ts.map

package/mapbox/index.js

@@ -2,3 +2,4 @@ export * from '../api';
 export * from '../common';
 export * from './controls';
 export * from './layers';
+export * from './utils';

package/mapbox/layers/Layer.d.ts

@@ -1,4 +1,7 @@
-export default Layer;
+import { EventsKey } from 'ol/events';
+import LayerCommon, { LayerCommonOptions } from '../../common/layers/LayerCommon';
+import { AnyMapboxMap, UserInteractionCallback } from '../../types';
+declare const Layer_base: typeof LayerCommon;
 /**
  * A class representing a layer to display on an OpenLayers map.
  *
@@ -14,13 +17,21 @@ export default Layer;
  * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
  * @extends {Layer}
  */
-declare class Layer {
+declare class Layer extends Layer_base {
+    options: LayerCommonOptions;
+    onChangeVisibleKey?: EventsKey;
+    userInteractions?: boolean;
+    userClickInteractions?: boolean;
+    userHoverInteractions?: boolean;
+    userClickCallbacks?: UserInteractionCallback[];
+    userHoverCallbacks?: UserInteractionCallback[];
+    onUserClickCallback: () => void;
+    onUserMoveCallback: () => void;
     /**
      * Initialize the layer and listen to user events.
-     * @param {ol/Map~Map} map
+     * @param {mapboxgl.Map|maplibregl.Map} map
      */
-    attachToMap(map: any): void;
-    onChangeVisibleKey: any;
+    attachToMap(map: AnyMapboxMap): void;
     detachFromMap(): void;
     activateUserInteractions(): void;
     deactivateUserInteractions(): void;
@@ -28,7 +39,7 @@ declare class Layer {
      * Toggle listeners needed when a layer is avisible or not.
      * @private
      */
-    private toggleVisibleListeners;
+    toggleVisibleListeners(): void;
     /**
      * Returns the current extent in mercator coordinates.
      */
@@ -42,6 +53,7 @@ declare class Layer {
      * @param {Object} newOptions Options to override
      * @return {Layer} A Layer
      */
-    clone(newOptions: Object): Layer;
+    clone(newOptions: LayerCommonOptions): Layer;
 }
+export default Layer;
 //# sourceMappingURL=Layer.d.ts.map

package/mapbox/layers/Layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/Layer.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;GAcG;AACH;IACE;;;OAGG;IACH,4BAcC;IALG,wBAGC;IAIL,sBAMC;IAED,iCAmBC;IAED,mCAKC;IAED;;;OAGG;IACH,+BAMC;IAED;;OAEG;IACH,gDAOC;IAED;;OAEG;IACH,iBAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,KAAK,CAIhB;CACF"}
+{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/Layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAGtC,OAAO,WAAW,EAAE,EAClB,kBAAkB,EACnB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;;AAEpE;;;;;;;;;;;;;;GAcG;AACH,cAAM,KAAM,SAAQ,UAAkC;IACpD,OAAO,EAAG,kBAAkB,CAAC;IAE7B,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAI/B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC,kBAAkB,CAAC,EAAE,uBAAuB,EAAE,CAAC;IAE/C,kBAAkB,CAAC,EAAE,uBAAuB,EAAE,CAAC;IAE/C,mBAAmB,EAAG,MAAM,IAAI,CAAC;IAEjC,kBAAkB,EAAG,MAAM,IAAI,CAAC;IAEhC;;;OAGG;IACH,WAAW,CAAC,GAAG,EAAE,YAAY;IAiB7B,aAAa;IASb,wBAAwB;IAqBxB,0BAA0B;IAO1B;;;OAGG;IACH,sBAAsB;IAQtB;;OAEG;IACH,iBAAiB;IASjB;;OAEG;IACH,SAAS;IAIT;;;;OAIG;IACH,KAAK,CAAC,UAAU,EAAE,kBAAkB;CAGrC;AACD,eAAe,KAAK,CAAC"}

package/mapbox/layers/Layer.js

@@ -20,7 +20,7 @@ import userInteractionsMixin from '../../common/mixins/UserInteractionsLayerMixi
 class Layer extends userInteractionsMixin(LayerCommon) {
     /**
      * Initialize the layer and listen to user events.
-     * @param {ol/Map~Map} map
+     * @param {mapboxgl.Map|maplibregl.Map} map
      */
     attachToMap(map) {
         super.attachToMap(map);
@@ -29,28 +29,32 @@ class Layer extends userInteractionsMixin(LayerCommon) {
         }
         if (this.userInteractions) {
             this.toggleVisibleListeners();
-            this.onChangeVisibleKey = this.on('change:visible', this.toggleVisibleListeners);
+            this.onChangeVisibleKey = this.on(
+            // @ts-ignore
+            'change:visible', this.toggleVisibleListeners);
         }
     }
     detachFromMap() {
         if (this.map) {
             this.deactivateUserInteractions();
+            // @ts-ignore
             unByKey(this.onChangeVisibleKey);
         }
         super.detachFromMap();
     }
     activateUserInteractions() {
+        var _a, _b;
         this.deactivateUserInteractions();
         if (this.map &&
             this.userInteractions &&
             this.userClickInteractions &&
-            this.userClickCallbacks.length) {
+            ((_a = this.userClickCallbacks) === null || _a === void 0 ? void 0 : _a.length)) {
             this.map.on('click', this.onUserClickCallback);
         }
         if (this.map &&
             this.userInteractions &&
             this.userHoverInteractions &&
-            this.userHoverCallbacks.length) {
+            ((_b = this.userHoverCallbacks) === null || _b === void 0 ? void 0 : _b.length)) {
             this.map.on('mousemove', this.onUserMoveCallback);
         }
     }

package/mapbox/layers/RealtimeLayer.d.ts

@@ -1,4 +1,83 @@
-export default RealtimeLayer;
+/// <reference types="mapbox-gl" />
+import { Coordinate } from 'ol/coordinate';
+import { Feature } from 'ol';
+import Layer from './Layer';
+import { AnyMapboxMap, LayerGetFeatureInfoOptions, LayerGetFeatureInfoResponse } from '../../types';
+import { RealtimeTrajectory } from '../../api/typedefs';
+declare const RealtimeLayer_base: {
+    new (options: import("../../common/mixins/RealtimeLayerMixin").RealtimeLayerMixinOptions): {
+        [x: string]: any;
+        debug: boolean;
+        trajectories?: {
+            [key: string]: GeoJSONFeature;
+        } | undefined;
+        canvas?: import("../../types").AnyCanvas | undefined;
+        mode: import("../../types").RealtimeMode;
+        api: import("../../api/RealtimeAPI").default;
+        tenant: string;
+        time?: Date | undefined;
+        live?: boolean | undefined;
+        speed?: number | undefined;
+        filter?: Function | undefined;
+        sort?: Function | undefined;
+        style?: import("../../types").RealtimeStyleFunction | undefined;
+        styleOptions?: import("../../types").RealtimeStyleOptions | undefined;
+        pixelRatio?: number | undefined;
+        minZoomNonTrain: number;
+        minZoomInterpolation: number;
+        isUpdateBboxOnMoveEnd: boolean;
+        hoverVehicleId?: string | undefined;
+        selectedVehicleId?: string | undefined;
+        renderState?: import("../../types").RealtimeRenderState | undefined;
+        useRequestAnimationFrame?: boolean | undefined;
+        useDebounce?: boolean | undefined;
+        useThrottle?: boolean | undefined;
+        generalizationLevel?: import("../../types").RealtimeGeneralizationLevel | undefined;
+        generalizationLevelByZoom: import("../../types").RealtimeGeneralizationLevel[];
+        renderTimeIntervalByZoom: number[];
+        format: import("ol/format/GeoJSON").default;
+        requestId?: number | undefined;
+        updateTimeInterval?: number | undefined;
+        updateTimeDelay?: number | undefined;
+        visibilityRef: import("ol/events").EventsKey;
+        selectedVehicle: GeoJSONFeature;
+        getGeneralizationLevelByZoom: (zoom: number) => import("../../types").RealtimeGeneralizationLevel;
+        getRenderTimeIntervalByZoom: (zoom: number) => number;
+        throttleRenderTrajectories: (viewState: import("../../types").ViewState, noInterpolate?: boolean | undefined) => void;
+        debounceRenderTrajectories: (viewState: import("../../types").ViewState, noInterpolate?: boolean | undefined) => void;
+        defineProperties(options: import("../../common/mixins/RealtimeLayerMixin").RealtimeLayerMixinOptions): void;
+        attachToMap(map: any): void;
+        detachFromMap(): void;
+        start(): void;
+        startUpdateTime(): void;
+        stop(): void;
+        stopUpdateTime(): void;
+        renderTrajectoriesInternal(viewState: import("../../types").ViewState, noInterpolate?: boolean): boolean;
+        renderTrajectories(viewState: import("../../types").ViewState | undefined, noInterpolate: boolean | undefined): void;
+        setBbox(extent?: [number, number, number, number] | undefined, zoom?: number | undefined): void;
+        setMode(mode: import("../../types").RealtimeMode): void;
+        getRefreshTimeInMs(zoom?: number | undefined): number;
+        getVehicle(filterFc: Function): GeoJSONFeature[];
+        getFeatureInfoAtCoordinate(coordinate: Coordinate, options: LayerGetFeatureInfoOptions): Promise<{
+            layer: any;
+            features: Feature<import("ol/geom/Geometry").default>[];
+            coordinate: Coordinate;
+        }>;
+        getTrajectoryInfos(id: string): Promise<{
+            stopSequence: unknown;
+            fullTrajectory: unknown;
+        }>;
+        purgeTrajectory(trajectory: GeoJSONFeature, extent: [number, number, number, number], zoom: number): boolean;
+        addTrajectory(trajectory: GeoJSONFeature): void;
+        removeTrajectory(trajectoryOrId: any): void;
+        onZoomEnd(): void;
+        onDocumentVisibilityChange(): void;
+        onTrajectoryMessage(data: import("../../common/api/WebSocketAPI").WebSocketAPIMessageEventData): void;
+        onDeleteTrajectoryMessage(data: import("../../common/api/WebSocketAPI").WebSocketAPIMessageEventData): void;
+        onFeatureHover(features: Feature<import("ol/geom/Geometry").default>[], layer: import("../../types").AnyRealtimeLayer, coordinate: Coordinate): void;
+        onFeatureClick(features: Feature<import("ol/geom/Geometry").default>[], layer: import("../../types").AnyRealtimeLayer, coordinate: Coordinate): void;
+    };
+} & typeof Layer;
 /**
  * Responsible for loading and display data from a Realtime service.
  *
@@ -16,25 +95,8 @@ export default RealtimeLayer;
  * @extends {Layer}
  * @implements {RealtimeLayerInterface}
  */
-declare class RealtimeLayer extends Layer implements RealtimeLayerInterface {
+declare class RealtimeLayer extends RealtimeLayer_base {
     constructor(options?: {});
-    onLoad(): void;
-    /**
-     * Callback on 'move' event.
-     *
-     * @private
-     */
-    private onMove;
-    /**
-     * Send the new BBOX to the websocket.
-     *
-     * @private
-     * @override
-     */
-    private override onMoveEnd;
-    /** @ignore */
-    onZoomEnd: any;
-    onVisibilityChange(): void;
     /**
      * Initialize the layer.
      *
@@ -42,29 +104,11 @@ declare class RealtimeLayer extends Layer implements RealtimeLayerInterface {
      * @param {string} beforeId Layer's id before which we want to add the new layer.
      * @override
      */
-    override attachToMap(map: mapboxgl.Map, beforeId: string): void;
-    source: {
-        type: string;
-        canvas: any;
-        coordinates: number[][];
-        animate: boolean;
-        attribution: any;
-    } | undefined;
-    beforeId: string | undefined;
-    layer: {
-        id: any;
-        type: string;
-        source: any;
-        layout: {
-            visibility: string;
-        };
-        paint: {
-            'raster-opacity': number;
-            'raster-fade-duration': number;
-            'raster-resampling': string;
-        };
-    } | undefined;
-    listeners: any[] | undefined;
+    attachToMap(map: AnyMapboxMap, beforeId: string): void;
+    /**
+     * Remove listeners from the Mapbox Map.
+     */
+    detachFromMap(): void;
     /**
      * Start updating vehicles position.
      *
@@ -72,47 +116,62 @@ declare class RealtimeLayer extends Layer implements RealtimeLayerInterface {
      * @listens {mapboxgl.map.event:mousemove} Listen to mousemove end.
      * @override
      */
-    override start(): void;
+    start(): void;
     /**
      * Stop updating vehicles position, and unlisten events.
      *
      * @override
      */
-    override stop(): void;
+    stop(): void;
+    onLoad(): void;
     /**
      * Function triggered when the user moves the cursor over the map.
      * @override
      */
-    override onUserMoveCallback(evt: any): void;
+    onUserMoveCallback(evt: mapboxgl.MapLayerMouseEvent | maplibregl.MapMouseEvent): void;
     /**
      * Render the trajectories using current map's size, resolution and rotation.
      * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
      * @overrides
      */
-    renderTrajectories(noInterpolate: boolean): void;
+    renderTrajectories(noInterpolate?: boolean): void;
     /**
      * Return the delay in ms before the next rendering.
      */
-    getRefreshTimeInMs(): any;
-    getFeatureInfoAtCoordinate(coordinate: any, options?: {}): any;
+    getRefreshTimeInMs(): number;
+    getFeatureInfoAtCoordinate(coordinate: Coordinate, options?: {}): Promise<LayerGetFeatureInfoResponse>;
+    onVisibilityChange(): void;
     /**
      * Remove the trajectory form the list if necessary.
      *
      * @private
      */
-    private purgeTrajectory;
+    purgeTrajectory(trajectory: RealtimeTrajectory, extent: [number, number, number, number], zoom: number): boolean;
     /**
      * Send the current bbox to the websocket
      */
-    setBbox(extent: any, zoom: any): void;
-    renderTrajectoriesInternal(viewState: any, noInterpolate: any): any;
+    setBbox(extent?: [number, number, number, number], zoom?: number): void;
+    /**
+     * Callback on 'move' event.
+     *
+     * @private
+     */
+    onMove(): void;
+    renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
+    /**
+     * Send the new BBOX to the websocket.
+     *
+     * @private
+     * @override
+     */
+    onMoveEnd(): void;
     /**
      * Update the cursor style when hovering a vehicle.
      *
      * @private
      * @override
      */
-    private override onFeatureHover;
+    onFeatureHover(features: Feature[], layer: RealtimeLayer, coordinate: Coordinate): void;
 }
-import Layer from "./Layer";
+export default RealtimeLayer;
 //# sourceMappingURL=RealtimeLayer.d.ts.map

package/mapbox/layers/RealtimeLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/RealtimeLayer.js"],"names":[],"mappings":";AASA;;;;;;;;;;;;;;;;GAgBG;AACH,qDAFgB,sBAAsB;IAGpC,0BAmBC;IAuGD,eAOC;IA0HD;;;;OAIG;IACH,eAEC;IAcD;;;;;OAKG;IACH,2BAMC;IA9QC,cAAc;IACd,eAA0C;IAoM5C,2BAYC;IA1MD;;;;;;OAMG;IACH,0BAJW,YAAY,YACZ,MAAM,QA8ChB;IA/BC;;;;;;kBAOC;IAED,6BAAwB;IACxB;;;;;;;;;;;;kBAYC;IAQD,6BAAqE;IAuBvE;;;;;;OAMG;IACH,uBAMC;IAED;;;;OAIG;IACH,sBAOC;IAWD;;;OAGG;IACH,4CAKC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAkDjB;IAED;;OAEG;IACH,0BAEC;IAED,+DAMC;IAgBD;;;;OAIG;IACH,wBAMC;IAED;;OAEG;IACH,sCAQC;IAWD,oEAUC;IAgBD;;;;;OAKG;IACH,gCAKC;CACF"}
+{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/RealtimeLayer.ts"],"names":[],"mappings":";AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAE7B,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B,OAAO,EACL,YAAY,EACZ,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExD;;;;;;;;;;;;;;;;GAgBG;AAEH,cAAM,aAAc,SAAQ,kBAAY;gBAC1B,OAAO,KAAK;IAqBxB;;;;;;OAMG;IAEH,WAAW,CAAC,GAAG,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM;IAuC/C;;OAEG;IACH,aAAa;IAkBb;;;;;;OAMG;IACH,KAAK;IAQL;;;;OAIG;IACH,IAAI;IASJ,MAAM;IASN;;;OAGG;IACH,kBAAkB,CAChB,GAAG,EAAE,QAAQ,CAAC,kBAAkB,GAAG,UAAU,CAAC,aAAa;IAQ7D;;;;OAIG;IAEH,kBAAkB,CAAC,aAAa,CAAC,EAAE,OAAe;IAuDlD;;OAEG;IACH,kBAAkB;IAIlB,0BAA0B,CACxB,UAAU,EAAE,UAAU,EACtB,OAAO,KAAK,GACX,OAAO,CAAC,2BAA2B,CAAC;IAQvC,kBAAkB;IAclB;;;;OAIG;IACH,eAAe,CACb,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,IAAI,EAAE,MAAM;IASd;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM;IAUhE;;;;OAIG;IACH,MAAM;IAIN,0BAA0B,CACxB,SAAS,EAAE,SAAS,EACpB,aAAa,GAAE,OAAe;IAahC;;;;;OAKG;IACH,SAAS;IAQT;;;;;OAKG;IACH,cAAc,CACZ,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,aAAa,EACpB,UAAU,EAAE,UAAU;CAOzB;AAED,eAAe,aAAa,CAAC"}

package/mapbox/layers/RealtimeLayer.js

@@ -23,6 +23,7 @@ import { getSourceCoordinates, getMercatorResolution } from '../utils';
  * @extends {Layer}
  * @implements {RealtimeLayerInterface}
  */
+// @ts-ignore
 class RealtimeLayer extends mixin(Layer) {
     constructor(options = {}) {
         super(Object.assign({}, options));
@@ -44,15 +45,12 @@ class RealtimeLayer extends mixin(Layer) {
      * @param {string} beforeId Layer's id before which we want to add the new layer.
      * @override
      */
+    // @ts-ignore
     attachToMap(map, beforeId) {
         if (!map) {
             return;
         }
-        const canvas = map.getCanvas();
-        super.attachToMap(map, {
-            width: canvas.width / this.pixelRatio,
-            height: canvas.height / this.pixelRatio,
-        });
+        super.attachToMap(map);
         this.source = {
             type: 'canvas',
             canvas: this.canvas,
@@ -87,6 +85,7 @@ class RealtimeLayer extends mixin(Layer) {
     detachFromMap() {
         if (this.map) {
             this.map.off('load', this.onLoad);
+            // @ts-ignore
             this.listeners.forEach((listener) => {
                 unByKey(listener);
             });
@@ -145,10 +144,14 @@ class RealtimeLayer extends mixin(Layer) {
      * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
      * @overrides
      */
-    renderTrajectories(noInterpolate) {
+    // @ts-ignore
+    renderTrajectories(noInterpolate = false) {
         if (!this.map) {
             return;
         }
+        if (!this.pixelRatio) {
+            this.pixelRatio = 1;
+        }
         const { width, height } = this.map.getCanvas();
         const center = this.map.getCenter();
         // We use turf here to have good transform.
@@ -156,7 +159,10 @@ class RealtimeLayer extends mixin(Layer) {
             x: 0,
             y: height / this.pixelRatio,
         }); // southWest
-        const rightTop = this.map.unproject({ x: width / this.pixelRatio, y: 0 }); // north east
+        const rightTop = this.map.unproject({
+            x: width / this.pixelRatio,
+            y: 0,
+        }); // north east
         const coord0 = transformRotate(point([leftBottom.lng, leftBottom.lat]), -this.map.getBearing(), {
             pivot: [center.lng, center.lat],
         }).geometry.coordinates;
@@ -231,7 +237,7 @@ class RealtimeLayer extends mixin(Layer) {
     onMove() {
         this.renderTrajectories();
     }
-    renderTrajectoriesInternal(viewState, noInterpolate) {
+    renderTrajectoriesInternal(viewState, noInterpolate = false) {
         const render = super.renderTrajectoriesInternal(viewState, noInterpolate);
         if (render && this.map.style) {
             const extent = getSourceCoordinates(this.map, this.pixelRatio);

package/mapbox/utils/getMercatorResolution.d.ts

@@ -0,0 +1,9 @@
+import { AnyMapboxMap } from '../../types';
+/**
+ * Get the current resolution of a Mapbox map.
+ * @param {mapboxgl.Map} map A map object.
+ * @private
+ */
+declare const getMercatorResolution: (map: AnyMapboxMap) => number;
+export default getMercatorResolution;
+//# sourceMappingURL=getMercatorResolution.d.ts.map

package/mapbox/utils/getMercatorResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMercatorResolution.d.ts","sourceRoot":"","sources":["../../../src/mapbox/utils/getMercatorResolution.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;GAIG;AACH,QAAA,MAAM,qBAAqB,QAAS,YAAY,WAS/C,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/mapbox/utils/getMercatorResolution.js

@@ -0,0 +1,18 @@
+import { getWidth, getHeight } from 'ol/extent';
+import { fromLonLat } from 'ol/proj';
+/**
+ * Get the current resolution of a Mapbox map.
+ * @param {mapboxgl.Map} map A map object.
+ * @private
+ */
+const getMercatorResolution = (map) => {
+    const bounds = map.getBounds().toArray();
+    const a = fromLonLat(bounds[0]);
+    const b = fromLonLat(bounds[1]);
+    const extent = [...a, ...b];
+    const { width, height } = map.getCanvas();
+    const xResolution = getWidth(extent) / width;
+    const yResolution = getHeight(extent) / height;
+    return Math.max(xResolution, yResolution);
+};
+export default getMercatorResolution;

package/mapbox/utils/getSourceCoordinates.d.ts

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

package/mapbox/utils/getSourceCoordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSourceCoordinates.d.ts","sourceRoot":"","sources":["../../../src/mapbox/utils/getSourceCoordinates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAC1B,YAAY,eACL,MAAM,eAsBnB,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/mapbox/{utils.js → utils/getSourceCoordinates.js}

@@ -1,34 +1,21 @@
-import { getWidth, getHeight } from 'ol/extent';
-import { fromLonLat } from 'ol/proj';
-/**
- * Get the current resolution of a Mapbox map.
- * @param {mapboxgl.Map} map A map object.
- * @private
- */
-export const getMercatorResolution = (map) => {
-    const bounds = map.getBounds().toArray();
-    const a = fromLonLat(bounds[0]);
-    const b = fromLonLat(bounds[1]);
-    const extent = [...a, ...b];
-    const { width, height } = map.getCanvas();
-    const xResolution = getWidth(extent) / width;
-    const yResolution = getHeight(extent) / height;
-    return Math.max(xResolution, yResolution);
-};
 /**
  * Get the canvas source coordinates of the current map's extent.
  * @param {mapboxgl.Map} map A map object.
  * @private
  */
-export const getSourceCoordinates = (map, pixelRatio) => {
+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 leftTop = map.unproject({ x: 0, y: 0 });
+    // @ts-ignore
     const leftBottom = map.unproject({ x: 0, y: height / pixelRatio }); // southWest
+    // @ts-ignore
     const rightBottom = map.unproject({
         x: width / pixelRatio,
         y: height / pixelRatio,
     });
+    // @ts-ignore
     const rightTop = map.unproject({ x: width / pixelRatio, y: 0 }); // north east
     return [
         [leftTop.lng, leftTop.lat],
@@ -37,7 +24,4 @@ export const getSourceCoordinates = (map, pixelRatio) => {
         [leftBottom.lng, leftBottom.lat],
     ];
 };
-export default {
-    getMercatorResolution,
-    getSourceCoordinates,
-};
+export default getSourceCoordinates;

package/mapbox/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { default as getSourceCoordinates } from "./getSourceCoordinates";
+export { default as getMercatorResolution } from "./getMercatorResolution";
+//# sourceMappingURL=index.d.ts.map

package/mapbox/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mapbox/utils/index.js"],"names":[],"mappings":""}

package/mapbox/utils/index.js

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