@rpgjs/vite 5.0.0-alpha.33 → 5.0.0-alpha.35

package/dist/index.js

@@ -8253,10 +8253,8 @@ class PartyConnection {
     this.messageQueue = [];
     this.isProcessingQueue = false;
     this.sequenceCounter = 0;
-    this.lastSendTime = 0;
-    this.outgoingFlushTimeout = null;
     this.incomingQueue = [];
-    this.incomingFlushTimeout = null;
+    this.isProcessingIncomingQueue = false;
     this.id = id || this.generateId();
     this.uri = uri || "";
   }
@@ -8320,22 +8318,12 @@ class PartyConnection {
     }
   }
   /**
-   * Processes the outgoing queue with TCP-like batching.
-   * 
-   * - If latency is enabled, schedule a single flush after latencyMs to batch messages.
-   * - At flush, send all queued messages in order, applying bandwidth delays per message.
+   * Processes the outgoing queue in order.
+   *
+   * Each message receives its own fixed latency (if enabled), while preserving
+   * original spacing and order.
    */
   async processMessageQueue() {
-    if (this.messageQueue.length === 0) return;
-    const shouldBatchWithLatency = PartyConnection.latencyEnabled && PartyConnection.latencyMs > 0;
-    if (shouldBatchWithLatency) {
-      if (this.outgoingFlushTimeout) return;
-      this.outgoingFlushTimeout = setTimeout(async () => {
-        this.outgoingFlushTimeout = null;
-        await this.flushSendQueue();
-      }, PartyConnection.latencyMs);
-      return;
-    }
     await this.flushSendQueue();
   }
   /**
@@ -8346,6 +8334,9 @@ class PartyConnection {
     this.isProcessingQueue = true;
     while (this.messageQueue.length > 0) {
       const queueItem = this.messageQueue.shift();
+      if (this.shouldApplyLatency(queueItem.message)) {
+        await this.waitUntil(queueItem.timestamp + PartyConnection.latencyMs);
+      }
       if (PartyConnection.bandwidthEnabled && PartyConnection.bandwidthKbps > 0) {
         if (!PartyConnection.bandwidthFilter || queueItem.message.includes(PartyConnection.bandwidthFilter)) {
           const messageSizeBits = queueItem.message.length * 8;
@@ -8360,6 +8351,22 @@ class PartyConnection {
     }
     this.isProcessingQueue = false;
   }
+  shouldApplyLatency(message) {
+    if (!PartyConnection.latencyEnabled || PartyConnection.latencyMs <= 0) {
+      return false;
+    }
+    if (!PartyConnection.latencyFilter) {
+      return true;
+    }
+    return message.includes(PartyConnection.latencyFilter);
+  }
+  async waitUntil(targetTimestamp) {
+    const delayMs = targetTimestamp - Date.now();
+    if (delayMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
   /**
    * Closes the WebSocket connection
    */
@@ -8386,9 +8393,9 @@ class PartyConnection {
   }
   /**
    * Buffers incoming messages to simulate TCP latency on reception.
-   * 
-   * All messages that arrive within the latency window are flushed together,
-   * preserving order. The provided processor is called with the ordered batch.
+   *
+   * Messages are processed in strict order. Each message keeps its own fixed
+   * latency delay relative to the moment it arrived.
    *
    * @param {string} message - Raw incoming message
    * @param {(messages: string[]) => Promise<void>} processor - Async batch processor
@@ -8399,19 +8406,32 @@ class PartyConnection {
    * })
    */
   bufferIncoming(message, processor) {
-    this.incomingQueue.push(message);
-    const latencyMs = PartyConnection.latencyEnabled && PartyConnection.latencyMs > 0 ? PartyConnection.latencyMs : 0;
-    if (this.incomingFlushTimeout) return;
-    this.incomingFlushTimeout = setTimeout(async () => {
-      const batch = this.incomingQueue;
-      this.incomingQueue = [];
-      this.incomingFlushTimeout = null;
+    this.incomingQueue.push({
+      message,
+      timestamp: Date.now(),
+      processor
+    });
+    if (!this.isProcessingIncomingQueue) {
+      void this.processIncomingQueue();
+    }
+  }
+  async processIncomingQueue() {
+    if (this.isProcessingIncomingQueue) {
+      return;
+    }
+    this.isProcessingIncomingQueue = true;
+    while (this.incomingQueue.length > 0) {
+      const item = this.incomingQueue.shift();
+      if (this.shouldApplyLatency(item.message)) {
+        await this.waitUntil(item.timestamp + PartyConnection.latencyMs);
+      }
       try {
-        await processor(batch);
+        await item.processor([item.message]);
       } catch (err) {
-        console.error("Error processing incoming batch:", err);
+        console.error("Error processing incoming message:", err);
       }
-    }, latencyMs);
+    }
+    this.isProcessingIncomingQueue = false;
   }
   /**
    * Configures packet loss simulation settings
@@ -8632,12 +8652,15 @@ async function importWebSocketServer() {
   }
 }
 async function updateMap(roomId, rpgServer) {
+  if (!roomId.startsWith("map-")) {
+    return;
+  }
   try {
     const mapId = roomId.startsWith("map-") ? roomId.slice(4) : roomId;
     const defaultMapPayload = {
       id: mapId,
-      width: 1e3,
-      height: 1e3,
+      width: 0,
+      height: 0,
       events: []
     };
     const req = {
@@ -8786,22 +8809,71 @@ function serverPlugin(serverModule) {
       }
       server.middlewares.use("/parties", async (req, res, next) => {
         try {
-          console.log(`RPG-JS HTTP request: ${req.method} ${req.url}`);
-          if (req.url?.includes("/test")) {
+          const host = req.headers.host || "localhost";
+          const incomingUrl = req.url || "/";
+          const parsedUrl = new URL(incomingUrl, `http://${host}`);
+          const normalizedPath = parsedUrl.pathname.startsWith("/parties") ? parsedUrl.pathname : `/parties${parsedUrl.pathname.startsWith("/") ? parsedUrl.pathname : `/${parsedUrl.pathname}`}`;
+          const pathParts = normalizedPath.split("/").filter(Boolean);
+          if (pathParts[0] !== "parties" || pathParts[1] !== "main" || pathParts.length < 4) {
+            next();
+            return;
+          }
+          const roomId = pathParts[2];
+          const requestPath = `/${pathParts.slice(3).join("/")}`;
+          const { room, rpgServer } = await ensureRoomAndServer(roomId);
+          room.context.parties = buildPartiesContext();
+          const bodyText = await new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => {
+              chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+            });
+            req.on("end", () => {
+              resolve(Buffer.concat(chunks).toString("utf8"));
+            });
+            req.on("error", reject);
+          });
+          const requestHeaders = new Headers();
+          Object.entries(req.headers).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+              if (value[0] !== void 0) requestHeaders.set(key, value[0]);
+              return;
+            }
+            if (typeof value === "string") {
+              requestHeaders.set(key, value);
+            }
+          });
+          const requestLike = {
+            url: `http://${host}/parties/main/${roomId}${requestPath}${parsedUrl.search}`,
+            method: (req.method || "GET").toUpperCase(),
+            headers: requestHeaders,
+            json: async () => {
+              if (!bodyText) return void 0;
+              return JSON.parse(bodyText);
+            },
+            text: async () => bodyText
+          };
+          const result = await rpgServer.onRequest(requestLike);
+          if (result instanceof Response) {
+            res.statusCode = result.status;
+            result.headers.forEach((value, key) => {
+              res.setHeader(key, value);
+            });
+            res.end(await result.text());
+            return;
+          }
+          if (typeof result === "string") {
             res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(
-              JSON.stringify({
-                message: "RPG-JS server is running",
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              })
-            );
+            res.setHeader("Content-Type", "text/plain");
+            res.end(result);
             return;
           }
-          next();
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify(result ?? {}));
         } catch (error) {
           console.error("Error handling RPG-JS request:", error);
           res.statusCode = 500;
+          res.setHeader("Content-Type", "application/json");
           res.end(JSON.stringify({ error: "Internal server error" }));
         }
       });