mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/meteor/callback-hook/hook.js

@@ -1,78 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hook = void 0;
-const hasOwn = Object.prototype.hasOwnProperty;
-class Hook {
-    constructor(options) {
-        options = options || {};
-        this.nextCallbackId = 0;
-        this.callbacks = Object.create(null);
-        // Whether to wrap callbacks with Meteor.bindEnvironment
-        if (options.exceptionHandler) {
-            this.exceptionHandler = options.exceptionHandler;
-        }
-        else if (options.debugPrintExceptions) {
-            if (typeof options.debugPrintExceptions !== "string") {
-                throw new Error("Hook option debugPrintExceptions should be a string");
-            }
-            this.exceptionHandler = options.debugPrintExceptions;
-        }
-    }
-    register(callback) {
-        var exceptionHandler = this.exceptionHandler || function (exception) {
-            // Note: this relies on the undocumented fact that if bindEnvironment's
-            // onException throws, and you are invoking the callback either in the
-            // browser or from within a Fiber in Node, the exception is propagated.
-            throw exception;
-        };
-        callback = dontBindEnvironment(callback, exceptionHandler);
-        var id = this.nextCallbackId++;
-        this.callbacks[id] = callback;
-        return {
-            callback,
-            stop: () => {
-                delete this.callbacks[id];
-            }
-        };
-    }
-    // For each registered callback, call the passed iterator function
-    // with the callback.
-    //
-    // The iterator function can choose whether or not to call the
-    // callback.  (For example, it might not call the callback if the
-    // observed object has been closed or terminated).
-    //
-    // The iteration is stopped if the iterator function returns a falsy
-    // value or throws an exception.
-    each(iterator) {
-        var ids = Object.keys(this.callbacks);
-        for (var i = 0; i < ids.length; ++i) {
-            var id = ids[i];
-            // check to see if the callback was removed during iteration
-            if (hasOwn.call(this.callbacks, id)) {
-                var callback = this.callbacks[id];
-                if (!iterator(callback)) {
-                    break;
-                }
-            }
-        }
-    }
-}
-exports.Hook = Hook;
-function dontBindEnvironment(func, onException, _this) {
-    if (!onException || typeof (onException) === 'string') {
-        var description = onException || "callback of async function";
-        onException = function (error) {
-            console.error("Exception in " + description, error);
-        };
-    }
-    return function (...args) {
-        try {
-            var ret = func.apply(_this, args);
-        }
-        catch (e) {
-            onException(e);
-        }
-        return ret;
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hook = void 0;
+const hasOwn = Object.prototype.hasOwnProperty;
+class Hook {
+    constructor(options) {
+        options = options || {};
+        this.nextCallbackId = 0;
+        this.callbacks = Object.create(null);
+        // Whether to wrap callbacks with Meteor.bindEnvironment
+        if (options.exceptionHandler) {
+            this.exceptionHandler = options.exceptionHandler;
+        }
+        else if (options.debugPrintExceptions) {
+            if (typeof options.debugPrintExceptions !== "string") {
+                throw new Error("Hook option debugPrintExceptions should be a string");
+            }
+            this.exceptionHandler = options.debugPrintExceptions;
+        }
+    }
+    register(callback) {
+        var exceptionHandler = this.exceptionHandler || function (exception) {
+            // Note: this relies on the undocumented fact that if bindEnvironment's
+            // onException throws, and you are invoking the callback either in the
+            // browser or from within a Fiber in Node, the exception is propagated.
+            throw exception;
+        };
+        callback = dontBindEnvironment(callback, exceptionHandler);
+        var id = this.nextCallbackId++;
+        this.callbacks[id] = callback;
+        return {
+            callback,
+            stop: () => {
+                delete this.callbacks[id];
+            }
+        };
+    }
+    // For each registered callback, call the passed iterator function
+    // with the callback.
+    //
+    // The iterator function can choose whether or not to call the
+    // callback.  (For example, it might not call the callback if the
+    // observed object has been closed or terminated).
+    //
+    // The iteration is stopped if the iterator function returns a falsy
+    // value or throws an exception.
+    each(iterator) {
+        var ids = Object.keys(this.callbacks);
+        for (var i = 0; i < ids.length; ++i) {
+            var id = ids[i];
+            // check to see if the callback was removed during iteration
+            if (hasOwn.call(this.callbacks, id)) {
+                var callback = this.callbacks[id];
+                if (!iterator(callback)) {
+                    break;
+                }
+            }
+        }
+    }
+}
+exports.Hook = Hook;
+function dontBindEnvironment(func, onException, _this) {
+    if (!onException || typeof (onException) === 'string') {
+        var description = onException || "callback of async function";
+        onException = function (error) {
+            console.error("Exception in " + description, error);
+        };
+    }
+    return function (...args) {
+        try {
+            var ret = func.apply(_this, args);
+        }
+        catch (e) {
+            onException(e);
+        }
+        return ret;
+    };
+}

package/dist/meteor/ddp/crossbar.d.ts

@@ -1,15 +1,15 @@
-export declare class _Crossbar {
-    private listenersByCollection;
-    private listenersByCollectionCount;
-    private nextId;
-    constructor(options: any);
-    _collectionForMessage(msg: {
-        collection?: any;
-    }): string;
-    listen(trigger: any, callback: any): {
-        stop: () => void;
-    };
-    fire(notification: Record<string, any>): void;
-    _matches(notification: Record<string, any>, trigger: Record<string, any>): boolean;
-}
-export declare const _InvalidationCrossbar: _Crossbar;
+export declare class _Crossbar {
+    private listenersByCollection;
+    private listenersByCollectionCount;
+    private nextId;
+    constructor(options: any);
+    _collectionForMessage(msg: {
+        collection?: any;
+    }): string;
+    listen(trigger: any, callback: any): {
+        stop: () => void;
+    };
+    fire(notification: Record<string, any>): void;
+    _matches(notification: Record<string, any>, trigger: Record<string, any>): boolean;
+}
+export declare const _InvalidationCrossbar: _Crossbar;

package/dist/meteor/ddp/crossbar.js

@@ -1,136 +1,136 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._InvalidationCrossbar = exports._Crossbar = void 0;
-const ejson_1 = require("../ejson/ejson");
-// A "crossbar" is a class that provides structured notification registration.
-// See _match for the definition of how a notification matches a trigger.
-// All notifications and triggers must have a string key named 'collection'.
-class _Crossbar {
-    constructor(options) {
-        this.listenersByCollection = {};
-        this.listenersByCollectionCount = {};
-        options = options || {};
-        this.nextId = 1;
-    }
-    // msg is a trigger or a notification
-    _collectionForMessage(msg) {
-        if (!msg.hasOwnProperty('collection')) {
-            return '';
-        }
-        else if (typeof (msg.collection) === 'string') {
-            if (msg.collection === '')
-                throw Error("Message has empty collection!");
-            return msg.collection;
-        }
-        else {
-            throw Error("Message has non-string collection!");
-        }
-    }
-    // Listen for notification that match 'trigger'. A notification
-    // matches if it has the key-value pairs in trigger as a
-    // subset. When a notification matches, call 'callback', passing
-    // the actual notification.
-    //
-    // Returns a listen handle, which is an object with a method
-    // stop(). Call stop() to stop listening.
-    //
-    // XXX It should be legal to call fire() from inside a listen()
-    // callback?
-    listen(trigger, callback) {
-        var self = this;
-        var id = self.nextId++;
-        var collection = self._collectionForMessage(trigger);
-        var record = { trigger: (0, ejson_1.clone)(trigger), callback: callback };
-        if (!self.listenersByCollection.hasOwnProperty(collection)) {
-            self.listenersByCollection[collection] = {};
-            self.listenersByCollectionCount[collection] = 0;
-        }
-        self.listenersByCollection[collection][id] = record;
-        self.listenersByCollectionCount[collection]++;
-        return {
-            stop: function () {
-                delete self.listenersByCollection[collection][id];
-                self.listenersByCollectionCount[collection]--;
-                if (self.listenersByCollectionCount[collection] === 0) {
-                    delete self.listenersByCollection[collection];
-                    delete self.listenersByCollectionCount[collection];
-                }
-            }
-        };
-    }
-    // Fire the provided 'notification' (an object whose attribute
-    // values are all JSON-compatibile) -- inform all matching listeners
-    // (registered with listen()).
-    //
-    // If fire() is called inside a write fence, then each of the
-    // listener callbacks will be called inside the write fence as well.
-    //
-    // The listeners may be invoked in parallel, rather than serially.
-    fire(notification) {
-        var self = this;
-        var collection = self._collectionForMessage(notification);
-        if (!self.listenersByCollection.hasOwnProperty(collection)) {
-            return;
-        }
-        var listenersForCollection = self.listenersByCollection[collection];
-        var callbackIds = [];
-        Object.entries(listenersForCollection).forEach(function ([id, l]) {
-            if (self._matches(notification, l.trigger)) {
-                callbackIds.push(id);
-            }
-        });
-        // Listener callbacks can yield, so we need to first find all the ones that
-        // match in a single iteration over self.listenersByCollection (which can't
-        // be mutated during this iteration), and then invoke the matching
-        // callbacks, checking before each call to ensure they haven't stopped.
-        // Note that we don't have to check that
-        // self.listenersByCollection[collection] still === listenersForCollection,
-        // because the only way that stops being true is if listenersForCollection
-        // first gets reduced down to the empty object (and then never gets
-        // increased again).
-        for (const id of callbackIds) {
-            if (listenersForCollection.hasOwnProperty(id)) {
-                listenersForCollection[id].callback(notification);
-            }
-        }
-    }
-    // A notification matches a trigger if all keys that exist in both are equal.
-    //
-    // Examples:
-    //  N:{collection: "C"} matches T:{collection: "C"}
-    //    (a non-targeted write to a collection matches a
-    //     non-targeted query)
-    //  N:{collection: "C", id: "X"} matches T:{collection: "C"}
-    //    (a targeted write to a collection matches a non-targeted query)
-    //  N:{collection: "C"} matches T:{collection: "C", id: "X"}
-    //    (a non-targeted write to a collection matches a
-    //     targeted query)
-    //  N:{collection: "C", id: "X"} matches T:{collection: "C", id: "X"}
-    //    (a targeted write to a collection matches a targeted query targeted
-    //     at the same document)
-    //  N:{collection: "C", id: "X"} does not match T:{collection: "C", id: "Y"}
-    //    (a targeted write to a collection does not match a targeted query
-    //     targeted at a different document)
-    _matches(notification, trigger) {
-        // Most notifications that use the crossbar have a string `collection` and
-        // maybe an `id` that is a string or ObjectID. We're already dividing up
-        // triggers by collection, but let's fast-track "nope, different ID" (and
-        // avoid the overly generic EJSON.equals). This makes a noticeable
-        // performance difference; see https://github.com/meteor/meteor/pull/3697
-        if (typeof (notification.id) === 'string' && typeof (trigger.id) === 'string' && notification.id !== trigger.id) {
-            return false;
-        }
-        return Object.entries(trigger).every(([key, triggerValue]) => {
-            return !notification.hasOwnProperty(key) || (0, ejson_1.equals)(triggerValue, notification[key]);
-        });
-    }
-}
-exports._Crossbar = _Crossbar;
-// The "invalidation crossbar" is a specific instance used by the DDP server to
-// implement write fence notifications. Listener callbacks on this crossbar
-// should call beginWrite on the current write fence before they return, if they
-// want to delay the write fence from firing (ie, the DDP method-data-updated
-// message from being sent).
-exports._InvalidationCrossbar = new _Crossbar({
-    factName: "invalidation-crossbar-listeners"
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._InvalidationCrossbar = exports._Crossbar = void 0;
+const ejson_1 = require("../ejson/ejson");
+// A "crossbar" is a class that provides structured notification registration.
+// See _match for the definition of how a notification matches a trigger.
+// All notifications and triggers must have a string key named 'collection'.
+class _Crossbar {
+    constructor(options) {
+        this.listenersByCollection = {};
+        this.listenersByCollectionCount = {};
+        options = options || {};
+        this.nextId = 1;
+    }
+    // msg is a trigger or a notification
+    _collectionForMessage(msg) {
+        if (!msg.hasOwnProperty('collection')) {
+            return '';
+        }
+        else if (typeof (msg.collection) === 'string') {
+            if (msg.collection === '')
+                throw Error("Message has empty collection!");
+            return msg.collection;
+        }
+        else {
+            throw Error("Message has non-string collection!");
+        }
+    }
+    // Listen for notification that match 'trigger'. A notification
+    // matches if it has the key-value pairs in trigger as a
+    // subset. When a notification matches, call 'callback', passing
+    // the actual notification.
+    //
+    // Returns a listen handle, which is an object with a method
+    // stop(). Call stop() to stop listening.
+    //
+    // XXX It should be legal to call fire() from inside a listen()
+    // callback?
+    listen(trigger, callback) {
+        var self = this;
+        var id = self.nextId++;
+        var collection = self._collectionForMessage(trigger);
+        var record = { trigger: (0, ejson_1.clone)(trigger), callback: callback };
+        if (!self.listenersByCollection.hasOwnProperty(collection)) {
+            self.listenersByCollection[collection] = {};
+            self.listenersByCollectionCount[collection] = 0;
+        }
+        self.listenersByCollection[collection][id] = record;
+        self.listenersByCollectionCount[collection]++;
+        return {
+            stop: function () {
+                delete self.listenersByCollection[collection][id];
+                self.listenersByCollectionCount[collection]--;
+                if (self.listenersByCollectionCount[collection] === 0) {
+                    delete self.listenersByCollection[collection];
+                    delete self.listenersByCollectionCount[collection];
+                }
+            }
+        };
+    }
+    // Fire the provided 'notification' (an object whose attribute
+    // values are all JSON-compatibile) -- inform all matching listeners
+    // (registered with listen()).
+    //
+    // If fire() is called inside a write fence, then each of the
+    // listener callbacks will be called inside the write fence as well.
+    //
+    // The listeners may be invoked in parallel, rather than serially.
+    fire(notification) {
+        var self = this;
+        var collection = self._collectionForMessage(notification);
+        if (!self.listenersByCollection.hasOwnProperty(collection)) {
+            return;
+        }
+        var listenersForCollection = self.listenersByCollection[collection];
+        var callbackIds = [];
+        Object.entries(listenersForCollection).forEach(function ([id, l]) {
+            if (self._matches(notification, l.trigger)) {
+                callbackIds.push(id);
+            }
+        });
+        // Listener callbacks can yield, so we need to first find all the ones that
+        // match in a single iteration over self.listenersByCollection (which can't
+        // be mutated during this iteration), and then invoke the matching
+        // callbacks, checking before each call to ensure they haven't stopped.
+        // Note that we don't have to check that
+        // self.listenersByCollection[collection] still === listenersForCollection,
+        // because the only way that stops being true is if listenersForCollection
+        // first gets reduced down to the empty object (and then never gets
+        // increased again).
+        for (const id of callbackIds) {
+            if (listenersForCollection.hasOwnProperty(id)) {
+                listenersForCollection[id].callback(notification);
+            }
+        }
+    }
+    // A notification matches a trigger if all keys that exist in both are equal.
+    //
+    // Examples:
+    //  N:{collection: "C"} matches T:{collection: "C"}
+    //    (a non-targeted write to a collection matches a
+    //     non-targeted query)
+    //  N:{collection: "C", id: "X"} matches T:{collection: "C"}
+    //    (a targeted write to a collection matches a non-targeted query)
+    //  N:{collection: "C"} matches T:{collection: "C", id: "X"}
+    //    (a non-targeted write to a collection matches a
+    //     targeted query)
+    //  N:{collection: "C", id: "X"} matches T:{collection: "C", id: "X"}
+    //    (a targeted write to a collection matches a targeted query targeted
+    //     at the same document)
+    //  N:{collection: "C", id: "X"} does not match T:{collection: "C", id: "Y"}
+    //    (a targeted write to a collection does not match a targeted query
+    //     targeted at a different document)
+    _matches(notification, trigger) {
+        // Most notifications that use the crossbar have a string `collection` and
+        // maybe an `id` that is a string or ObjectID. We're already dividing up
+        // triggers by collection, but let's fast-track "nope, different ID" (and
+        // avoid the overly generic EJSON.equals). This makes a noticeable
+        // performance difference; see https://github.com/meteor/meteor/pull/3697
+        if (typeof (notification.id) === 'string' && typeof (trigger.id) === 'string' && notification.id !== trigger.id) {
+            return false;
+        }
+        return Object.entries(trigger).every(([key, triggerValue]) => {
+            return !notification.hasOwnProperty(key) || (0, ejson_1.equals)(triggerValue, notification[key]);
+        });
+    }
+}
+exports._Crossbar = _Crossbar;
+// The "invalidation crossbar" is a specific instance used by the DDP server to
+// implement write fence notifications. Listener callbacks on this crossbar
+// should call beginWrite on the current write fence before they return, if they
+// want to delay the write fence from firing (ie, the DDP method-data-updated
+// message from being sent).
+exports._InvalidationCrossbar = new _Crossbar({
+    factName: "invalidation-crossbar-listeners"
+});

package/dist/meteor/ddp/heartbeat.d.ts

@@ -1,19 +1,19 @@
-export declare class Heartbeat {
-    private heartbeatInterval;
-    private heartbeatTimeout;
-    private _sendPing;
-    private _onTimeout;
-    private _seenPacket;
-    private _heartbeatIntervalHandle;
-    private _heartbeatTimeoutHandle;
-    constructor(options: any);
-    stop(): void;
-    start(): void;
-    _startHeartbeatIntervalTimer(): void;
-    _startHeartbeatTimeoutTimer(): void;
-    _clearHeartbeatIntervalTimer(): void;
-    _clearHeartbeatTimeoutTimer(): void;
-    _heartbeatIntervalFired(): void;
-    _heartbeatTimeoutFired(): void;
-    messageReceived(): void;
-}
+export declare class Heartbeat {
+    private heartbeatInterval;
+    private heartbeatTimeout;
+    private _sendPing;
+    private _onTimeout;
+    private _seenPacket;
+    private _heartbeatIntervalHandle;
+    private _heartbeatTimeoutHandle;
+    constructor(options: any);
+    stop(): void;
+    start(): void;
+    _startHeartbeatIntervalTimer(): void;
+    _startHeartbeatTimeoutTimer(): void;
+    _clearHeartbeatIntervalTimer(): void;
+    _clearHeartbeatTimeoutTimer(): void;
+    _heartbeatIntervalFired(): void;
+    _heartbeatTimeoutFired(): void;
+    messageReceived(): void;
+}

package/dist/meteor/ddp/heartbeat.js

@@ -1,77 +1,77 @@
-"use strict";
-// Heartbeat options:
-//   heartbeatInterval: interval to send pings, in milliseconds.
-//   heartbeatTimeout: timeout to close the connection if a reply isn't
-//     received, in milliseconds.
-//   sendPing: function to call to send a ping on the connection.
-//   onTimeout: function to call to close the connection.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heartbeat = void 0;
-class Heartbeat {
-    constructor(options) {
-        this.heartbeatInterval = options.heartbeatInterval;
-        this.heartbeatTimeout = options.heartbeatTimeout;
-        this._sendPing = options.sendPing;
-        this._onTimeout = options.onTimeout;
-        this._seenPacket = false;
-        this._heartbeatIntervalHandle = null;
-        this._heartbeatTimeoutHandle = null;
-    }
-    stop() {
-        this._clearHeartbeatIntervalTimer();
-        this._clearHeartbeatTimeoutTimer();
-    }
-    start() {
-        this.stop();
-        this._startHeartbeatIntervalTimer();
-    }
-    _startHeartbeatIntervalTimer() {
-        this._heartbeatIntervalHandle = setInterval(() => this._heartbeatIntervalFired(), this.heartbeatInterval);
-    }
-    _startHeartbeatTimeoutTimer() {
-        this._heartbeatTimeoutHandle = setTimeout(() => this._heartbeatTimeoutFired(), this.heartbeatTimeout);
-    }
-    _clearHeartbeatIntervalTimer() {
-        if (this._heartbeatIntervalHandle) {
-            clearInterval(this._heartbeatIntervalHandle);
-            this._heartbeatIntervalHandle = null;
-        }
-    }
-    _clearHeartbeatTimeoutTimer() {
-        if (this._heartbeatTimeoutHandle) {
-            clearTimeout(this._heartbeatTimeoutHandle);
-            this._heartbeatTimeoutHandle = null;
-        }
-    }
-    // The heartbeat interval timer is fired when we should send a ping.
-    _heartbeatIntervalFired() {
-        // don't send ping if we've seen a packet since we last checked,
-        // *or* if we have already sent a ping and are awaiting a timeout.
-        // That shouldn't happen, but it's possible if
-        // `this.heartbeatInterval` is smaller than
-        // `this.heartbeatTimeout`.
-        if (!this._seenPacket && !this._heartbeatTimeoutHandle) {
-            this._sendPing();
-            // Set up timeout, in case a pong doesn't arrive in time.
-            this._startHeartbeatTimeoutTimer();
-        }
-        this._seenPacket = false;
-    }
-    // The heartbeat timeout timer is fired when we sent a ping, but we
-    // timed out waiting for the pong.
-    _heartbeatTimeoutFired() {
-        this._heartbeatTimeoutHandle = null;
-        this._onTimeout();
-    }
-    messageReceived() {
-        // Tell periodic checkin that we have seen a packet, and thus it
-        // does not need to send a ping this cycle.
-        this._seenPacket = true;
-        // If we were waiting for a pong, we got it.
-        if (this._heartbeatTimeoutHandle) {
-            this._clearHeartbeatTimeoutTimer();
-        }
-    }
-}
-exports.Heartbeat = Heartbeat;
-;
+"use strict";
+// Heartbeat options:
+//   heartbeatInterval: interval to send pings, in milliseconds.
+//   heartbeatTimeout: timeout to close the connection if a reply isn't
+//     received, in milliseconds.
+//   sendPing: function to call to send a ping on the connection.
+//   onTimeout: function to call to close the connection.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heartbeat = void 0;
+class Heartbeat {
+    constructor(options) {
+        this.heartbeatInterval = options.heartbeatInterval;
+        this.heartbeatTimeout = options.heartbeatTimeout;
+        this._sendPing = options.sendPing;
+        this._onTimeout = options.onTimeout;
+        this._seenPacket = false;
+        this._heartbeatIntervalHandle = null;
+        this._heartbeatTimeoutHandle = null;
+    }
+    stop() {
+        this._clearHeartbeatIntervalTimer();
+        this._clearHeartbeatTimeoutTimer();
+    }
+    start() {
+        this.stop();
+        this._startHeartbeatIntervalTimer();
+    }
+    _startHeartbeatIntervalTimer() {
+        this._heartbeatIntervalHandle = setInterval(() => this._heartbeatIntervalFired(), this.heartbeatInterval);
+    }
+    _startHeartbeatTimeoutTimer() {
+        this._heartbeatTimeoutHandle = setTimeout(() => this._heartbeatTimeoutFired(), this.heartbeatTimeout);
+    }
+    _clearHeartbeatIntervalTimer() {
+        if (this._heartbeatIntervalHandle) {
+            clearInterval(this._heartbeatIntervalHandle);
+            this._heartbeatIntervalHandle = null;
+        }
+    }
+    _clearHeartbeatTimeoutTimer() {
+        if (this._heartbeatTimeoutHandle) {
+            clearTimeout(this._heartbeatTimeoutHandle);
+            this._heartbeatTimeoutHandle = null;
+        }
+    }
+    // The heartbeat interval timer is fired when we should send a ping.
+    _heartbeatIntervalFired() {
+        // don't send ping if we've seen a packet since we last checked,
+        // *or* if we have already sent a ping and are awaiting a timeout.
+        // That shouldn't happen, but it's possible if
+        // `this.heartbeatInterval` is smaller than
+        // `this.heartbeatTimeout`.
+        if (!this._seenPacket && !this._heartbeatTimeoutHandle) {
+            this._sendPing();
+            // Set up timeout, in case a pong doesn't arrive in time.
+            this._startHeartbeatTimeoutTimer();
+        }
+        this._seenPacket = false;
+    }
+    // The heartbeat timeout timer is fired when we sent a ping, but we
+    // timed out waiting for the pong.
+    _heartbeatTimeoutFired() {
+        this._heartbeatTimeoutHandle = null;
+        this._onTimeout();
+    }
+    messageReceived() {
+        // Tell periodic checkin that we have seen a packet, and thus it
+        // does not need to send a ping this cycle.
+        this._seenPacket = true;
+        // If we were waiting for a pong, we got it.
+        if (this._heartbeatTimeoutHandle) {
+            this._clearHeartbeatTimeoutTimer();
+        }
+    }
+}
+exports.Heartbeat = Heartbeat;
+;