mobility-toolbox-js 2.0.0-beta.33 → 2.0.0-beta.34

package/api/RealtimeAPI.js

@@ -0,0 +1,640 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeModes = void 0;
+var WebSocketAPI_1 = require("../common/api/WebSocketAPI");
+var cleanStopTime_1 = require("../common/utils/cleanStopTime");
+var getRealtimeModeSuffix_1 = require("../common/utils/getRealtimeModeSuffix");
+var compareDepartures_1 = require("../common/utils/compareDepartures");
+/**
+ * Enum for Realtime modes.
+ * @readonly
+ * @typedef {string} RealtimeMode
+ * @property {string} RAW "raw"
+ * @property {string} SCHEMATIC "schematic"
+ * @property {string} TOPOGRAPHIC "topographic"
+ * @enum {RealtimeMode}
+ */
+exports.RealtimeModes = {
+    RAW: 'raw',
+    TOPOGRAPHIC: 'topographic',
+    SCHEMATIC: 'schematic',
+};
+/**
+ * This class provides convenience methods to access to the [geOps realtime api](https://developer.geops.io/apis/realtime/).
+ *
+ * @example
+ * import { RealtimeAPI } from 'mobility-toolbox-js/api';
+ *
+ * const api = new RealtimeAPI({
+ *   url: "yourUrl",
+ *   apiKey: "yourApiKey"
+ * });
+ *
+ * @example
+ * import { RealtimeAPI } from 'mobility-toolbox-js/api';
+ *
+ * const api = new RealtimeAPI("yourUrl");
+ */
+var RealtimeAPI = /** @class */ (function () {
+    /**
+     * Constructor
+     *
+     * @param {Object|string} 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 {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {string} [options.prefix=''] Service prefix to specify tenant.
+     * @param {string} [options.projection] The epsg code of the projection for features. Default to EPSG:3857.
+     * @param {number[4]} [options.bbox=[minX, minY, maxX, maxY, zoom, tenant] The bounding box to receive data from.
+     */
+    function RealtimeAPI(options) {
+        if (options === void 0) { options = {}; }
+        this.defineProperties(options);
+        /** @ignore */
+        this.subscribedStationUic = null;
+        /** @ignore */
+        this.departureUpdateTimeout = null;
+        /** @ignore */
+        this.maxDepartureAge = 30;
+        /** @ignore */
+        this.extraGeoms = {};
+        /** @ignore */
+        this.prefix = options.prefix || '';
+        /** @ignore */
+        this.onOpen = this.onOpen.bind(this);
+    }
+    RealtimeAPI.prototype.defineProperties = function (options) {
+        var _this = this;
+        var opt = options;
+        if (typeof options === 'string') {
+            opt = { url: options };
+        }
+        var apiKey = opt.apiKey;
+        var url = opt.url, projection = opt.projection, bbox = opt.bbox, _a = opt.buffer, buffer = _a === void 0 ? [100, 100] : _a;
+        var wsApi = new WebSocketAPI_1.default();
+        if (apiKey) {
+            url = "".concat(url || 'wss://api.geops.io/tracker-ws/v1/', "?key=").concat(apiKey);
+        }
+        Object.defineProperties(this, {
+            url: {
+                get: function () { return url; },
+                set: function (newUrl) {
+                    url = newUrl;
+                    _this.open();
+                },
+            },
+            projection: {
+                get: function () { return projection; },
+                set: function (newProjection) {
+                    if (newProjection !== projection) {
+                        projection = newProjection;
+                        if (_this.wsApi) {
+                            _this.wsApi.send("PROJECTION ".concat(projection));
+                        }
+                    }
+                },
+            },
+            bbox: {
+                get: function () { return bbox; },
+                set: function (newBbox) {
+                    if (JSON.stringify(newBbox) !== JSON.stringify(bbox)) {
+                        bbox = newBbox;
+                        if (_this.wsApi) {
+                            _this.wsApi.send("BBOX ".concat(bbox.join(' ')));
+                        }
+                    }
+                },
+            },
+            buffer: {
+                get: function () { return buffer; },
+                set: function (newBuffer) {
+                    if (JSON.stringify(newBuffer) !== JSON.stringify(buffer)) {
+                        buffer = newBuffer;
+                        if (_this.wsApi) {
+                            _this.wsApi.send("BUFFER ".concat(buffer.join(' ')));
+                        }
+                    }
+                },
+            },
+            /**
+             * 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,
+            },
+        });
+    };
+    RealtimeAPI.prototype.open = function () {
+        var _this = this;
+        this.close();
+        // Register BBOX and PROJECTION messages must be send before previous subscriptions.
+        this.wsApi.connect(this.url, this.onOpen);
+        // Register reconnection on close.
+        this.wsApi.websocket.onclose = function () {
+            _this.onClose();
+        };
+    };
+    /**
+     * Close the websocket connection without reconnection.
+     */
+    RealtimeAPI.prototype.close = function () {
+        this.wsApi.close();
+    };
+    /**
+     * Unsubscribe trajectory and deleted_vehicles channels. To resubscribe you have to set a new BBOX.
+     */
+    // eslint-disable-next-line class-methods-use-this
+    RealtimeAPI.prototype.reset = function () {
+        this.wsApi.send('RESET');
+    };
+    /**
+     * Callback when the websocket is opened and ready.
+     * It applies the bbox and the projection.
+     */
+    RealtimeAPI.prototype.onOpen = function () {
+        var _this = this;
+        if (this.projection) {
+            this.wsApi.send("PROJECTION ".concat(this.projection));
+        }
+        if (this.bbox) {
+            this.wsApi.send("BBOX ".concat(this.bbox.join(' ')));
+        }
+        if (this.buffer) {
+            this.wsApi.send("BUFFER ".concat(this.buffer.join(' ')));
+        }
+        /**
+         * Keep websocket alive
+         */
+        if (this.pingIntervalMs) {
+            window.clearInterval(this.pingInterval);
+            /** @ignore */
+            this.pingInterval = setInterval(function () {
+                _this.wsApi.send('PING');
+            }, this.pingIntervalMs);
+        }
+    };
+    /**
+     * Callback when the websocket is closed by the server.
+     * It auto reconnects after a timeout.
+     */
+    RealtimeAPI.prototype.onClose = function () {
+        var _this = this;
+        window.clearTimeout(this.pingInterval);
+        window.clearTimeout(this.reconnectTimeout);
+        if (this.reconnectTimeoutMs) {
+            /** @ignore */
+            this.reconnectTimeout = window.setTimeout(function () { return _this.open(); }, this.reconnectTimeoutMs);
+        }
+    };
+    /**
+     * 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
+     */
+    RealtimeAPI.prototype.subscribe = function (channel, onSuccess, onError, quiet) {
+        if (quiet === void 0) { quiet = false; }
+        this.wsApi.subscribe({ channel: channel }, onSuccess, onError, quiet);
+    };
+    /**
+     * 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} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     * @private
+     */
+    RealtimeAPI.prototype.unsubscribe = function (channel, suffix, cb) {
+        this.wsApi.unsubscribe("".concat(channel).concat((0, getRealtimeModeSuffix_1.default)(exports.RealtimeModes.SCHEMATIC, exports.RealtimeModes)).concat(suffix), cb);
+        this.wsApi.unsubscribe("".concat(channel).concat((0, getRealtimeModeSuffix_1.default)(exports.RealtimeModes.TOPOGRAPHIC, exports.RealtimeModes)).concat(suffix || ''), cb);
+    };
+    /**
+     * Filter departures and return an array.
+     *
+     * @param {Object} depObject The object containing departures by id.
+     * @param {boolean} [sortByMinArrivalTime=false] If true sort departures by arrival time.
+     * @return {Array<departure>} Return departures array.
+     * @private
+     */
+    RealtimeAPI.prototype.filterDepartures = function (depObject, sortByMinArrivalTime) {
+        if (sortByMinArrivalTime === void 0) { sortByMinArrivalTime = false; }
+        var departures = Object.keys(depObject).map(function (k) { return depObject[k]; });
+        departures.sort(function (a, b) { return (0, compareDepartures_1.default)(a, b, sortByMinArrivalTime); });
+        var future = new Date();
+        future.setMinutes(future.getMinutes() + this.maxDepartureAge);
+        future = future.getTime();
+        var past = new Date();
+        past.setMinutes(past.getMinutes() - this.maxDepartureAge);
+        past = past.getTime();
+        var departureArray = [];
+        var platformsBoarding = [];
+        var previousDeparture = null;
+        for (var i = departures.length - 1; i >= 0; i -= 1) {
+            var d = departures[i];
+            var t = new Date(d.time).getTime();
+            // Only show departures within the next 30 minutes
+            if (t > past && t < future) {
+                // If 2 trains are boarding at the same platform,
+                // remove the older one.
+                if (d.state === 'BOARDING') {
+                    if (platformsBoarding.indexOf(d.platform) === -1) {
+                        platformsBoarding.push(d.platform);
+                    }
+                    else {
+                        d.state = 'HIDDEN';
+                    }
+                }
+                // If two trains with the same line number and destinatin
+                // and a departure difference < 1 minute, hide the second one.
+                if (previousDeparture &&
+                    d.to[0] === previousDeparture.to[0] &&
+                    Math.abs(t - previousDeparture.time) < 1000 &&
+                    d.line.name === previousDeparture.line.name) {
+                    d.state = 'HIDDEN';
+                }
+                if (/(STOP_CANCELLED|JOURNEY_CANCELLED)/.test(d.state)) {
+                    d.cancelled = true;
+                }
+                previousDeparture = d;
+                previousDeparture.time = t;
+                departureArray.unshift(d);
+            }
+        }
+        return departureArray;
+    };
+    /**
+     * 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.
+     */
+    RealtimeAPI.prototype.subscribeDepartures = function (stationId, sortByMinArrivalTime, onMessage) {
+        var _this = this;
+        window.clearTimeout(this.departureUpdateTimeout);
+        this.unsubscribeDepartures();
+        this.subscribedStationUic = stationId;
+        var channel = stationId ? "timetable_".concat(stationId) : null;
+        var departureObject = {};
+        this.subscribe(channel, function (data) {
+            if (data.source === channel) {
+                var content = data.content || {};
+                var tDiff = new Date(content.timestamp).getTime() - Date.now();
+                content.timediff = tDiff;
+                departureObject[content.call_id] = content;
+                window.clearTimeout(_this.departureUpdateTimeout);
+                _this.departureUpdateTimeout = window.setTimeout(function () {
+                    var departures = _this.filterDepartures(departureObject, sortByMinArrivalTime || false);
+                    onMessage(departures);
+                }, 100);
+            }
+        }, function () {
+            onMessage([]);
+        });
+    };
+    /**
+     * Unsubscribe from current departures channel.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeDepartures = function (cb) {
+        if (this.subscribedStationUic) {
+            this.unsubscribe("timetable_".concat(this.subscribedStationUic), '', cb);
+            this.subscribedStationUic = null;
+        }
+    };
+    /**
+     * Subscribe to the disruptions channel for tenant.
+     *
+     * @param {function} onMessage Function called on each message of the channel.
+     */
+    RealtimeAPI.prototype.subscribeDisruptions = function (onMessage) {
+        this.subscribe("".concat(this.prefix, "newsticker"), function (data) {
+            onMessage(data.content);
+        });
+    };
+    /**
+     * Unsubscribe disruptions.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeDisruptions = function (cb) {
+        this.unsubscribe("".concat(this.prefix, "newsticker"), '', cb);
+    };
+    /**
+     * 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<Station>} A station.
+     */
+    RealtimeAPI.prototype.getStation = function (uic, mode) {
+        var _this = this;
+        var params = {
+            channel: "station".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes)),
+            args: uic,
+        };
+        return new Promise(function (resolve, reject) {
+            _this.wsApi.get(params, function (data) {
+                if (data.content) {
+                    resolve(data.content);
+                }
+                else {
+                    reject();
+                }
+            });
+        });
+    };
+    /**
+     * Update the model's station list for a given mode and a bbox.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @return {Promise<Array<Station>>} An array of stations.
+     */
+    RealtimeAPI.prototype.getStations = function (mode) {
+        var _this = this;
+        var stations = [];
+        var params = {
+            channel: "station".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes)),
+        };
+        window.clearTimeout(this.stationUpdateTimeout);
+        return new Promise(function (resolve, reject) {
+            _this.wsApi.get(params, function (data) {
+                if (data.content) {
+                    stations.push(data.content);
+                    window.clearTimeout(_this.stationUpdateTimeout);
+                    /** @ignore */
+                    _this.stationUpdateTimeout = window.setTimeout(function () {
+                        resolve(stations);
+                    }, 50);
+                }
+                else {
+                    reject(data.content);
+                }
+            });
+        });
+    };
+    /**
+     * Subscribe to stations channel.
+     * One message pro station.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(station: Station)} onMessage Function called on each message of the channel.
+     */
+    RealtimeAPI.prototype.subscribeStations = function (mode, onMessage) {
+        this.unsubscribeStations();
+        this.subscribe("station".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes)), function (data) {
+            if (data.content) {
+                onMessage(data.content);
+            }
+        });
+    };
+    /**
+     * Unsubscribe to stations channel.
+     * @param {function} cb The listener callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribe.
+     */
+    RealtimeAPI.prototype.unsubscribeStations = function (cb) {
+        window.clearTimeout(this.stationUpdateTimeout);
+        this.unsubscribe('station', '', cb);
+    };
+    /**
+     * Subscribe to extra_geoms channel.
+     *
+     * @param {function(extraGeoms: GeosJSONFeature[])} onMessage Function called on each message of the channel.
+     */
+    RealtimeAPI.prototype.subscribeExtraGeoms = function (onMessage) {
+        var _this = this;
+        this.subscribe('extra_geoms', function (data) {
+            var extraGeom = data.content;
+            if (extraGeom) {
+                var ref = extraGeom.properties.ref;
+                if (extraGeom.type === 'Feature') {
+                    _this.extraGeoms[ref] = extraGeom;
+                }
+                else {
+                    delete _this.extraGeoms[ref];
+                }
+                onMessage(Object.keys(_this.extraGeoms).map(function (key) { return _this.extraGeoms[key]; }));
+            }
+        });
+    };
+    /**
+     * Unsubscribe to extra_geoms channel.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeExtraGeoms = function (cb) {
+        this.unsubscribe('extra_geoms', '', cb);
+    };
+    /**
+     * Subscribe to trajectory channel.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(trajectory: RealtimeTrajectory)} onMessage Function called on each message of the channel.
+     * @param {boolean} quiet If true, the subscription will not send GET and SUB requests to the websocket.
+     */
+    RealtimeAPI.prototype.subscribeTrajectory = function (mode, onMessage, quiet) {
+        if (quiet === void 0) { quiet = false; }
+        this.unsubscribeTrajectory(onMessage);
+        this.subscribe("trajectory".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes)), onMessage, null, quiet);
+    };
+    /**
+     * Unsubscribe to trajectory channels.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeTrajectory = function (cb) {
+        this.unsubscribe("trajectory", '', cb);
+    };
+    /**
+     * Subscribe to deleted_vhicles channel.
+     *
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {function(response: { content: Vehicle })} onMessage Function called on each message of the channel.
+     * @param {boolean} quiet If true, the subscription will not send GET and SUB requests to the websocket.
+     */
+    RealtimeAPI.prototype.subscribeDeletedVehicles = function (mode, onMessage, quiet) {
+        if (quiet === void 0) { quiet = false; }
+        this.unsubscribeDeletedVehicles(onMessage);
+        this.subscribe("deleted_vehicles".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes)), onMessage, null, quiet);
+    };
+    /**
+     * Unsubscribe to deleted_vhicles channels.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeDeletedVehicles = function (cb) {
+        this.unsubscribe('deleted_vehicles', '', cb);
+    };
+    /**
+     * 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<FullTrajectory>} Return a full trajectory.
+     */
+    RealtimeAPI.prototype.getFullTrajectory = function (id, mode, generalizationLevel) {
+        var _this = this;
+        var channel = ["full_trajectory".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes))];
+        if (id) {
+            channel.push(id);
+        }
+        if ((!mode || mode === exports.RealtimeModes.TOPOGRAPHIC) && generalizationLevel) {
+            channel.push("gen".concat(generalizationLevel));
+        }
+        var params = {
+            channel: channel.join('_'),
+        };
+        return new Promise(function (resolve) {
+            _this.wsApi.get(params, function (data) {
+                if (data.content) {
+                    resolve(data.content);
+                }
+            });
+        });
+    };
+    /**
+     * Get full trajectories of a vehicules .
+     *
+     * @param {string[]} ids List of vehicles ids.
+     * @param {RealtimeMode} mode Realtime mode.
+     * @param {string} generalizationLevel The generalization level to request. Can be one of '', 'gen5', 'gen10', 'gen30', 'gen100'.
+     * @return {Promise<Array<FullTrajectory>>} Return an array of full trajectories.
+     */
+    RealtimeAPI.prototype.getFullTrajectories = function (ids, mode, generalizationLevel) {
+        var _this = this;
+        var promises = ids.map(function (id) {
+            return _this.getFullTrajectory(id, mode, generalizationLevel);
+        });
+        return Promise.all(promises);
+    };
+    /**
+     * Subscribe to full_trajectory channel of a given vehicle.
+     *
+     * @param {string} id A vehicle id.
+     * @param {RealtimeMode} mode Realtime mode.
+     */
+    RealtimeAPI.prototype.subscribeFullTrajectory = function (id, mode) {
+        // window.clearTimeout(this.fullTrajectoryUpdateTimeout);
+        this.unsubscribeFullTrajectory(id);
+        this.subscribe("full_trajectory".concat((0, getRealtimeModeSuffix_1.default)(mode, exports.RealtimeModes), "_").concat(id), function (data) {
+            // eslint-disable-next-line no-console
+            console.log('subscribe full_trajectory', data);
+        }, function (err) {
+            // eslint-disable-next-line no-console
+            console.log('subscribe full_trajectory error', err);
+        });
+    };
+    /**
+     * Unsubscribe from full_trajectory channel
+     *
+     * @param {string} id A vehicle id.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeFullTrajectory = function (id, cb) {
+        this.unsubscribe('full_trajectory', "_".concat(id), cb);
+    };
+    /**
+     * Get the list of stops for this vehicle.
+     *
+     * @param {string} id A vehicle id.
+     * @return {Promise<StopSequence>} Returns a stop sequence object.
+     */
+    RealtimeAPI.prototype.getStopSequence = function (id) {
+        var _this = this;
+        var params = {
+            channel: "stopsequence_".concat(id),
+        };
+        return new Promise(function (resolve, reject) {
+            _this.wsApi.get(params, function (data) {
+                if (data.content && data.content.length) {
+                    var content = data.content.map(function (stopSequence) {
+                        return (0, cleanStopTime_1.default)(stopSequence);
+                    });
+                    // Remove the delay from arrivalTime and departureTime
+                    resolve(content);
+                }
+                resolve([]);
+            }, function (err) {
+                reject(err);
+            });
+        });
+    };
+    /**
+     * Get a list of stops for a list of vehicles.
+     *
+     * @param {string[]} ids List of vehicles ids.
+     * @return {Promise<Array<StopSequence>>} Return an array of stop sequences.
+     */
+    RealtimeAPI.prototype.getStopSequences = function (ids) {
+        var _this = this;
+        var promises = ids.map(function (id) { return _this.getStopSequence(id); });
+        return Promise.all(promises);
+    };
+    /**
+     * Subscribe to stopsequence channel of a given vehicle.
+     *
+     * @param {string} id A vehicle id.
+     * @param {function(stopSequence: StopSequence)} onMessage Function called on each message of the channel.
+     */
+    RealtimeAPI.prototype.subscribeStopSequence = function (id, onMessage) {
+        window.clearTimeout(this.fullTrajectoryUpdateTimeout);
+        this.unsubscribeStopSequence(id);
+        this.subscribe("stopsequence_".concat(id), function (data) {
+            if (data.content && data.content.length) {
+                var content = data.content.map(function (stopSequence) {
+                    return (0, cleanStopTime_1.default)(stopSequence);
+                });
+                // Remove the delay from arrivalTime and departureTime
+                onMessage(content);
+            }
+        }, function (err) {
+            // eslint-disable-next-line no-console
+            console.log('subscribe stopsequence error', err);
+        });
+    };
+    /**
+     * Unsubscribe from stopsequence channel
+     *
+     * @param {string} id A vehicle id.
+     * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
+     */
+    RealtimeAPI.prototype.unsubscribeStopSequence = function (id, cb) {
+        this.unsubscribe("stopsequence", "_".concat(id), cb);
+    };
+    /**
+     * Subscribe to healthcheck channel.
+     * @param {function} onMessage Callback when the subscribe to healthcheck channel succeeds.
+     */
+    RealtimeAPI.prototype.subscribeHealthCheck = function (onMessage) {
+        this.unsubscribeHealthCheck();
+        this.subscribe('healthcheck', onMessage);
+    };
+    /**
+     * Unsubscribe to healthcheck channel.
+     */
+    RealtimeAPI.prototype.unsubscribeHealthCheck = function () {
+        this.unsubscribe('healthcheck');
+    };
+    return RealtimeAPI;
+}());
+exports.default = RealtimeAPI;