leafrelay 0.2.2 → 0.2.3

package/dist/{chunk-Q3R5N4YE.js → chunk-3RL67IG5.js}

@@ -152,6 +152,7 @@ var OverleafRealtimeSocket = class {
   cookie;
   socket;
   connected = false;
+  projectJoined = false;
   explicitlyDisconnected = false;
   reconnectEnabled;
   reconnectAttempts = 0;
@@ -160,7 +161,6 @@ var OverleafRealtimeSocket = class {
   closeTimeoutMs = 6e4;
   acknowledgementId = 0;
   acknowledgements = /* @__PURE__ */ new Map();
-  sendBuffer = [];
   io = {
     reconnect: (enabled) => {
       this.reconnectEnabled = enabled;
@@ -192,15 +192,24 @@ var OverleafRealtimeSocket = class {
     if (id && callback) {
       this.acknowledgements.set(id, callback);
     }
-    this.send(encodePacket({
+    const packet = encodePacket({
       type: "event",
       id,
       ack: callback ? "data" : void 0,
       name: event,
       args
-    }));
+    });
+    if (!this.sendApplicationEvent(packet) && callback) {
+      if (id) {
+        this.acknowledgements.delete(id);
+      }
+      queueMicrotask(() => callback(new Error("The Overleaf project session is not connected.")));
+    }
     return this;
   }
+  markProjectJoined() {
+    this.projectJoined = true;
+  }
   disconnect() {
     this.explicitlyDisconnected = true;
     this.reconnectEnabled = false;
@@ -215,6 +224,7 @@ var OverleafRealtimeSocket = class {
   }
   async connect() {
     try {
+      this.projectJoined = false;
       const handshakeUrl = new URL("/socket.io/1/", this.endpoint.origin);
       for (const [name, value] of this.endpoint.searchParams) {
         handshakeUrl.searchParams.set(name, value);
@@ -243,7 +253,7 @@ var OverleafRealtimeSocket = class {
       this.socket.addEventListener("open", () => this.events.emit("connecting", "websocket"));
       this.socket.addEventListener("message", (event) => void this.receive(event.data));
       this.socket.addEventListener("error", (error2) => this.events.emit("error", error2));
-      this.socket.addEventListener("close", () => this.handleClose());
+      this.socket.addEventListener("close", (event) => this.handleClose(event));
     } catch (error2) {
       this.events.emit("connect_failed", error2);
       this.events.emit("error", error2);
@@ -263,7 +273,6 @@ var OverleafRealtimeSocket = class {
         const wasReconnecting = this.reconnectAttempts > 0;
         this.connected = true;
         this.events.emit("connect");
-        this.flush();
         if (wasReconnecting) {
           this.events.emit("reconnect", "websocket", this.reconnectAttempts);
           this.reconnectAttempts = 0;
@@ -309,16 +318,16 @@ var OverleafRealtimeSocket = class {
     }
   }
   send(packet) {
-    if (!this.connected || this.socket?.readyState !== WebSocket.OPEN) {
-      this.sendBuffer.push(packet);
-      return;
+    if (this.connected && this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(packet);
     }
-    this.socket.send(packet);
   }
-  flush() {
-    while (this.sendBuffer.length > 0 && this.socket?.readyState === WebSocket.OPEN) {
-      this.socket.send(this.sendBuffer.shift());
+  sendApplicationEvent(packet) {
+    if (!this.connected || !this.projectJoined || this.socket?.readyState !== WebSocket.OPEN) {
+      return false;
     }
+    this.socket.send(packet);
+    return true;
   }
   resetInactivityTimer() {
     if (this.inactivityTimer) {
@@ -326,20 +335,25 @@ var OverleafRealtimeSocket = class {
     }
     this.inactivityTimer = setTimeout(() => this.closeSocket("timeout"), this.closeTimeoutMs);
   }
-  handleClose() {
+  handleClose(event) {
     const wasConnected = this.connected;
     this.connected = false;
+    this.projectJoined = false;
     if (this.inactivityTimer) {
       clearTimeout(this.inactivityTimer);
     }
     if (wasConnected) {
-      this.events.emit("disconnect", "transport close");
+      const detail = event.reason ? `: ${event.reason}` : "";
+      const reason = `transport close (code ${event.code})${detail}`;
+      this.failAcknowledgements(reason);
+      this.events.emit("disconnect", reason);
     }
     this.scheduleReconnect();
   }
   closeSocket(reason) {
     const wasConnected = this.connected;
     this.connected = false;
+    this.projectJoined = false;
     if (this.inactivityTimer) {
       clearTimeout(this.inactivityTimer);
     }
@@ -347,12 +361,20 @@ var OverleafRealtimeSocket = class {
     this.socket = void 0;
     socket?.close();
     if (wasConnected) {
+      this.failAcknowledgements(reason);
       this.events.emit("disconnect", reason);
     }
     if (!this.explicitlyDisconnected) {
       this.scheduleReconnect();
     }
   }
+  failAcknowledgements(reason) {
+    const error2 = new Error(`Overleaf realtime connection closed: ${reason}`);
+    for (const callback of this.acknowledgements.values()) {
+      callback(error2);
+    }
+    this.acknowledgements.clear();
+  }
   scheduleReconnect() {
     if (!this.reconnectEnabled || this.explicitlyDisconnected || this.reconnectTimer) {
       return;
@@ -1188,6 +1210,8 @@ var SocketIOAPI = class _SocketIOAPI {
   static alternativeSocketFactory;
   scheme;
   record;
+  joinedProject;
+  pendingProjectJoin;
   _handlers = [];
   connectedPublicId;
   socket;
@@ -1224,6 +1248,8 @@ var SocketIOAPI = class _SocketIOAPI {
         break;
       case "realtime":
         this.record = void 0;
+        this.joinedProject = void 0;
+        this.resetProjectJoin(new Error("The realtime connection was replaced."));
         const query = `?projectId=${this.projectId}&t=${Date.now()}`;
         this.socket = this.api._initSocketV0(this.identity, query);
         break;
@@ -1266,6 +1292,11 @@ var SocketIOAPI = class _SocketIOAPI {
     });
     this.socket.on("disconnect", (reason) => {
       log("SocketIOAPI: disconnect event", { scheme: this.scheme, projectId: this.projectId, reason });
+      if (this.scheme === "realtime") {
+        this.joinedProject = void 0;
+        this.connectedPublicId = void 0;
+        this.resetProjectJoin(new Error(`Overleaf realtime connection closed: ${String(reason ?? "unknown")}`));
+      }
     });
     this.socket.on("reconnecting", (delay, attempt) => {
       log("SocketIOAPI: reconnecting", { scheme: this.scheme, projectId: this.projectId, delay, attempt });
@@ -1290,22 +1321,50 @@ var SocketIOAPI = class _SocketIOAPI {
       error(`Overleaf connection error: ${message}`);
     });
     if (this.scheme === "realtime") {
-      this.record = new Promise((resolve6, reject) => {
-        this.socket.on("joinProjectResponse", (res) => {
-          const publicId = res.publicId;
-          const project = res.project;
-          this.connectedPublicId = publicId;
-          for (const handler of this._handlers) {
-            handler.onConnectionAccepted?.(publicId);
-          }
-          resolve6(project);
-        });
-        this.socket.on("connectionRejected", (err) => {
-          reject(err?.message || err);
-        });
+      this.pendingProjectJoin ??= this.createProjectJoin();
+      this.socket.on("joinProjectResponse", (res) => {
+        const publicId = res.publicId;
+        const project = res.project;
+        this.socket.markProjectJoined?.();
+        log("SocketIOAPI: project joined", { scheme: this.scheme, projectId: this.projectId, publicId });
+        this.connectedPublicId = publicId;
+        this.joinedProject = project;
+        this.pendingProjectJoin?.resolve(project);
+        for (const handler of this._handlers) {
+          handler.onProjectJoined?.(project);
+          handler.onConnectionAccepted?.(publicId);
+        }
+      });
+      this.socket.on("connectionRejected", (err) => {
+        this.pendingProjectJoin?.reject(err?.message || err);
       });
     }
   }
+  createProjectJoin() {
+    let resolve6;
+    let reject;
+    const promise = new Promise((resolveProject, rejectProject) => {
+      resolve6 = resolveProject;
+      reject = rejectProject;
+    });
+    void promise.catch(() => void 0);
+    return { promise, resolve: resolve6, reject };
+  }
+  resetProjectJoin(reason) {
+    if (reason !== void 0) {
+      this.pendingProjectJoin?.reject(reason);
+    }
+    this.pendingProjectJoin = this.createProjectJoin();
+  }
+  waitForRealtimeProject() {
+    return this.joinedProject ? Promise.resolve(this.joinedProject) : this.pendingProjectJoin.promise;
+  }
+  async emitProjectEvent(event, ...args) {
+    if (this.scheme === "realtime") {
+      await this.waitForRealtimeProject();
+    }
+    return this.emit(event, ...args);
+  }
   disconnect() {
     this.socket.disconnect();
   }
@@ -1364,10 +1423,12 @@ var SocketIOAPI = class _SocketIOAPI {
           });
           break;
         case handlers.onDisconnected:
-          this.socket.on("disconnect", () => {
-            handler();
+          this.socket.on("disconnect", (reason) => {
+            handler(reason);
           });
           break;
+        case handlers.onProjectJoined:
+          break;
         case handlers.onConnectionAccepted:
           this.socket.on("connectionAccepted", (_, publicId) => {
             handler(publicId);
@@ -1437,7 +1498,7 @@ var SocketIOAPI = class _SocketIOAPI {
           timeoutPromise
         ]);
       case "realtime":
-        return Promise.race([this.record, timeoutPromise]);
+        return Promise.race([this.waitForRealtimeProject(), timeoutPromise]);
     }
   }
   /**
@@ -1446,7 +1507,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async joinDoc(docId) {
-    return this.emit("joinDoc", docId, { encodeRanges: true }).then((returns) => {
+    return this.emitProjectEvent("joinDoc", docId, { encodeRanges: true }).then((returns) => {
       const [docLinesAscii, version, updates, ranges] = returns;
       const docLines = docLinesAscii.map((line) => decodePackedUtf8(line));
       return { docLines, version, updates, ranges };
@@ -1458,7 +1519,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async leaveDoc(docId) {
-    return this.emit("leaveDoc", docId).then(() => {
+    return this.emitProjectEvent("leaveDoc", docId).then(() => {
       return;
     });
   }
@@ -1470,7 +1531,7 @@ var SocketIOAPI = class _SocketIOAPI {
    */
   async applyOtUpdate(docId, update) {
     try {
-      await this.emit("applyOtUpdate", docId, update);
+      await this.emitProjectEvent("applyOtUpdate", docId, update);
     } catch (error2) {
       let detail;
       if (error2 instanceof Error) {
@@ -1492,7 +1553,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async getConnectedUsers() {
-    return this.emit("clientTracking.getConnectedUsers").then((returns) => {
+    return this.emitProjectEvent("clientTracking.getConnectedUsers").then((returns) => {
       const [connectedUsers] = returns;
       return connectedUsers;
     });
@@ -1503,7 +1564,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async updatePosition(doc_id, row, column) {
-    return this.emit("clientTracking.updatePosition", { row, column, doc_id }).then(() => {
+    return this.emitProjectEvent("clientTracking.updatePosition", { row, column, doc_id }).then(() => {
       return;
     });
   }
@@ -1768,6 +1829,7 @@ var RemoteProject = class {
   entries = /* @__PURE__ */ new Map();
   idToPath = /* @__PURE__ */ new Map();
   changeHandler;
+  reconnectHandler;
   externalTransport;
   async connect() {
     if (this.externalTransport) {
@@ -1793,6 +1855,9 @@ var RemoteProject = class {
   onChange(handler) {
     this.changeHandler = handler;
   }
+  onReconnect(handler) {
+    this.reconnectHandler = handler;
+  }
   listEntries() {
     return [...this.entries.values()];
   }
@@ -2011,6 +2076,11 @@ var RemoteProject = class {
   }
   registerEvents() {
     this.socket.updateEventHandlers({
+      onProjectJoined: (project) => {
+        this.project = project;
+        this.reindex();
+        this.reconnectHandler?.();
+      },
       onFileCreated: (parentId, type, entity) => {
         const parent = this.folderById(parentId);
         if (!parent || type === "outputs") {
@@ -2211,6 +2281,11 @@ var SyncEngine = class {
       }
       this.schedule(change.path, "remote");
     });
+    this.options.remote.onReconnect?.(() => {
+      this.queue = this.queue.then(() => this.reconcileAfterReconnect()).catch((error2) => {
+        this.options.log(`Failed to reconcile after reconnecting: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      });
+    });
     this.options.log(`Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
   }
   async stop() {
@@ -2324,6 +2399,15 @@ var SyncEngine = class {
       this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
     }
   }
+  async reconcileAfterReconnect() {
+    const currentVersion = await this.options.remote.getCurrentVersion();
+    await this.startupReconcile(
+      currentVersion,
+      await this.options.local.listFiles(),
+      this.remoteFilePaths()
+    );
+    this.options.log(`Realtime connection restored at Overleaf version ${currentVersion}.`);
+  }
   schedule(path, source) {
     const normalized = normalizePath2(path);
     if (this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
@@ -2534,4 +2618,4 @@ export {
   RemoteProject,
   startServe
 };
-//# sourceMappingURL=chunk-Q3R5N4YE.js.map
+//# sourceMappingURL=chunk-3RL67IG5.js.map