@korajs/sync 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -642,8 +642,10 @@ var WebSocketTransport = class {
   errorHandler = null;
   serializer;
   WebSocketImpl;
+  connectTimeout;
   constructor(options) {
     this.serializer = options?.serializer ?? new JsonMessageSerializer();
+    this.connectTimeout = options?.connectTimeout ?? 1e4;
     if (options?.WebSocketImpl) {
       this.WebSocketImpl = options.WebSocketImpl;
     } else if (typeof globalThis.WebSocket !== "undefined") {
@@ -659,12 +661,38 @@ var WebSocketTransport = class {
       });
     }
     return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        fn();
+      };
+      const timer = setTimeout(() => {
+        settle(() => {
+          const err = new import_core2.SyncError("WebSocket connection timed out", {
+            url,
+            timeout: this.connectTimeout
+          });
+          if (this.ws) {
+            try {
+              this.ws.onclose = null;
+              this.ws.onerror = null;
+              this.ws.close();
+            } catch {
+            }
+            this.ws = null;
+          }
+          this.errorHandler?.(err);
+          reject(err);
+        });
+      }, this.connectTimeout);
       try {
         const connectUrl = options?.authToken ? `${url}${url.includes("?") ? "&" : "?"}token=${encodeURIComponent(options.authToken)}` : url;
         const ws = new this.WebSocketImpl(connectUrl);
         this.ws = ws;
         ws.onopen = () => {
-          resolve();
+          settle(() => resolve());
         };
         ws.onmessage = (event) => {
           try {
@@ -688,15 +716,17 @@ var WebSocketTransport = class {
           this.errorHandler?.(err);
           if (!this.isConnected()) {
             this.ws = null;
-            reject(err);
+            settle(() => reject(err));
           }
         };
       } catch (err) {
-        reject(
-          err instanceof import_core2.SyncError ? err : new import_core2.SyncError("Failed to create WebSocket", {
-            url,
-            error: String(err)
-          })
+        settle(
+          () => reject(
+            err instanceof import_core2.SyncError ? err : new import_core2.SyncError("Failed to create WebSocket", {
+              url,
+              error: String(err)
+            })
+          )
         );
       }
     });
@@ -1213,6 +1243,7 @@ var SyncEngine = class {
   remoteVector = /* @__PURE__ */ new Map();
   lastSyncedAt = null;
   currentBatch = null;
+  reconnecting = false;
   // Track delta exchange state
   deltaBatchesReceived = 0;
   deltaReceiveComplete = false;
@@ -1257,8 +1288,7 @@ var SyncEngine = class {
       };
       this.transport.send(handshake);
     } catch (err) {
-      this.transitionTo("error");
-      this.transitionTo("disconnected");
+      this.ensureDisconnected();
       throw err;
     }
   }
@@ -1292,6 +1322,15 @@ var SyncEngine = class {
       this.flushQueue();
     }
   }
+  /**
+   * Mark the engine as being in a reconnection loop. When reconnecting,
+   * `getStatus()` returns 'offline' instead of 'syncing' for intermediate
+   * states (connecting, handshaking, syncing), since the user is effectively
+   * disconnected until reconnection succeeds.
+   */
+  setReconnecting(value) {
+    this.reconnecting = value;
+  }
   /**
    * Get the current developer-facing sync status.
    */
@@ -1303,7 +1342,11 @@ var SyncEngine = class {
       case "connecting":
       case "handshaking":
       case "syncing":
-        return { status: "syncing", pendingOperations, lastSyncedAt: this.lastSyncedAt };
+        return {
+          status: this.reconnecting ? "offline" : "syncing",
+          pendingOperations,
+          lastSyncedAt: this.lastSyncedAt
+        };
       case "streaming":
         return {
           status: pendingOperations > 0 ? "syncing" : "synced",
@@ -1620,6 +1663,7 @@ var ReconnectionManager = class {
   attempt = 0;
   timer = null;
   stopped = false;
+  running = false;
   waitResolve = null;
   constructor(config) {
     this.initialDelay = config?.initialDelay ?? 1e3;
@@ -1637,25 +1681,30 @@ var ReconnectionManager = class {
    */
   async start(onReconnect) {
     this.stopped = false;
+    this.running = true;
     this.attempt = 0;
-    while (!this.stopped) {
-      if (this.maxAttempts > 0 && this.attempt >= this.maxAttempts) {
-        return false;
-      }
-      const delay = this.getNextDelay();
-      this.attempt++;
-      await this.wait(delay);
-      if (this.stopped) return false;
-      try {
-        const success = await onReconnect();
-        if (success) {
-          this.reset();
-          return true;
+    try {
+      while (!this.stopped) {
+        if (this.maxAttempts > 0 && this.attempt >= this.maxAttempts) {
+          return false;
+        }
+        const delay = this.getNextDelay();
+        this.attempt++;
+        await this.wait(delay);
+        if (this.stopped) return false;
+        try {
+          const success = await onReconnect();
+          if (success) {
+            this.reset();
+            return true;
+          }
+        } catch {
         }
-      } catch {
       }
+      return false;
+    } finally {
+      this.running = false;
     }
-    return false;
   }
   /**
    * Stop any pending reconnection attempt.
@@ -1688,6 +1737,12 @@ var ReconnectionManager = class {
     const jitterOffset = (this.random() - 0.5) * 2 * jitterRange;
     return Math.max(0, Math.round(baseDelay + jitterOffset));
   }
+  /**
+   * Whether the reconnection loop is currently running.
+   */
+  isRunning() {
+    return this.running;
+  }
   /**
    * Current attempt number (for testing).
    */