redux-cluster-ws 2.0.2 → 2.0.3

package/dist/cjs/client.js

@@ -273,4 +273,3 @@ function client(store) {
     }
     return store;
 }
-//# sourceMappingURL=client.js.map

package/dist/cjs/index.js

@@ -22,4 +22,3 @@ Object.defineProperty(exports, "client", { enumerable: true, get: function () {
 Object.defineProperty(exports, "createStore", { enumerable: true, get: function () { return client_js_1.createStore; } });
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./utils.js"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/server.js

@@ -292,4 +292,3 @@ function server(store) {
     new ReduxClusterWSServerWrapper(store);
     return store;
 }
-//# sourceMappingURL=server.js.map

package/dist/cjs/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/cjs/utils.js

@@ -72,4 +72,3 @@ function deepClone(obj) {
     }
     return obj;
 }
-//# sourceMappingURL=utils.js.map

package/dist/esm/client.js

@@ -18,20 +18,15 @@ const WebSocketClass = (() => {
     }
 })();
 export class ReduxCluster {
-    stderr = console.error;
-    role = [];
-    mode = "action";
-    connected = false;
-    resync = 1000;
-    RCHash;
-    version;
-    homepage;
-    createWSClient;
-    store;
-    altReducer;
-    defaultState;
-    static reducers = {};
     constructor(reducer) {
+        this.stderr = console.error;
+        this.role = [];
+        this.mode = "action";
+        this.connected = false;
+        this.resync = 1000;
+        this.dispatch = (action) => {
+            return this.store.dispatch(action);
+        };
         this.altReducer = reducer;
         this.RCHash = hasher(reducer.name);
         // Get version and homepage from package.json (would need to be injected in real implementation)
@@ -71,9 +66,6 @@ export class ReduxCluster {
     getState() {
         return this.store.getState();
     }
-    dispatch = (action) => {
-        return this.store.dispatch(action);
-    };
     subscribe(listener) {
         return this.store.subscribe(listener);
     }
@@ -84,16 +76,126 @@ export class ReduxCluster {
         return this.store[Symbol.observable]();
     }
 }
+ReduxCluster.reducers = {};
 export class ReduxClusterWSClientWrapper {
-    store;
-    config;
-    ws;
-    reconnectTimer;
-    authenticated = false;
-    login;
-    password;
-    originalDispatch;
     constructor(store, config) {
+        this.authenticated = false;
+        this.reconnect = () => {
+            try {
+                const url = this.buildWebSocketURL();
+                this.ws = new WebSocketClass(url);
+                if (this.ws) {
+                    this.ws.onopen = () => {
+                        this.sendMessage({
+                            _msg: "REDUX_CLUSTER_SOCKET_AUTH",
+                            _hash: this.store.RCHash,
+                            _login: this.login,
+                            _password: this.password,
+                        });
+                    };
+                    this.ws.onmessage = (event) => {
+                        try {
+                            const message = JSON.parse(event.data);
+                            this.handleMessage(message);
+                        }
+                        catch (error) {
+                            this.store.stderr(`ReduxCluster.createWSClient message parse error: ${error}`);
+                        }
+                    };
+                    this.ws.onclose = () => {
+                        this.authenticated = false;
+                        this.store.connected = false;
+                        this.scheduleReconnect();
+                    };
+                    this.ws.onerror = (error) => {
+                        this.store.stderr(`ReduxCluster.createWSClient connection error: ${error}`);
+                        this.authenticated = false;
+                        this.store.connected = false;
+                    };
+                }
+            }
+            catch (error) {
+                this.store.stderr(`ReduxCluster.createWSClient client error: ${error}`);
+                this.store.connected = false;
+                this.scheduleReconnect();
+            }
+        };
+        this.handleMessage = (message) => {
+            if (message._hash !== this.store.RCHash) {
+                return;
+            }
+            switch (message._msg) {
+                case "REDUX_CLUSTER_MSGTOWORKER":
+                    if (message._action) {
+                        this.originalDispatch(message._action);
+                    }
+                    break;
+                case "REDUX_CLUSTER_SOCKET_AUTHSTATE":
+                    if (message._value === true) {
+                        this.authenticated = true;
+                        this.store.connected = true;
+                        this.sendMessage({
+                            _msg: "REDUX_CLUSTER_START",
+                            _hash: this.store.RCHash,
+                        });
+                    }
+                    else {
+                        this.authenticated = false;
+                        this.store.connected = false;
+                        if (message._banned) {
+                            this.store.stderr("Your IP is locked for 3 hours");
+                        }
+                        else {
+                            this.store.stderr("Authorization failed");
+                        }
+                        this.ws?.close();
+                    }
+                    break;
+            }
+        };
+        this.dispatch = (action) => {
+            try {
+                if (this.ws && this.ws.readyState === 1 && this.authenticated) {
+                    // WebSocket.OPEN = 1
+                    this.sendMessage({
+                        _msg: "REDUX_CLUSTER_MSGTOMASTER",
+                        _hash: this.store.RCHash,
+                        _action: action,
+                    });
+                }
+                else {
+                    this.store.stderr("WebSocket is not connected or not authenticated");
+                }
+            }
+            catch (error) {
+                this.store.stderr(`ReduxCluster.createWSClient write error: ${error}`);
+            }
+            return action;
+        };
+        this.sendMessage = (message) => {
+            if (this.ws && this.ws.readyState === 1) {
+                // WebSocket.OPEN = 1
+                this.ws.send(JSON.stringify(message));
+            }
+        };
+        this.scheduleReconnect = () => {
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+            }
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnect();
+            }, this.config.reconnectInterval);
+        };
+        this.destroy = () => {
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+            }
+            if (this.ws) {
+                this.ws.close();
+            }
+            // Restore original dispatch
+            this.store.dispatch = this.originalDispatch;
+        };
         this.store = store;
         this.config = {
             port: 10002,
@@ -127,46 +229,6 @@ export class ReduxClusterWSClientWrapper {
         this.store.connected = false;
         this.reconnect();
     }
-    reconnect = () => {
-        try {
-            const url = this.buildWebSocketURL();
-            this.ws = new WebSocketClass(url);
-            if (this.ws) {
-                this.ws.onopen = () => {
-                    this.sendMessage({
-                        _msg: "REDUX_CLUSTER_SOCKET_AUTH",
-                        _hash: this.store.RCHash,
-                        _login: this.login,
-                        _password: this.password,
-                    });
-                };
-                this.ws.onmessage = (event) => {
-                    try {
-                        const message = JSON.parse(event.data);
-                        this.handleMessage(message);
-                    }
-                    catch (error) {
-                        this.store.stderr(`ReduxCluster.createWSClient message parse error: ${error}`);
-                    }
-                };
-                this.ws.onclose = () => {
-                    this.authenticated = false;
-                    this.store.connected = false;
-                    this.scheduleReconnect();
-                };
-                this.ws.onerror = (error) => {
-                    this.store.stderr(`ReduxCluster.createWSClient connection error: ${error}`);
-                    this.authenticated = false;
-                    this.store.connected = false;
-                };
-            }
-        }
-        catch (error) {
-            this.store.stderr(`ReduxCluster.createWSClient client error: ${error}`);
-            this.store.connected = false;
-            this.scheduleReconnect();
-        }
-    };
     buildWebSocketURL() {
         const protocol = this.config.host.toLowerCase().includes("https://")
             ? "wss:"
@@ -175,82 +237,6 @@ export class ReduxClusterWSClientWrapper {
         const path = `/redux-cluster-${this.store.RCHash}`;
         return `${protocol}//${host}:${this.config.port}${path}`;
     }
-    handleMessage = (message) => {
-        if (message._hash !== this.store.RCHash) {
-            return;
-        }
-        switch (message._msg) {
-            case "REDUX_CLUSTER_MSGTOWORKER":
-                if (message._action) {
-                    this.originalDispatch(message._action);
-                }
-                break;
-            case "REDUX_CLUSTER_SOCKET_AUTHSTATE":
-                if (message._value === true) {
-                    this.authenticated = true;
-                    this.store.connected = true;
-                    this.sendMessage({
-                        _msg: "REDUX_CLUSTER_START",
-                        _hash: this.store.RCHash,
-                    });
-                }
-                else {
-                    this.authenticated = false;
-                    this.store.connected = false;
-                    if (message._banned) {
-                        this.store.stderr("Your IP is locked for 3 hours");
-                    }
-                    else {
-                        this.store.stderr("Authorization failed");
-                    }
-                    this.ws?.close();
-                }
-                break;
-        }
-    };
-    dispatch = (action) => {
-        try {
-            if (this.ws && this.ws.readyState === 1 && this.authenticated) {
-                // WebSocket.OPEN = 1
-                this.sendMessage({
-                    _msg: "REDUX_CLUSTER_MSGTOMASTER",
-                    _hash: this.store.RCHash,
-                    _action: action,
-                });
-            }
-            else {
-                this.store.stderr("WebSocket is not connected or not authenticated");
-            }
-        }
-        catch (error) {
-            this.store.stderr(`ReduxCluster.createWSClient write error: ${error}`);
-        }
-        return action;
-    };
-    sendMessage = (message) => {
-        if (this.ws && this.ws.readyState === 1) {
-            // WebSocket.OPEN = 1
-            this.ws.send(JSON.stringify(message));
-        }
-    };
-    scheduleReconnect = () => {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-        }
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnect();
-        }, this.config.reconnectInterval);
-    };
-    destroy = () => {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-        }
-        if (this.ws) {
-            this.ws.close();
-        }
-        // Restore original dispatch
-        this.store.dispatch = this.originalDispatch;
-    };
 }
 export function createStore(reducer) {
     const reduxCluster = new ReduxCluster(reducer);
@@ -279,4 +265,3 @@ export function client(store) {
     }
     return store;
 }
-//# sourceMappingURL=client.js.map

package/dist/esm/index.js

@@ -2,4 +2,3 @@ export { server } from "./server.js";
 export { client, createStore } from "./client.js";
 export * from "./types.js";
 export * from "./utils.js";
-//# sourceMappingURL=index.js.map