@ngxs/websocket-plugin 3.7.4 → 3.7.5-dev.master-17a1bb8

package/bundles/ngxs-websocket-plugin.umd.js

@@ -223,625 +223,625 @@
         return value;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
-    var NGXS_WEBSOCKET_OPTIONS = new core.InjectionToken('NGXS_WEBSOCKET_OPTIONS');
-    /**
-     * @record
-     */
-    function NgxsWebsocketPluginOptions() { }
-    if (false) {
-        /**
-         * URL of the websocket.
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.url;
-        /**
-         * Either a single protocol string or an array of protocol strings.
-         * These strings are used to indicate sub-protocols, so that a single server
-         * can implement multiple WebSocket sub-protocols (for example, you might want one server to be able
-         * to handle different types of interactions depending on the specified protocol).
-         * If you don't specify a protocol string, an empty string is assumed.
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.protocol;
-        /**
-         * Sets the `binaryType` property of the underlying WebSocket.
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.binaryType;
-        /**
-         * The property name to distigunish this type for the store.
-         * Default: 'type'
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.typeKey;
-        /**
-         * Interval to try and reconnect.
-         * Default: 5000
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.reconnectInterval;
-        /**
-         * Number of reconnect attemps.
-         * Default: 10
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.reconnectAttempts;
-        /**
-         * Serializer to call before sending messages
-         * Default: `json.stringify`
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.serializer;
-        /**
-         * Deseralizer before publishing the message.
-         * @type {?|undefined}
-         */
-        NgxsWebsocketPluginOptions.prototype.deserializer;
-    }
-    /**
-     * @param {...?} _args
-     * @return {?}
-     */
-    function noop() {
-        var _args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            _args[_i] = arguments[_i];
-        }
-        return (/**
-         * @return {?}
-         */
-        function () { });
-    }
-    /**
-     * Action to connect to the websocket. Optionally pass a URL.
-     */
-    var   /**
-     * Action to connect to the websocket. Optionally pass a URL.
-     */
-    ConnectWebSocket = /** @class */ (function () {
-        function ConnectWebSocket(payload) {
-            this.payload = payload;
-        }
-        Object.defineProperty(ConnectWebSocket, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '[WebSocket] Connect';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return ConnectWebSocket;
-    }());
-    if (false) {
-        /** @type {?} */
-        ConnectWebSocket.prototype.payload;
-    }
-    /**
-     * Action triggered when a error ocurrs
-     */
-    var   /**
-     * Action triggered when a error ocurrs
-     */
-    WebsocketMessageError = /** @class */ (function () {
-        function WebsocketMessageError(payload) {
-            this.payload = payload;
-        }
-        Object.defineProperty(WebsocketMessageError, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '[WebSocket] Message Error';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return WebsocketMessageError;
-    }());
-    if (false) {
-        /** @type {?} */
-        WebsocketMessageError.prototype.payload;
-    }
-    /**
-     * Action to disconnect the websocket.
-     */
-    var   /**
-     * Action to disconnect the websocket.
-     */
-    DisconnectWebSocket = /** @class */ (function () {
-        function DisconnectWebSocket() {
-        }
-        Object.defineProperty(DisconnectWebSocket, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '[WebSocket] Disconnect';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return DisconnectWebSocket;
-    }());
-    /**
-     * Action triggered when websocket is connected
-     */
-    var   /**
-     * Action triggered when websocket is connected
-     */
-    WebSocketConnected = /** @class */ (function () {
-        function WebSocketConnected() {
-        }
-        Object.defineProperty(WebSocketConnected, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return '[WebSocket] Connected';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return WebSocketConnected;
-    }());
-    /**
-     * Action triggered when websocket is disconnected
-     */
-    var   /**
-     * Action triggered when websocket is disconnected
-     */
-    WebSocketDisconnected = /** @class */ (function () {
-        function WebSocketDisconnected() {
-        }
-        Object.defineProperty(WebSocketDisconnected, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '[WebSocket] Disconnected';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return WebSocketDisconnected;
-    }());
-    /**
-     * Action to send to the server.
-     */
-    var   /**
-     * Action to send to the server.
-     */
-    SendWebSocketMessage = /** @class */ (function () {
-        function SendWebSocketMessage(payload) {
-            this.payload = payload;
-        }
-        Object.defineProperty(SendWebSocketMessage, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '[WebSocket] Send Message';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return SendWebSocketMessage;
-    }());
-    if (false) {
-        /** @type {?} */
-        SendWebSocketMessage.prototype.payload;
-    }
-    /**
-     * Action dispatched when the user tries to connect if the connection already exists.
-     */
-    var   /**
-     * Action dispatched when the user tries to connect if the connection already exists.
-     */
-    WebSocketConnectionUpdated = /** @class */ (function () {
-        function WebSocketConnectionUpdated() {
-        }
-        Object.defineProperty(WebSocketConnectionUpdated, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '[WebSocket] Connection Updated';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return WebSocketConnectionUpdated;
-    }());
-    /**
-     * This error is thrown where there is no `type` (or custom `typeKey`) property
-     * on the message that came from the server side socket
-     */
-    var /**
-     * This error is thrown where there is no `type` (or custom `typeKey`) property
-     * on the message that came from the server side socket
-     */
-    TypeKeyPropertyMissingError = /** @class */ (function (_super) {
-        __extends(TypeKeyPropertyMissingError, _super);
-        function TypeKeyPropertyMissingError(typeKey) {
-            return _super.call(this, "Property " + typeKey + " is missing on the socket message") || this;
-        }
-        return TypeKeyPropertyMissingError;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var NGXS_WEBSOCKET_OPTIONS = new core.InjectionToken('NGXS_WEBSOCKET_OPTIONS');
+    /**
+     * @record
+     */
+    function NgxsWebsocketPluginOptions() { }
+    if (false) {
+        /**
+         * URL of the websocket.
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.url;
+        /**
+         * Either a single protocol string or an array of protocol strings.
+         * These strings are used to indicate sub-protocols, so that a single server
+         * can implement multiple WebSocket sub-protocols (for example, you might want one server to be able
+         * to handle different types of interactions depending on the specified protocol).
+         * If you don't specify a protocol string, an empty string is assumed.
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.protocol;
+        /**
+         * Sets the `binaryType` property of the underlying WebSocket.
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.binaryType;
+        /**
+         * The property name to distigunish this type for the store.
+         * Default: 'type'
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.typeKey;
+        /**
+         * Interval to try and reconnect.
+         * Default: 5000
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.reconnectInterval;
+        /**
+         * Number of reconnect attemps.
+         * Default: 10
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.reconnectAttempts;
+        /**
+         * Serializer to call before sending messages
+         * Default: `json.stringify`
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.serializer;
+        /**
+         * Deseralizer before publishing the message.
+         * @type {?|undefined}
+         */
+        NgxsWebsocketPluginOptions.prototype.deserializer;
+    }
+    /**
+     * @param {...?} _args
+     * @return {?}
+     */
+    function noop() {
+        var _args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            _args[_i] = arguments[_i];
+        }
+        return (/**
+         * @return {?}
+         */
+        function () { });
+    }
+    /**
+     * Action to connect to the websocket. Optionally pass a URL.
+     */
+    var   /**
+     * Action to connect to the websocket. Optionally pass a URL.
+     */
+    ConnectWebSocket = /** @class */ (function () {
+        function ConnectWebSocket(payload) {
+            this.payload = payload;
+        }
+        Object.defineProperty(ConnectWebSocket, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '[WebSocket] Connect';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return ConnectWebSocket;
+    }());
+    if (false) {
+        /** @type {?} */
+        ConnectWebSocket.prototype.payload;
+    }
+    /**
+     * Action triggered when a error ocurrs
+     */
+    var   /**
+     * Action triggered when a error ocurrs
+     */
+    WebsocketMessageError = /** @class */ (function () {
+        function WebsocketMessageError(payload) {
+            this.payload = payload;
+        }
+        Object.defineProperty(WebsocketMessageError, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '[WebSocket] Message Error';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return WebsocketMessageError;
+    }());
+    if (false) {
+        /** @type {?} */
+        WebsocketMessageError.prototype.payload;
+    }
+    /**
+     * Action to disconnect the websocket.
+     */
+    var   /**
+     * Action to disconnect the websocket.
+     */
+    DisconnectWebSocket = /** @class */ (function () {
+        function DisconnectWebSocket() {
+        }
+        Object.defineProperty(DisconnectWebSocket, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '[WebSocket] Disconnect';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return DisconnectWebSocket;
+    }());
+    /**
+     * Action triggered when websocket is connected
+     */
+    var   /**
+     * Action triggered when websocket is connected
+     */
+    WebSocketConnected = /** @class */ (function () {
+        function WebSocketConnected() {
+        }
+        Object.defineProperty(WebSocketConnected, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return '[WebSocket] Connected';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return WebSocketConnected;
+    }());
+    /**
+     * Action triggered when websocket is disconnected
+     */
+    var   /**
+     * Action triggered when websocket is disconnected
+     */
+    WebSocketDisconnected = /** @class */ (function () {
+        function WebSocketDisconnected() {
+        }
+        Object.defineProperty(WebSocketDisconnected, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '[WebSocket] Disconnected';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return WebSocketDisconnected;
+    }());
+    /**
+     * Action to send to the server.
+     */
+    var   /**
+     * Action to send to the server.
+     */
+    SendWebSocketMessage = /** @class */ (function () {
+        function SendWebSocketMessage(payload) {
+            this.payload = payload;
+        }
+        Object.defineProperty(SendWebSocketMessage, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '[WebSocket] Send Message';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return SendWebSocketMessage;
+    }());
+    if (false) {
+        /** @type {?} */
+        SendWebSocketMessage.prototype.payload;
+    }
+    /**
+     * Action dispatched when the user tries to connect if the connection already exists.
+     */
+    var   /**
+     * Action dispatched when the user tries to connect if the connection already exists.
+     */
+    WebSocketConnectionUpdated = /** @class */ (function () {
+        function WebSocketConnectionUpdated() {
+        }
+        Object.defineProperty(WebSocketConnectionUpdated, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '[WebSocket] Connection Updated';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return WebSocketConnectionUpdated;
+    }());
+    /**
+     * This error is thrown where there is no `type` (or custom `typeKey`) property
+     * on the message that came from the server side socket
+     */
+    var /**
+     * This error is thrown where there is no `type` (or custom `typeKey`) property
+     * on the message that came from the server side socket
+     */
+    TypeKeyPropertyMissingError = /** @class */ (function (_super) {
+        __extends(TypeKeyPropertyMissingError, _super);
+        function TypeKeyPropertyMissingError(typeKey) {
+            return _super.call(this, "Property " + typeKey + " is missing on the socket message") || this;
+        }
+        return TypeKeyPropertyMissingError;
     }(Error));
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var WebSocketHandler = /** @class */ (function () {
-        function WebSocketHandler(store, actions$, options) {
-            var _this = this;
-            this.store = store;
-            this.actions$ = actions$;
-            this.options = options;
-            this.socket = null;
-            this.config = {
-                url: (/** @type {?} */ (this.options.url)),
-                protocol: this.options.protocol,
-                // Default binary type is `blob` for the global `WebSocket`
-                binaryType: this.options.binaryType,
-                serializer: this.options.serializer,
-                deserializer: this.options.deserializer,
-                closeObserver: {
-                    next: (/**
-                     * @return {?}
-                     */
-                    function () {
-                        // ATTENTION!
-                        // See https://github.com/ReactiveX/rxjs/blob/master/src/internal/observable/dom/WebSocketSubject.ts#L340
-                        // RxJS socket emits `onComplete` event only if `event.wasClean` is truthy
-                        // and doesn't complete socket subject if it's falsy
-                        _this.disconnect();
-                    })
-                },
-                openObserver: {
-                    next: (/**
-                     * @return {?}
-                     */
-                    function () { return _this.store.dispatch(new WebSocketConnected()); })
-                }
-            };
-            this.typeKey = (/** @type {?} */ (this.options.typeKey));
-            this.subscription = new rxjs.Subscription();
-            this.setupActionsListeners();
-        }
-        /**
-         * @return {?}
-         */
-        WebSocketHandler.prototype.ngOnDestroy = /**
-         * @return {?}
-         */
-        function () {
-            this.closeConnection();
-            this.subscription.unsubscribe();
-        };
-        /**
-         * @private
-         * @return {?}
-         */
-        WebSocketHandler.prototype.setupActionsListeners = /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            var _this = this;
-            this.subscription.add(this.actions$.pipe(store.ofActionDispatched(ConnectWebSocket)).subscribe((/**
-             * @param {?} __0
-             * @return {?}
-             */
-            function (_a) {
-                var payload = _a.payload;
-                _this.connect(payload);
-            })));
-            this.subscription.add(this.actions$.pipe(store.ofActionDispatched(DisconnectWebSocket)).subscribe((/**
-             * @return {?}
-             */
-            function () {
-                _this.disconnect();
-            })));
-            this.subscription.add(this.actions$.pipe(store.ofActionDispatched(SendWebSocketMessage)).subscribe((/**
-             * @param {?} __0
-             * @return {?}
-             */
-            function (_a) {
-                var payload = _a.payload;
-                _this.send(payload);
-            })));
-        };
-        /**
-         * @private
-         * @param {?=} options
-         * @return {?}
-         */
-        WebSocketHandler.prototype.connect = /**
-         * @private
-         * @param {?=} options
-         * @return {?}
-         */
-        function (options) {
-            var _this = this;
-            this.updateConnection();
-            // Users can pass the options in the connect method so
-            // if options aren't available at DI bootstrap they have access
-            // to pass them here
-            if (options) {
-                this.mergeConfigWithOptions(options);
-            }
-            this.socket = new webSocket.WebSocketSubject(this.config);
-            this.socket.subscribe({
-                next: (/**
-                 * @param {?} message
-                 * @return {?}
-                 */
-                function (message) {
-                    /** @type {?} */
-                    var type = store.getValue(message, _this.typeKey);
-                    if (!type) {
-                        throw new TypeKeyPropertyMissingError(_this.typeKey);
-                    }
-                    _this.store.dispatch(__assign({}, message, { type: type }));
-                }),
-                error: (/**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (error) {
-                    if (error instanceof CloseEvent) {
-                        _this.dispatchWebSocketDisconnected();
-                    }
-                    else {
-                        _this.store.dispatch(new WebsocketMessageError(error));
-                    }
-                })
-            });
-        };
-        /**
-         * @private
-         * @return {?}
-         */
-        WebSocketHandler.prototype.disconnect = /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            if (this.socket) {
-                this.closeConnection();
-                this.dispatchWebSocketDisconnected();
-            }
-        };
-        /**
-         * @private
-         * @param {?} data
-         * @return {?}
-         */
-        WebSocketHandler.prototype.send = /**
-         * @private
-         * @param {?} data
-         * @return {?}
-         */
-        function (data) {
-            if (!this.socket) {
-                throw new Error('You must connect to the socket before sending any data');
-            }
-            this.socket.next(data);
-        };
-        /**
-         * Don't enlarge the `connect` method
-         */
-        /**
-         * Don't enlarge the `connect` method
-         * @private
-         * @param {?} options
-         * @return {?}
-         */
-        WebSocketHandler.prototype.mergeConfigWithOptions = /**
-         * Don't enlarge the `connect` method
-         * @private
-         * @param {?} options
-         * @return {?}
-         */
-        function (options) {
-            if (options.url) {
-                this.config.url = options.url;
-            }
-            if (options.serializer) {
-                this.config.serializer = options.serializer;
-            }
-            if (options.deserializer) {
-                this.config.deserializer = options.deserializer;
-            }
-        };
-        /**
-         * To ensure we don't have any memory leaks
-         * e.g. if the user occasionally dispatched `ConnectWebSocket` twice
-         * then the previous subscription will still live in the memory
-         * to prevent such behavior - we close the previous connection if it exists
-         */
-        /**
-         * To ensure we don't have any memory leaks
-         * e.g. if the user occasionally dispatched `ConnectWebSocket` twice
-         * then the previous subscription will still live in the memory
-         * to prevent such behavior - we close the previous connection if it exists
-         * @private
-         * @return {?}
-         */
-        WebSocketHandler.prototype.updateConnection = /**
-         * To ensure we don't have any memory leaks
-         * e.g. if the user occasionally dispatched `ConnectWebSocket` twice
-         * then the previous subscription will still live in the memory
-         * to prevent such behavior - we close the previous connection if it exists
-         * @private
-         * @return {?}
-         */
-        function () {
-            if (this.socket) {
-                this.closeConnection();
-                this.store.dispatch(new WebSocketConnectionUpdated());
-            }
-        };
-        /**
-         * Used in many places so it's better to move the code into function
-         */
-        /**
-         * Used in many places so it's better to move the code into function
-         * @private
-         * @return {?}
-         */
-        WebSocketHandler.prototype.dispatchWebSocketDisconnected = /**
-         * Used in many places so it's better to move the code into function
-         * @private
-         * @return {?}
-         */
-        function () {
-            this.store.dispatch(new WebSocketDisconnected());
-        };
-        /**
-         * @private
-         * @return {?}
-         */
-        WebSocketHandler.prototype.closeConnection = /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            // `socket.complete()` closes the connection
-            // also it doesn't invoke the `onComplete` callback that we passed
-            // into `socket.subscribe(...)`
-            if (this.socket !== null) {
-                this.socket.complete();
-                this.socket = null;
-            }
-        };
-        WebSocketHandler.decorators = [
-            { type: core.Injectable }
-        ];
-        /** @nocollapse */
-        WebSocketHandler.ctorParameters = function () { return [
-            { type: store.Store },
-            { type: store.Actions },
-            { type: undefined, decorators: [{ type: core.Inject, args: [NGXS_WEBSOCKET_OPTIONS,] }] }
-        ]; };
-        return WebSocketHandler;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.socket;
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.config;
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.typeKey;
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.subscription;
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.store;
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.actions$;
-        /**
-         * @type {?}
-         * @private
-         */
-        WebSocketHandler.prototype.options;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var WebSocketHandler = /** @class */ (function () {
+        function WebSocketHandler(store, actions$, options) {
+            var _this = this;
+            this.store = store;
+            this.actions$ = actions$;
+            this.options = options;
+            this.socket = null;
+            this.config = {
+                url: (/** @type {?} */ (this.options.url)),
+                protocol: this.options.protocol,
+                // Default binary type is `blob` for the global `WebSocket`
+                binaryType: this.options.binaryType,
+                serializer: this.options.serializer,
+                deserializer: this.options.deserializer,
+                closeObserver: {
+                    next: (/**
+                     * @return {?}
+                     */
+                    function () {
+                        // ATTENTION!
+                        // See https://github.com/ReactiveX/rxjs/blob/master/src/internal/observable/dom/WebSocketSubject.ts#L340
+                        // RxJS socket emits `onComplete` event only if `event.wasClean` is truthy
+                        // and doesn't complete socket subject if it's falsy
+                        _this.disconnect();
+                    })
+                },
+                openObserver: {
+                    next: (/**
+                     * @return {?}
+                     */
+                    function () { return _this.store.dispatch(new WebSocketConnected()); })
+                }
+            };
+            this.typeKey = (/** @type {?} */ (this.options.typeKey));
+            this.subscription = new rxjs.Subscription();
+            this.setupActionsListeners();
+        }
+        /**
+         * @return {?}
+         */
+        WebSocketHandler.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+        function () {
+            this.closeConnection();
+            this.subscription.unsubscribe();
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        WebSocketHandler.prototype.setupActionsListeners = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            var _this = this;
+            this.subscription.add(this.actions$.pipe(store.ofActionDispatched(ConnectWebSocket)).subscribe((/**
+             * @param {?} __0
+             * @return {?}
+             */
+            function (_a) {
+                var payload = _a.payload;
+                _this.connect(payload);
+            })));
+            this.subscription.add(this.actions$.pipe(store.ofActionDispatched(DisconnectWebSocket)).subscribe((/**
+             * @return {?}
+             */
+            function () {
+                _this.disconnect();
+            })));
+            this.subscription.add(this.actions$.pipe(store.ofActionDispatched(SendWebSocketMessage)).subscribe((/**
+             * @param {?} __0
+             * @return {?}
+             */
+            function (_a) {
+                var payload = _a.payload;
+                _this.send(payload);
+            })));
+        };
+        /**
+         * @private
+         * @param {?=} options
+         * @return {?}
+         */
+        WebSocketHandler.prototype.connect = /**
+         * @private
+         * @param {?=} options
+         * @return {?}
+         */
+        function (options) {
+            var _this = this;
+            this.updateConnection();
+            // Users can pass the options in the connect method so
+            // if options aren't available at DI bootstrap they have access
+            // to pass them here
+            if (options) {
+                this.mergeConfigWithOptions(options);
+            }
+            this.socket = new webSocket.WebSocketSubject(this.config);
+            this.socket.subscribe({
+                next: (/**
+                 * @param {?} message
+                 * @return {?}
+                 */
+                function (message) {
+                    /** @type {?} */
+                    var type = store.getValue(message, _this.typeKey);
+                    if (!type) {
+                        throw new TypeKeyPropertyMissingError(_this.typeKey);
+                    }
+                    _this.store.dispatch(__assign({}, message, { type: type }));
+                }),
+                error: (/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    if (error instanceof CloseEvent) {
+                        _this.dispatchWebSocketDisconnected();
+                    }
+                    else {
+                        _this.store.dispatch(new WebsocketMessageError(error));
+                    }
+                })
+            });
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        WebSocketHandler.prototype.disconnect = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            if (this.socket) {
+                this.closeConnection();
+                this.dispatchWebSocketDisconnected();
+            }
+        };
+        /**
+         * @private
+         * @param {?} data
+         * @return {?}
+         */
+        WebSocketHandler.prototype.send = /**
+         * @private
+         * @param {?} data
+         * @return {?}
+         */
+        function (data) {
+            if (!this.socket) {
+                throw new Error('You must connect to the socket before sending any data');
+            }
+            this.socket.next(data);
+        };
+        /**
+         * Don't enlarge the `connect` method
+         */
+        /**
+         * Don't enlarge the `connect` method
+         * @private
+         * @param {?} options
+         * @return {?}
+         */
+        WebSocketHandler.prototype.mergeConfigWithOptions = /**
+         * Don't enlarge the `connect` method
+         * @private
+         * @param {?} options
+         * @return {?}
+         */
+        function (options) {
+            if (options.url) {
+                this.config.url = options.url;
+            }
+            if (options.serializer) {
+                this.config.serializer = options.serializer;
+            }
+            if (options.deserializer) {
+                this.config.deserializer = options.deserializer;
+            }
+        };
+        /**
+         * To ensure we don't have any memory leaks
+         * e.g. if the user occasionally dispatched `ConnectWebSocket` twice
+         * then the previous subscription will still live in the memory
+         * to prevent such behavior - we close the previous connection if it exists
+         */
+        /**
+         * To ensure we don't have any memory leaks
+         * e.g. if the user occasionally dispatched `ConnectWebSocket` twice
+         * then the previous subscription will still live in the memory
+         * to prevent such behavior - we close the previous connection if it exists
+         * @private
+         * @return {?}
+         */
+        WebSocketHandler.prototype.updateConnection = /**
+         * To ensure we don't have any memory leaks
+         * e.g. if the user occasionally dispatched `ConnectWebSocket` twice
+         * then the previous subscription will still live in the memory
+         * to prevent such behavior - we close the previous connection if it exists
+         * @private
+         * @return {?}
+         */
+        function () {
+            if (this.socket) {
+                this.closeConnection();
+                this.store.dispatch(new WebSocketConnectionUpdated());
+            }
+        };
+        /**
+         * Used in many places so it's better to move the code into function
+         */
+        /**
+         * Used in many places so it's better to move the code into function
+         * @private
+         * @return {?}
+         */
+        WebSocketHandler.prototype.dispatchWebSocketDisconnected = /**
+         * Used in many places so it's better to move the code into function
+         * @private
+         * @return {?}
+         */
+        function () {
+            this.store.dispatch(new WebSocketDisconnected());
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        WebSocketHandler.prototype.closeConnection = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            // `socket.complete()` closes the connection
+            // also it doesn't invoke the `onComplete` callback that we passed
+            // into `socket.subscribe(...)`
+            if (this.socket !== null) {
+                this.socket.complete();
+                this.socket = null;
+            }
+        };
+        WebSocketHandler.decorators = [
+            { type: core.Injectable }
+        ];
+        /** @nocollapse */
+        WebSocketHandler.ctorParameters = function () { return [
+            { type: store.Store },
+            { type: store.Actions },
+            { type: undefined, decorators: [{ type: core.Inject, args: [NGXS_WEBSOCKET_OPTIONS,] }] }
+        ]; };
+        return WebSocketHandler;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.socket;
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.config;
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.typeKey;
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.subscription;
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.store;
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.actions$;
+        /**
+         * @type {?}
+         * @private
+         */
+        WebSocketHandler.prototype.options;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @param {?} options
-     * @return {?}
-     */
-    function websocketOptionsFactory(options) {
-        return __assign({ reconnectInterval: 5000, reconnectAttempts: 10, typeKey: 'type', deserializer: /**
-             * @param {?} e
-             * @return {?}
-             */
-            function (e) {
-                return JSON.parse(e.data);
-            },
-            serializer: /**
-             * @param {?} value
-             * @return {?}
-             */
-            function (value) {
-                return JSON.stringify(value);
-            } }, options);
-    }
-    /** @type {?} */
-    var USER_OPTIONS = new core.InjectionToken('USER_OPTIONS');
-    var NgxsWebsocketPluginModule = /** @class */ (function () {
-        function NgxsWebsocketPluginModule() {
-        }
-        /**
-         * @param {?=} options
-         * @return {?}
-         */
-        NgxsWebsocketPluginModule.forRoot = /**
-         * @param {?=} options
-         * @return {?}
-         */
-        function (options) {
-            return {
-                ngModule: NgxsWebsocketPluginModule,
-                providers: [
-                    WebSocketHandler,
-                    {
-                        provide: USER_OPTIONS,
-                        useValue: options
-                    },
-                    {
-                        provide: NGXS_WEBSOCKET_OPTIONS,
-                        useFactory: websocketOptionsFactory,
-                        deps: [USER_OPTIONS]
-                    },
-                    {
-                        provide: core.APP_INITIALIZER,
-                        useFactory: noop,
-                        deps: [WebSocketHandler],
-                        multi: true
-                    }
-                ]
-            };
-        };
-        NgxsWebsocketPluginModule.decorators = [
-            { type: core.NgModule }
-        ];
-        return NgxsWebsocketPluginModule;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    function websocketOptionsFactory(options) {
+        return __assign({ reconnectInterval: 5000, reconnectAttempts: 10, typeKey: 'type', deserializer: /**
+             * @param {?} e
+             * @return {?}
+             */
+            function (e) {
+                return JSON.parse(e.data);
+            },
+            serializer: /**
+             * @param {?} value
+             * @return {?}
+             */
+            function (value) {
+                return JSON.stringify(value);
+            } }, options);
+    }
+    /** @type {?} */
+    var USER_OPTIONS = new core.InjectionToken('USER_OPTIONS');
+    var NgxsWebsocketPluginModule = /** @class */ (function () {
+        function NgxsWebsocketPluginModule() {
+        }
+        /**
+         * @param {?=} options
+         * @return {?}
+         */
+        NgxsWebsocketPluginModule.forRoot = /**
+         * @param {?=} options
+         * @return {?}
+         */
+        function (options) {
+            return {
+                ngModule: NgxsWebsocketPluginModule,
+                providers: [
+                    WebSocketHandler,
+                    {
+                        provide: USER_OPTIONS,
+                        useValue: options
+                    },
+                    {
+                        provide: NGXS_WEBSOCKET_OPTIONS,
+                        useFactory: websocketOptionsFactory,
+                        deps: [USER_OPTIONS]
+                    },
+                    {
+                        provide: core.APP_INITIALIZER,
+                        useFactory: noop,
+                        deps: [WebSocketHandler],
+                        multi: true
+                    }
+                ]
+            };
+        };
+        NgxsWebsocketPluginModule.decorators = [
+            { type: core.NgModule }
+        ];
+        return NgxsWebsocketPluginModule;
     }());
 
     exports.ConnectWebSocket = ConnectWebSocket;