mobility-toolbox-js 3.0.0-beta.1 → 3.0.0-beta.10

package/api/HttpAPI.d.ts

@@ -0,0 +1,20 @@
+export type HttpAPIOptions = {
+    url: string;
+    apiKey?: string;
+};
+/**
+ * Common class to access to a geOps api using http.
+ * @private
+ */
+declare class HttpAPI {
+    url: string;
+    apiKey?: string;
+    constructor(options: HttpAPIOptions);
+    /**
+     * Append the apiKey before sending the request.
+     *
+     * @private
+     */
+    fetch(path: string, params: Object, config: RequestInit): Promise<any>;
+}
+export default HttpAPI;

package/api/HttpAPI.js

@@ -10,17 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import getUrlWithParams from '../common/utils/getUrlWithParams';
 /**
  * Common class to access to a geOps api using http.
- *
- * @example
- * import { API } from 'mobility-toolbox-js/api';
- *
- * const api = new HttpApi({
- *   url: [yourUrl],
- *   apiKey: [yourApiKey]
- * });
- *
- * @classproperty {string} url Url of the service.
- * @classproperty {string} apiKey Api key to access the service.
  * @private
  */
 class HttpAPI {
@@ -47,6 +36,7 @@ class HttpAPI {
             // Clean requets parameters, removing undefined and null values.
             const searchParams = params || {};
             const url = getUrlWithParams(`${this.url}${path || ''}`, Object.assign({ key: this.apiKey }, searchParams));
+            fetch;
             const response = yield fetch(url.toString(), config);
             const data = yield response.json();
             if (data.error) {

package/api/RealtimeAPI.d.ts

@@ -0,0 +1,365 @@
+import WebSocketAPI, { WebSocketAPIMessageCallback, WebSocketAPIMessageEventData, WebSocketAPIParameters } from './WebSocketAPI';
+import type { RealtimeMode, RealtimeDeparture, RealtimeNews, RealtimeStation, RealtimeExtraGeom, RealtimeTrainId, RealtimeGeneralizationLevel, RealtimeFullTrajectory, RealtimeTrajectoryResponse, RealtimeStationId, RealtimeVersion, RealtimeTrajectory, RealtimeTenant, RealtimeBbox } from '../types';
+import { StopSequence } from './typedefs';
+/**
+ * @typedef RealtimeAPIOptions
+ */
+export type RealtimeAPIOptions = {
+    url?: string;
+    apiKey?: string;
+    version?: RealtimeVersion;
+    bbox?: RealtimeBbox;
+    buffer?: number[];
+    pingIntervalMs?: number;
+    reconnectTimeoutMs?: number;
+};
+export declare type RealtimeAPIExtraGeomsById = {
+    [index: string]: RealtimeExtraGeom;
+};
+export type RealtimeAPIDeparturesById = {
+    [index: string]: RealtimeDeparture;
+};
+export type RealtimeModesType = {
+    RAW: RealtimeMode;
+    TOPOGRAPHIC: RealtimeMode;
+    SCHEMATIC: RealtimeMode;
+};
+/**
+ * Enum for Realtime modes.
+ * @readonly
+ * @typedef {string} RealtimeMode
+ * @property {string} RAW "raw"
+ * @property {string} SCHEMATIC "schematic"
+ * @property {string} TOPOGRAPHIC "topographic"
+ * @enum {RealtimeMode}
+ * @public
+ */
+export declare const RealtimeModes: {
+    RAW: RealtimeMode;
+    TOPOGRAPHIC: RealtimeMode;
+    SCHEMATIC: RealtimeMode;
+};
+/**
+ * This class provides convenience methods to use to the [geOps realtime API](https://developer.geops.io/apis/realtime/).
+ *
+ * @example
+ * import { RealtimeAPI } from 'mobility-toolbox-js/api';
+ *
+ * const api = new RealtimeAPI({
+ *   apiKey: "yourApiKey",
+ *   bbox: [782001, 5888803, 923410, 5923660, 11, "mots=rail"],
+ *   // url: "wss://api.geops.io/tracker-ws/v1/",
+ * });
+ *
+ * // Open the websocket connection
+ * api.open();
+ *
+ * // Subscribe to channel
+ * api.subscribeTrajectory('topographic', (data) => {
+ *    console.log('Log trajectories:', JSON.stringify(data.content));
+ * });
+ *
+ * // Close the websocket connection
+ * // api.close();
+ *
+ * @public
+ */
+declare class RealtimeAPI {
+    _url: string;
+    get url(): string;
+    set url(newUrl: string);
+    _bbox?: RealtimeBbox;
+    /**
+     * The bounding box to receive data from.\
+     * Example: [minX, minY, maxX, maxY, zoom, mots , gen_level, tenant, ...]\
+     *  \
+     * Where:
+     * - **minX**: a string representation of an integer (not a float) representing the minimal X coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **minY**: a string representation of an integer (not a float) representing the minimal Y coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **maxX**: a string representation of an integer (not a float) representing the maximal X coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **maxY**: a string representation of an integer (not a float) representing the maximal Y coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **zoom**: a string representation of an integer representing the zoom level (from 4 to 22). When zoom < 8 only the trains are displayed for performance reasons.\
+     * &nbsp;
+     * - **mots**: A comma separated list of modes of transport. **Optional**.\
+     *         Example: "mots=rail,subway".\
+     * &nbsp;
+     * - **gen_level**: An integer representing the generalization level. **Optional**.\
+     *              Example: "gen_level=5"\
+     * &nbsp;
+     * - **tenant**: A string representing the tenant. **Optional**.\
+     *           Example: "tenant=sbb"\
+     * &nbsp;
+     * - ...: Any other values added to the bbox will be send to the server
+     *
+     * @type {string[]}
+     *
+     * @public
+     */
+    get bbox(): RealtimeBbox | undefined;
+    set bbox(newBbox: RealtimeBbox | undefined);
+    _buffer?: number[];
+    get buffer(): number[] | undefined;
+    set buffer(newBuffer: number[] | undefined);
+    version: RealtimeVersion;
+    wsApi: WebSocketAPI;
+    private pingInterval;
+    private pingIntervalMs;
+    private reconnectTimeout?;
+    private reconnectTimeoutMs?;
+    /**
+     * Constructor
+     *
+     * @param {Object} options Options.
+     * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {string[]} options.bbox The bounding box to receive data from.
+     * @param {string} [options.url='wss://api.geops.io/tracker-ws/v1/'] Url of the [geOps realtime API](https://developer.geops.io/apis/realtime/).
+     * @public
+     */
+    constructor(options?: RealtimeAPIOptions);
+    /**
+     * Open the websocket connection.
+     *
+     * @public
+     */
+    open(): void;
+    /**
+     * Close the websocket connection without reconnection.
+     *
+     * @public
+     */
+    close(): void;
+    /**
+     * Unsubscribe trajectory and deleted_vehicles channels. To resubscribe you have to set a new BBOX.
+     */
+    reset(): void;
+    /**
+     * Callback when the websocket is opened and ready.
+     * It applies the bbox and the projection.
+     * @private
+     */
+    onOpen(): void;
+    /**
+     * Callback when the websocket is closed by the server.
+     * It auto reconnects after a timeout.
+     * @private
+     */
+    onClose(): void;
+    /**
+     * Send GET to a channel.
+     *
+     * @param {string | WebSocketAPIParameters} channelOrParams Name of the websocket channel to send GET or an object representing parameters to send
+     * @return {Promise<WebSocketAPIMessageEventData<?>>} A websocket response.
+     */
+    get(channelOrParams: string | WebSocketAPIParameters): Promise<WebSocketAPIMessageEventData<any>>;
+    /**
+     * Subscribe to a channel.
+     *
+     * @param {string} channel Name of the websocket channel to subscribe.
+     * @param {function} onSuccess Callback when the subscription succeeds.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @private
+     */
+    subscribe(channel: string, onSuccess: WebSocketAPIMessageCallback<any>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe both modes of a channel.
+     *
+     * @param {string} channel Name of the websocket channel to unsubscribe.
+     * @param {string} suffix Suffix to add to the channel name.
+     * @param {function} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @private
+     */
+    unsubscribe(channel: string, suffix?: string, onMessage?: WebSocketAPIMessageCallback<any>): void;
+    /**
+     * Subscribe to departures channel of a given station.
+     *
+     * @param {number} stationId UIC of the station.
+     * @param {Boolean} sortByMinArrivalTime Sort by minimum arrival time
+     * @param {function(departures:Departure[])} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @public
+     */
+    subscribeDepartures(stationId: number, onMessage: WebSocketAPIMessageCallback<RealtimeDeparture>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe from current departures channel.
+     * @param {RealtimeStationId} id Station's id
+     * @param {function(data: { content: RealtimeDeparture[] })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @public
+     */
+    unsubscribeDepartures(id: RealtimeStationId, onMessage?: WebSocketAPIMessageCallback<RealtimeDeparture>): void;
+    /**
+     * Subscribe to the disruptions channel for tenant.
+     *
+     * @param {function(data: { content: RealtimeNews[] })} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @public
+     */
+    subscribeDisruptions(tenant: RealtimeTenant, onMessage: WebSocketAPIMessageCallback<RealtimeNews>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe disruptions.
+     *
+     * @param {function(data: { content: RealtimeNews[] })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @public
+     */
+    unsubscribeDisruptions(tenant: RealtimeTenant, onMessage?: WebSocketAPIMessageCallback<RealtimeNews>): void;
+    /**
+     * Return a station with a given uic number and a mode.
+     *
+     * @param {number} uic UIC of the station.
+     * @param {RealtimeMode} mode Realtime mode.
+     * @return {Promise<{data: { content: RealtimeStation }}>} A station.
+     * @public
+     */
+    getStation(uic: RealtimeStationId, mode: RealtimeMode): Promise<WebSocketAPIMessageEventData<RealtimeStation>>;
+    /**
+     * Get the list of ststions available for a specifc mode. The promise is resolved every 100ms
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {number} timeout = 100 Duration in ms between each promise resolve calls.
+     * @return {Promise<RealtimeStation[]>} An array of stations.
+     * @public
+     */
+    getStations(mode: RealtimeMode, timeout?: number): Promise<RealtimeStation[]>;
+    /**
+     * Subscribe to stations channel.
+     * One message pro station.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(data: { content: RealtimeStation })} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @public
+     */
+    subscribeStations(mode: RealtimeMode, onMessage: WebSocketAPIMessageCallback<RealtimeStation>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe to stations channel.
+     * @param {function(data: { content: RealtimeStation })} onMessage The listener callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribe.
+     * @public
+     */
+    unsubscribeStations(onMessage?: WebSocketAPIMessageCallback<RealtimeStation>): void;
+    /**
+     * Subscribe to extra_geoms channel.
+     *
+     * @param {function(data: { content: RealtimeExtraGeom })} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     */
+    subscribeExtraGeoms(onMessage: WebSocketAPIMessageCallback<RealtimeExtraGeom>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe to extra_geoms channel.
+     * @param {function(data: { content: RealtimeExtraGeom })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    unsubscribeExtraGeoms(onMessage: WebSocketAPIMessageCallback<RealtimeExtraGeom>): void;
+    /**
+     * Return a partial trajectory with a given id and a mode.
+     *
+     * @param {number} trainId The identifier of a trajectory.
+     * @param {RealtimeMode} mode Realtime mode.
+     * @return {Promise<{data: { content: RealtimeTrajectory }}>} A trajectory.
+     * @public
+     */
+    getTrajectory(id: RealtimeTrainId, mode: RealtimeMode): Promise<WebSocketAPIMessageEventData<RealtimeTrajectory>>;
+    /**
+     * Subscribe to trajectory channel.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(data: { content: RealtimeTrajectoryResponse[] })} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @public
+     */
+    subscribeTrajectory(mode: RealtimeMode, onMessage: WebSocketAPIMessageCallback<RealtimeTrajectoryResponse[] | RealtimeTrajectoryResponse>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe to trajectory channels.
+     * @param {function(data: { content: RealtimeTrajectoryResponse[] })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @public
+     */
+    unsubscribeTrajectory(onMessage: WebSocketAPIMessageCallback<RealtimeTrajectoryResponse[]>): void;
+    /**
+     * Subscribe to deleted_vhicles channel.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(data: { content: RealtimeTrainId })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     */
+    subscribeDeletedVehicles(mode: RealtimeMode, onMessage: WebSocketAPIMessageCallback<RealtimeTrainId>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe to deleted_vhicles channels.
+     * @param {function(data: { content: RealtimeTrainId })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    unsubscribeDeletedVehicles(onMessage: WebSocketAPIMessageCallback<RealtimeTrainId>): void;
+    /**
+     * Get a full trajectory of a vehicule .
+     *
+     * @param {string} id A vehicle id.
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {string} generalizationLevel The generalization level to request. Can be one of 5 (more generalized), 10, 30, 100, undefined (less generalized).
+     * @return {Promise<{ data: { content: RealtimeFullTrajectory } }>} Return a full trajectory.
+     * @public
+     */
+    getFullTrajectory(id: RealtimeTrainId, mode: RealtimeMode, generalizationLevel: RealtimeGeneralizationLevel | undefined): Promise<WebSocketAPIMessageEventData<RealtimeFullTrajectory>>;
+    /**
+     * Subscribe to full_trajectory channel of a given vehicle.
+     *
+     * @param {string} id A vehicle id.
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(data: { content: RealtimeFullTrajectory })} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @public
+     */
+    subscribeFullTrajectory(id: RealtimeTrainId, mode: RealtimeMode, onMessage: WebSocketAPIMessageCallback<RealtimeFullTrajectory>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe from full_trajectory channel
+     *
+     * @param {string} id A vehicle id.
+     * @param {function(data: { content: RealtimeFullTrajectory })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @public
+     */
+    unsubscribeFullTrajectory(id: RealtimeTrainId, onMessage?: WebSocketAPIMessageCallback<RealtimeFullTrajectory>): void;
+    /**
+     * Get the list of stops for this vehicle.
+     *
+     * @param {string} id A vehicle id.
+     * @return {Promise<{ data: { content: StopSequence[] } }>} Returns a stop sequence object.
+     * @public
+     */
+    getStopSequence(id: RealtimeTrainId): Promise<WebSocketAPIMessageEventData<StopSequence[]>>;
+    /**
+     * Subscribe to stopsequence channel of a given vehicle.
+     *
+     * @param {string} id A vehicle id.
+     * @param {function(data: { content: StopSequence[] })} onMessage Function called on each message of the channel.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     * @public
+     */
+    subscribeStopSequence(id: RealtimeTrainId, onMessage: WebSocketAPIMessageCallback<StopSequence[]>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe from stopsequence channel
+     *
+     * @param {string} id A vehicle id.
+     * @param {function(data: { content: StopSequence[] })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @public
+     */
+    unsubscribeStopSequence(id: RealtimeTrainId, onMessage?: WebSocketAPIMessageCallback<StopSequence[]>): void;
+    /**
+     * Subscribe to healthcheck channel.
+     * @param {function(data: { content: string })} onMessage Callback when the subscribe to healthcheck channel succeeds.
+     * @param {function} onError Callback when the subscription fails.
+     * @param {boolean} [quiet=false] If true avoid to store the subscription in the subscriptions list.
+     */
+    subscribeHealthCheck(onMessage: WebSocketAPIMessageCallback<string>, onError?: EventListener, quiet?: boolean): void;
+    /**
+     * Unsubscribe to healthcheck channel.
+     * @param {function(data: { content: string })} onMessage Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    unsubscribeHealthCheck(onMessage?: WebSocketAPIMessageCallback<string>): void;
+}
+export default RealtimeAPI;

package/api/RealtimeAPI.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-underscore-dangle */
 /* eslint-disable class-methods-use-this */
 import WebSocketAPI from './WebSocketAPI';
 import debounceWebsocketMessages from '../common/utils/debounceWebsocketMessages';
@@ -10,6 +11,7 @@ import getModeSuffix from '../common/utils/getRealtimeModeSuffix';
  * @property {string} SCHEMATIC "schematic"
  * @property {string} TOPOGRAPHIC "topographic"
  * @enum {RealtimeMode}
+ * @public
  */
 export const RealtimeModes = {
     RAW: 'raw',
@@ -17,123 +19,135 @@ export const RealtimeModes = {
     SCHEMATIC: 'schematic',
 };
 /**
- * This class provides convenience methods to use to the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
+ * This class provides convenience methods to use to the [geOps realtime API](https://developer.geops.io/apis/realtime/).
  *
  * @example
  * import { RealtimeAPI } from 'mobility-toolbox-js/api';
  *
  * const api = new RealtimeAPI({
  *   apiKey: "yourApiKey",
- *   bbox: [782001, 5888803, 923410, 5923660, 11, "mots=rail],
+ *   bbox: [782001, 5888803, 923410, 5923660, 11, "mots=rail"],
  *   // url: "wss://api.geops.io/tracker-ws/v1/",
  * });
  *
+ * // Open the websocket connection
  * api.open();
  *
+ * // Subscribe to channel
  * api.subscribeTrajectory('topographic', (data) => {
  *    console.log('Log trajectories:', JSON.stringify(data.content));
  * });
  *
- * @classproperty {string} apiKey - Access key for [geOps APIs](https://developer.geops.io/)
- * @classproperty {RealtimeBbox} bbox - The bounding box to receive data from. \ Example: \ [ minX, minY, maxX, maxY, zoom, "tenant=tenant1", "gen_level=5", "mots=mot1,mot2" ]. \ tenant, gen_level and mots are optional.
- * @classproperty {string} url - The [geOps Realtime API](https://developer.geops.io/apis/realtime/) url.
+ * // Close the websocket connection
+ * // api.close();
+ *
  * @public
  */
 class RealtimeAPI {
+    get url() {
+        return this._url;
+    }
+    set url(newUrl) {
+        if (this._url !== newUrl) {
+            this._url = newUrl;
+            // Update the websocket only if the url has changed and the websocket is already open or is opening.
+            if (this.wsApi.open || this.wsApi.connecting) {
+                this.open();
+            }
+        }
+    }
+    /**
+     * The bounding box to receive data from.\
+     * Example: [minX, minY, maxX, maxY, zoom, mots , gen_level, tenant, ...]\
+     *  \
+     * Where:
+     * - **minX**: a string representation of an integer (not a float) representing the minimal X coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **minY**: a string representation of an integer (not a float) representing the minimal Y coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **maxX**: a string representation of an integer (not a float) representing the maximal X coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **maxY**: a string representation of an integer (not a float) representing the maximal Y coordinate (in EPSG:3857) of a bounding box\
+     *  
+     * - **zoom**: a string representation of an integer representing the zoom level (from 4 to 22). When zoom < 8 only the trains are displayed for performance reasons.\
+     * &nbsp;
+     * - **mots**: A comma separated list of modes of transport. **Optional**.\
+     *         Example: "mots=rail,subway".\
+     * &nbsp;
+     * - **gen_level**: An integer representing the generalization level. **Optional**.\
+     *              Example: "gen_level=5"\
+     * &nbsp;
+     * - **tenant**: A string representing the tenant. **Optional**.\
+     *           Example: "tenant=sbb"\
+     * &nbsp;
+     * - ...: Any other values added to the bbox will be send to the server
+     *
+     * @type {string[]}
+     *
+     * @public
+     */
+    get bbox() {
+        return this._bbox;
+    }
+    set bbox(newBbox) {
+        if (JSON.stringify(newBbox) !== JSON.stringify(this._bbox)) {
+            this._bbox = newBbox;
+            if (this.wsApi && this._bbox) {
+                this.wsApi.send(`BBOX ${this._bbox.join(' ')}`);
+            }
+        }
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    set buffer(newBuffer) {
+        if (JSON.stringify(newBuffer) !== JSON.stringify(this._buffer)) {
+            this._buffer = newBuffer;
+            if (this.wsApi && this._buffer) {
+                this.wsApi.send(`BUFFER ${this._buffer.join(' ')}`);
+            }
+        }
+    }
     /**
      * Constructor
      *
-     * @param {RealtimeAPIOptions} options A string representing the url of the service or an object containing the url and the apiKey.
-     * @param {string} options.url Url to the [geOps realtime api](https://developer.geops.io/apis/realtime/).
+     * @param {Object} options Options.
      * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
-     * @param {number[5]} [options.bbox=[minX, minY, maxX, maxY, zoom, tenant]] The bounding box to receive data from.
+     * @param {string[]} options.bbox The bounding box to receive data from.
+     * @param {string} [options.url='wss://api.geops.io/tracker-ws/v1/'] Url of the [geOps realtime API](https://developer.geops.io/apis/realtime/).
+     * @public
      */
     constructor(options = {}) {
         this.version = '2';
-        this.defineProperties(options);
-        this.onOpen = this.onOpen.bind(this);
-    }
-    defineProperties(options = {}) {
-        let opt = options || {};
+        let opt = options;
         if (typeof options === 'string') {
             opt = { url: options };
         }
-        const { apiKey, version } = opt;
-        let { url, bbox, buffer = [100, 100] } = opt;
+        const { apiKey } = opt;
+        const { url } = opt;
         const wsApi = new WebSocketAPI();
-        if (!url) {
-            url = 'wss://api.geops.io/tracker-ws/v1/';
-        }
-        if (apiKey) {
-            url = `${url}?key=${apiKey}`;
+        let suffix = '';
+        if (apiKey && !(url === null || url === void 0 ? void 0 : url.includes('key='))) {
+            suffix = `?key=${apiKey}`;
         }
-        Object.defineProperties(this, {
-            url: {
-                get: () => url,
-                set: (newUrl) => {
-                    if (url !== newUrl) {
-                        url = newUrl;
-                        // Update the websocket only if the url has changed and the websocket is already open or is opening.
-                        if (this.wsApi.open || this.wsApi.connecting) {
-                            this.open();
-                        }
-                    }
-                },
-            },
-            bbox: {
-                get: () => bbox,
-                set: (newBbox) => {
-                    if (JSON.stringify(newBbox) !== JSON.stringify(bbox)) {
-                        bbox = newBbox;
-                        if (this.wsApi && bbox) {
-                            this.wsApi.send(`BBOX ${bbox.join(' ')}`);
-                        }
-                    }
-                },
-            },
-            buffer: {
-                get: () => buffer,
-                set: (newBuffer) => {
-                    if (JSON.stringify(newBuffer) !== JSON.stringify(buffer)) {
-                        buffer = newBuffer;
-                        if (this.wsApi) {
-                            this.wsApi.send(`BUFFER ${buffer.join(' ')}`);
-                        }
-                    }
-                },
-            },
-            version: {
-                value: version,
-                writable: true,
-            },
-            /**
-             * The websocket helper class to connect the websocket.
-             *
-             * @private
-             */
-            wsApi: {
-                value: wsApi,
-                writable: true,
-            },
-            /**
-             * Interval between PING request in ms.
-             * If equal to 0,  no PING request are sent.
-             * @type {number}
-             * @private
-             */
-            pingIntervalMs: {
-                value: options.pingIntervalMs || 10000,
-                writable: true,
-            },
-            /**
-             * Timeout in ms after an automatic reconnection when the websoscket has been closed by the server.
-             * @type {number}
-             */
-            reconnectTimeoutMs: {
-                value: options.pingIntervalMs || 100,
-                writable: true,
-            },
-        });
+        this._url = (url || 'wss://api.geops.io/tracker-ws/v1/') + suffix;
+        this._buffer = opt.buffer || [100, 100];
+        this.version = opt.version || '2';
+        /**
+         * Interval between PING request in ms.
+         * If equal to 0,  no PING request are sent.
+         * @type {number}
+         */
+        this.pingIntervalMs = opt.pingIntervalMs || 10000;
+        /**
+         * Timeout in ms after an automatic reconnection when the websoscket has been closed by the server.
+         * @type {number}
+         */
+        this.reconnectTimeoutMs = opt.reconnectTimeoutMs || 100;
+        /**
+         * The websocket helper class to connect the websocket.
+         */
+        this.wsApi = wsApi;
     }
     /**
      * Open the websocket connection.
@@ -141,7 +155,7 @@ class RealtimeAPI {
      * @public
      */
     open() {
-        this.wsApi.connect(this.url, this.onOpen);
+        this.wsApi.connect(this.url, this.onOpen.bind(this));
         // Register reconnection on close.
         if (this.wsApi.websocket) {
             this.wsApi.websocket.onclose = () => {
@@ -160,7 +174,6 @@ class RealtimeAPI {
     /**
      * Unsubscribe trajectory and deleted_vehicles channels. To resubscribe you have to set a new BBOX.
      */
-    // eslint-disable-next-line class-methods-use-this
     reset() {
         this.wsApi.send('RESET');
     }