@f3liz/rescript-misskey-api 0.6.6 → 0.6.8

package/lib/es6/src/stream/StreamClient.mjs

@@ -2,6 +2,7 @@
 
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as StreamProtocol from "./StreamProtocol.mjs";
+import * as MisskeyWebSocket from "../bindings/MisskeyWebSocket.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as StreamConnection from "./StreamConnection.mjs";
@@ -25,11 +26,17 @@ function make(origin, credential, param) {
     idCounter: 0,
     broadcastHandlers: {},
     onConnectedCallback: undefined,
-    onDisconnectedCallback: undefined
+    onDisconnectedCallback: undefined,
+    pendingMessages: []
   };
   ws.addEventListener("open", _event => {
     let isReconnect = stream.state === "reconnecting";
     stream.state = "connected";
+    let pending = stream.pendingMessages;
+    stream.pendingMessages = [];
+    pending.forEach(msg => {
+      stream.ws.send(msg);
+    });
     let cb = stream.onConnectedCallback;
     if (cb !== undefined) {
       cb();
@@ -99,7 +106,11 @@ function make(origin, credential, param) {
 
 function send(stream, msg) {
   let serialized = StreamProtocol.serializeOutgoing(msg);
-  stream.ws.send(serialized);
+  if (MisskeyWebSocket.isOpen(stream.ws) && stream.pendingMessages.length === 0) {
+    stream.ws.send(serialized);
+  } else {
+    stream.pendingMessages = stream.pendingMessages.concat([serialized]);
+  }
 }
 
 function ping(stream) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-misskey-api",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "ReScript bindings for Misskey API using OpenAPI code generation",
   "keywords": [
     "misskey",

package/src/bindings/{WebSocket.res → MisskeyWebSocket.res}

@@ -1,4 +1,4 @@
-// WebSocket.res - Browser WebSocket API bindings for ReScript
+// MisskeyWebSocket.res - Browser WebSocket API bindings for ReScript
 
 // WebSocket ready state constants
 module ReadyState = {

package/src/stream/NativeStreamBindings.res

@@ -40,11 +40,11 @@ let sendTyped = (stream: stream, type_: string, payload: JSON.t): unit => {
   let obj = Dict.make()
   obj->Dict.set("type", type_->JSON.Encode.string)
   obj->Dict.set("body", payload)
-  stream.ws->WebSocket.send(obj->JSON.Encode.object->JSON.stringify)
+  stream.ws->MisskeyWebSocket.send(obj->JSON.Encode.object->JSON.stringify)
 }
 
 let sendRaw = (stream: stream, payload: JSON.t): unit => {
-  stream.ws->WebSocket.send(payload->JSON.stringify)
+  stream.ws->MisskeyWebSocket.send(payload->JSON.stringify)
 }
 
 // Connection management

package/src/stream/StreamClient.res

@@ -1,7 +1,7 @@
 // StreamClient.res - Native ReScript WebSocket streaming client
 // Pure ReScript implementation replacing misskey-js Stream class
 
-module WS = WebSocket
+module WS = MisskeyWebSocket
 module Protocol = StreamProtocol
 module Connection = StreamConnection
 
@@ -29,6 +29,7 @@ type t = {
   broadcastHandlers: Dict.t<JSON.t => unit>,
   mutable onConnectedCallback: option<unit => unit>,
   mutable onDisconnectedCallback: option<unit => unit>,
+  mutable pendingMessages: array<string>,
 }
 
 // Generate unique ID for connections
@@ -54,6 +55,7 @@ let make = (~origin: string, ~credential: option<string>=?, ()): t => {
     broadcastHandlers: Dict.make(),
     onConnectedCallback: None,
     onDisconnectedCallback: None,
+    pendingMessages: [],
   }
   
   // Set up WebSocket event handlers
@@ -61,6 +63,11 @@ let make = (~origin: string, ~credential: option<string>=?, ()): t => {
     let isReconnect = stream.state == #reconnecting
     stream.state = #connected
     
+    // Flush any pending messages
+    let pending = stream.pendingMessages
+    stream.pendingMessages = []
+    pending->Array.forEach(msg => stream.ws->WS.send(msg))
+    
     // Call user callback
     switch stream.onConnectedCallback {
     | Some(cb) => cb()
@@ -148,10 +155,15 @@ let make = (~origin: string, ~credential: option<string>=?, ()): t => {
   stream
 }
 
-// Send a message
+// Send a message (queues if WebSocket not yet open)
 let send = (stream: t, msg: Protocol.outgoingMessage): unit => {
   let serialized = Protocol.serializeOutgoing(msg)
-  stream.ws->WS.send(serialized)
+  if WS.isOpen(stream.ws) && Array.length(stream.pendingMessages) == 0 {
+    stream.ws->WS.send(serialized)
+  } else {
+    // Queue for when connection opens or if there are already pending messages
+    stream.pendingMessages = stream.pendingMessages->Array.concat([serialized])
+  }
 }
 
 // Ping the server