@korajs/sync 0.1.3 → 0.1.5

package/dist/index.d.cts

@@ -121,6 +121,8 @@ interface WebSocketTransportOptions {
     serializer?: MessageSerializer;
     /** Injectable WebSocket constructor for testing. Defaults to globalThis.WebSocket. */
     WebSocketImpl?: WebSocketConstructor;
+    /** Connection timeout in ms. Defaults to 10000 (10s). */
+    connectTimeout?: number;
 }
 /**
  * WebSocket-based sync transport implementation.
@@ -132,6 +134,7 @@ declare class WebSocketTransport implements SyncTransport {
     private errorHandler;
     private readonly serializer;
     private readonly WebSocketImpl;
+    private readonly connectTimeout;
     constructor(options?: WebSocketTransportOptions);
     connect(url: string, options?: TransportOptions): Promise<void>;
     disconnect(): Promise<void>;
@@ -334,6 +337,7 @@ declare class SyncEngine {
     private remoteVector;
     private lastSyncedAt;
     private currentBatch;
+    private reconnecting;
     private deltaBatchesReceived;
     private deltaReceiveComplete;
     private deltaSendComplete;
@@ -352,6 +356,13 @@ declare class SyncEngine {
      * If streaming, flushes immediately.
      */
     pushOperation(op: Operation): Promise<void>;
+    /**
+     * 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: boolean): void;
     /**
      * Get the current developer-facing sync status.
      */
@@ -473,6 +484,7 @@ declare class ReconnectionManager {
     private attempt;
     private timer;
     private stopped;
+    private running;
     private waitResolve;
     constructor(config?: ReconnectionConfig);
     /**
@@ -495,6 +507,10 @@ declare class ReconnectionManager {
      * Exposed for testing purposes.
      */
     getNextDelay(): number;
+    /**
+     * Whether the reconnection loop is currently running.
+     */
+    isRunning(): boolean;
     /**
      * Current attempt number (for testing).
      */

package/dist/index.d.ts

@@ -121,6 +121,8 @@ interface WebSocketTransportOptions {
     serializer?: MessageSerializer;
     /** Injectable WebSocket constructor for testing. Defaults to globalThis.WebSocket. */
     WebSocketImpl?: WebSocketConstructor;
+    /** Connection timeout in ms. Defaults to 10000 (10s). */
+    connectTimeout?: number;
 }
 /**
  * WebSocket-based sync transport implementation.
@@ -132,6 +134,7 @@ declare class WebSocketTransport implements SyncTransport {
     private errorHandler;
     private readonly serializer;
     private readonly WebSocketImpl;
+    private readonly connectTimeout;
     constructor(options?: WebSocketTransportOptions);
     connect(url: string, options?: TransportOptions): Promise<void>;
     disconnect(): Promise<void>;
@@ -334,6 +337,7 @@ declare class SyncEngine {
     private remoteVector;
     private lastSyncedAt;
     private currentBatch;
+    private reconnecting;
     private deltaBatchesReceived;
     private deltaReceiveComplete;
     private deltaSendComplete;
@@ -352,6 +356,13 @@ declare class SyncEngine {
      * If streaming, flushes immediately.
      */
     pushOperation(op: Operation): Promise<void>;
+    /**
+     * 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: boolean): void;
     /**
      * Get the current developer-facing sync status.
      */
@@ -473,6 +484,7 @@ declare class ReconnectionManager {
     private attempt;
     private timer;
     private stopped;
+    private running;
     private waitResolve;
     constructor(config?: ReconnectionConfig);
     /**
@@ -495,6 +507,10 @@ declare class ReconnectionManager {
      * Exposed for testing purposes.
      */
     getNextDelay(): number;
+    /**
+     * Whether the reconnection loop is currently running.
+     */
+    isRunning(): boolean;
     /**
      * Current attempt number (for testing).
      */

package/dist/index.js

@@ -591,8 +591,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") {
@@ -608,12 +610,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 SyncError2("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 {
@@ -637,15 +665,17 @@ var WebSocketTransport = class {
           this.errorHandler?.(err);
           if (!this.isConnected()) {
             this.ws = null;
-            reject(err);
+            settle(() => reject(err));
           }
         };
       } catch (err) {
-        reject(
-          err instanceof SyncError2 ? err : new SyncError2("Failed to create WebSocket", {
-            url,
-            error: String(err)
-          })
+        settle(
+          () => reject(
+            err instanceof SyncError2 ? err : new SyncError2("Failed to create WebSocket", {
+              url,
+              error: String(err)
+            })
+          )
         );
       }
     });
@@ -1143,6 +1173,7 @@ var SyncEngine = class {
   remoteVector = /* @__PURE__ */ new Map();
   lastSyncedAt = null;
   currentBatch = null;
+  reconnecting = false;
   // Track delta exchange state
   deltaBatchesReceived = 0;
   deltaReceiveComplete = false;
@@ -1187,8 +1218,7 @@ var SyncEngine = class {
       };
       this.transport.send(handshake);
     } catch (err) {
-      this.transitionTo("error");
-      this.transitionTo("disconnected");
+      this.ensureDisconnected();
       throw err;
     }
   }
@@ -1222,6 +1252,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.
    */
@@ -1233,7 +1272,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",
@@ -1550,6 +1593,7 @@ var ReconnectionManager = class {
   attempt = 0;
   timer = null;
   stopped = false;
+  running = false;
   waitResolve = null;
   constructor(config) {
     this.initialDelay = config?.initialDelay ?? 1e3;
@@ -1567,25 +1611,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.
@@ -1618,6 +1667,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).
    */