slapflow 1.2.0 → 1.2.1

package/dist/index.cjs

@@ -2675,115 +2675,148 @@ var createWS = (options) => {
   return { start, stop, reconnect, status: () => currentStatus };
 };
 
+// src/helpers/parsePayload.ts
+var parsePayload = (data) => {
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  return data;
+};
+
 // src/createWebSocket.ts
-var createWebSocket = (options) => {
-  let socket;
-  let retryTimer;
-  let retryAttempt = 0;
-  let started = false;
-  let currentStatus = "idle";
-  const emitSocketEvent = (topic, payload) => {
-    options.bus.dispatch({
-      id: createId(),
-      topic,
-      occurredAt: Date.now(),
-      ...options.origin ? { origin: options.origin } : {},
-      parsed: payload,
-      serialized: JSON.stringify(payload)
-    });
-  };
-  const scheduleRetry = () => {
-    const delay = getRetryDelay(retryAttempt, options.reconnect ?? {});
-    const attempt = retryAttempt + 1;
-    currentStatus = "reconnecting";
-    retryAttempt = attempt;
-    retryTimer = setTimeout(() => {
-      retryTimer = void 0;
-      connect();
-    }, delay);
-  };
-  const connect = () => {
-    if (!started || socket) {
+var WebSocketConnection = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  _socket;
+  _retryTimer;
+  _retryAttempt = 0;
+  _queue = [];
+  _started = false;
+  _status = "idle";
+  start() {
+    if (!this._started) {
+      this._started = true;
+      this.connect();
+    }
+  }
+  stop() {
+    this._started = false;
+    this.clearTimer();
+    this.clearQueue();
+    const current = this._socket;
+    this._socket = void 0;
+    current?.close();
+    this.setStatus("stopped");
+  }
+  reconnect() {
+    if (this._started) {
+      this.clearTimer();
+      const current = this._socket;
+      this._socket = void 0;
+      current?.close();
+      this.connect();
+    }
+  }
+  status() {
+    return this._status;
+  }
+  send(data) {
+    if (this._socket?.readyState === WebSocket.OPEN) {
+      this._socket.send(data);
+    } else {
+      this._queue.push(data);
+    }
+  }
+  connect() {
+    if (!this._started || this._socket) {
       return;
     }
-    currentStatus = "connecting";
-    try {
-      const current = new WebSocket(options.url, options.protocols ?? []);
-      socket = current;
-      current.addEventListener("open", () => {
-        if (socket === current) {
-          retryAttempt = 0;
-          currentStatus = "connected";
-          emitSocketEvent("open", { url: options.url });
-        }
-      });
-      current.addEventListener("message", (event) => {
-        if (socket !== current) {
-          return;
-        }
-        let parsed = event.data;
-        if (typeof parsed === "string") {
-          try {
-            parsed = JSON.parse(parsed);
-          } catch {
-            parsed = event.data;
-          }
-        }
-        emitSocketEvent("message", parsed);
-      });
-      current.addEventListener("close", (event) => {
-        if (socket !== current) {
-          return;
-        }
-        socket = void 0;
-        emitSocketEvent("close", { code: event.code, reason: event.reason });
-        if (started) {
-          scheduleRetry();
-        }
-      });
-      current.addEventListener("error", (event) => {
-        emitSocketEvent("error", { error: event });
-      });
-    } catch (error) {
-      socket = void 0;
-      emitSocketEvent("error", { error });
-      if (started) {
-        scheduleRetry();
+    const { url, protocols } = this.options;
+    const current = new WebSocket(url, protocols ?? []);
+    this._socket = current;
+    this.setStatus("connecting");
+    current.addEventListener("open", () => this.onOpen(current));
+    current.addEventListener("message", (event) => this.onMessage(current, event));
+    current.addEventListener("close", (event) => this.onClose(current, event));
+    current.addEventListener("error", (event) => this.onError(current, event));
+  }
+  onOpen(current) {
+    if (this._socket === current) {
+      this._retryAttempt = 0;
+      this.setStatus("connected");
+      this.flush();
+      this.dispatch("open", { url: this.options.url });
+    }
+  }
+  onMessage(current, event) {
+    if (this._socket === current) {
+      this.dispatch("message", parsePayload(event.data));
+    }
+  }
+  onClose(current, event) {
+    if (this._socket === current) {
+      this._socket = void 0;
+      this.dispatch("close", event);
+      if (this._started) {
+        this.retry();
       }
     }
-  };
-  const start = () => {
-    if (!started) {
-      started = true;
-      connect();
-    }
-  };
-  const stop = () => {
-    started = false;
-    if (retryTimer) {
-      clearTimeout(retryTimer);
+  }
+  onError(current, event) {
+    if (this._socket === current) {
+      this.dispatch("error", serializeError(event.error));
     }
-    retryTimer = void 0;
-    const current = socket;
-    socket = void 0;
-    current?.close();
-    currentStatus = "stopped";
-  };
-  const reconnect = () => {
-    if (!started) {
-      return;
+  }
+  dispatch(topic, parsed) {
+    const { bus, origin } = this.options;
+    bus.dispatch({
+      id: createId(),
+      topic,
+      occurredAt: Date.now(),
+      ...origin ? { origin } : {},
+      parsed,
+      serialized: JSON.stringify(parsed)
+    });
+  }
+  flush() {
+    if (this._socket && this._socket.readyState === WebSocket.OPEN) {
+      for (const message of this._queue) {
+        this._socket.send(message);
+      }
+      this.clearQueue();
     }
-    if (retryTimer) {
-      clearTimeout(retryTimer);
-      retryTimer = void 0;
+  }
+  retry() {
+    this.setStatus("reconnecting");
+    this._retryTimer = setTimeout(
+      () => {
+        this._retryTimer = void 0;
+        this.connect();
+      },
+      getRetryDelay(this._retryAttempt, this.options.reconnect ?? {})
+    );
+    this._retryAttempt = this._retryAttempt + 1;
+  }
+  setStatus(status) {
+    this._status = status || "idle";
+  }
+  clearQueue() {
+    this._queue = [];
+  }
+  clearTimer() {
+    if (this._retryTimer) {
+      clearTimeout(this._retryTimer);
     }
-    const current = socket;
-    socket = void 0;
-    current?.close();
-    connect();
-  };
-  return { start, stop, reconnect, status: () => currentStatus };
+    this._retryTimer = void 0;
+  }
 };
+var createWebSocket = (options) => new WebSocketConnection(options);
 
 // src/helpers/catchError.ts
 var catchError = (callback) => new Promise((resolve, reject) => {

package/dist/index.d.cts

@@ -162,6 +162,7 @@ type WSClient = {
     stop(): void;
     reconnect(): void;
     status(): WebSocketStatus;
+    send(data: string): void;
 };
 type BindingEventMap = Record<string, Input>;
 type BusBindingKey<TEvents extends object> = {

package/dist/index.d.ts

@@ -162,6 +162,7 @@ type WSClient = {
     stop(): void;
     reconnect(): void;
     status(): WebSocketStatus;
+    send(data: string): void;
 };
 type BindingEventMap = Record<string, Input>;
 type BusBindingKey<TEvents extends object> = {

package/dist/index.js

@@ -2637,115 +2637,148 @@ var createWS = (options) => {
   return { start, stop, reconnect, status: () => currentStatus };
 };
 
+// src/helpers/parsePayload.ts
+var parsePayload = (data) => {
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  return data;
+};
+
 // src/createWebSocket.ts
-var createWebSocket = (options) => {
-  let socket;
-  let retryTimer;
-  let retryAttempt = 0;
-  let started = false;
-  let currentStatus = "idle";
-  const emitSocketEvent = (topic, payload) => {
-    options.bus.dispatch({
-      id: createId(),
-      topic,
-      occurredAt: Date.now(),
-      ...options.origin ? { origin: options.origin } : {},
-      parsed: payload,
-      serialized: JSON.stringify(payload)
-    });
-  };
-  const scheduleRetry = () => {
-    const delay = getRetryDelay(retryAttempt, options.reconnect ?? {});
-    const attempt = retryAttempt + 1;
-    currentStatus = "reconnecting";
-    retryAttempt = attempt;
-    retryTimer = setTimeout(() => {
-      retryTimer = void 0;
-      connect();
-    }, delay);
-  };
-  const connect = () => {
-    if (!started || socket) {
+var WebSocketConnection = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  _socket;
+  _retryTimer;
+  _retryAttempt = 0;
+  _queue = [];
+  _started = false;
+  _status = "idle";
+  start() {
+    if (!this._started) {
+      this._started = true;
+      this.connect();
+    }
+  }
+  stop() {
+    this._started = false;
+    this.clearTimer();
+    this.clearQueue();
+    const current = this._socket;
+    this._socket = void 0;
+    current?.close();
+    this.setStatus("stopped");
+  }
+  reconnect() {
+    if (this._started) {
+      this.clearTimer();
+      const current = this._socket;
+      this._socket = void 0;
+      current?.close();
+      this.connect();
+    }
+  }
+  status() {
+    return this._status;
+  }
+  send(data) {
+    if (this._socket?.readyState === WebSocket.OPEN) {
+      this._socket.send(data);
+    } else {
+      this._queue.push(data);
+    }
+  }
+  connect() {
+    if (!this._started || this._socket) {
       return;
     }
-    currentStatus = "connecting";
-    try {
-      const current = new WebSocket(options.url, options.protocols ?? []);
-      socket = current;
-      current.addEventListener("open", () => {
-        if (socket === current) {
-          retryAttempt = 0;
-          currentStatus = "connected";
-          emitSocketEvent("open", { url: options.url });
-        }
-      });
-      current.addEventListener("message", (event) => {
-        if (socket !== current) {
-          return;
-        }
-        let parsed = event.data;
-        if (typeof parsed === "string") {
-          try {
-            parsed = JSON.parse(parsed);
-          } catch {
-            parsed = event.data;
-          }
-        }
-        emitSocketEvent("message", parsed);
-      });
-      current.addEventListener("close", (event) => {
-        if (socket !== current) {
-          return;
-        }
-        socket = void 0;
-        emitSocketEvent("close", { code: event.code, reason: event.reason });
-        if (started) {
-          scheduleRetry();
-        }
-      });
-      current.addEventListener("error", (event) => {
-        emitSocketEvent("error", { error: event });
-      });
-    } catch (error) {
-      socket = void 0;
-      emitSocketEvent("error", { error });
-      if (started) {
-        scheduleRetry();
+    const { url, protocols } = this.options;
+    const current = new WebSocket(url, protocols ?? []);
+    this._socket = current;
+    this.setStatus("connecting");
+    current.addEventListener("open", () => this.onOpen(current));
+    current.addEventListener("message", (event) => this.onMessage(current, event));
+    current.addEventListener("close", (event) => this.onClose(current, event));
+    current.addEventListener("error", (event) => this.onError(current, event));
+  }
+  onOpen(current) {
+    if (this._socket === current) {
+      this._retryAttempt = 0;
+      this.setStatus("connected");
+      this.flush();
+      this.dispatch("open", { url: this.options.url });
+    }
+  }
+  onMessage(current, event) {
+    if (this._socket === current) {
+      this.dispatch("message", parsePayload(event.data));
+    }
+  }
+  onClose(current, event) {
+    if (this._socket === current) {
+      this._socket = void 0;
+      this.dispatch("close", event);
+      if (this._started) {
+        this.retry();
       }
     }
-  };
-  const start = () => {
-    if (!started) {
-      started = true;
-      connect();
-    }
-  };
-  const stop = () => {
-    started = false;
-    if (retryTimer) {
-      clearTimeout(retryTimer);
+  }
+  onError(current, event) {
+    if (this._socket === current) {
+      this.dispatch("error", serializeError(event.error));
     }
-    retryTimer = void 0;
-    const current = socket;
-    socket = void 0;
-    current?.close();
-    currentStatus = "stopped";
-  };
-  const reconnect = () => {
-    if (!started) {
-      return;
+  }
+  dispatch(topic, parsed) {
+    const { bus, origin } = this.options;
+    bus.dispatch({
+      id: createId(),
+      topic,
+      occurredAt: Date.now(),
+      ...origin ? { origin } : {},
+      parsed,
+      serialized: JSON.stringify(parsed)
+    });
+  }
+  flush() {
+    if (this._socket && this._socket.readyState === WebSocket.OPEN) {
+      for (const message of this._queue) {
+        this._socket.send(message);
+      }
+      this.clearQueue();
     }
-    if (retryTimer) {
-      clearTimeout(retryTimer);
-      retryTimer = void 0;
+  }
+  retry() {
+    this.setStatus("reconnecting");
+    this._retryTimer = setTimeout(
+      () => {
+        this._retryTimer = void 0;
+        this.connect();
+      },
+      getRetryDelay(this._retryAttempt, this.options.reconnect ?? {})
+    );
+    this._retryAttempt = this._retryAttempt + 1;
+  }
+  setStatus(status) {
+    this._status = status || "idle";
+  }
+  clearQueue() {
+    this._queue = [];
+  }
+  clearTimer() {
+    if (this._retryTimer) {
+      clearTimeout(this._retryTimer);
     }
-    const current = socket;
-    socket = void 0;
-    current?.close();
-    connect();
-  };
-  return { start, stop, reconnect, status: () => currentStatus };
+    this._retryTimer = void 0;
+  }
 };
+var createWebSocket = (options) => new WebSocketConnection(options);
 
 // src/helpers/catchError.ts
 var catchError = (callback) => new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slapflow",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Chain actions behavior runtime",
   "license": "ISC",
   "author": "Sergey Khalilov",