@rpgjs/vite 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/server-plugin.ts

@@ -1,221 +1,14 @@
-import { RpgServerEngine } from "@rpgjs/server";
+import { createRpgServerTransport, logNetworkSimulationStatus } from "@rpgjs/server/node";
+import type { RpgTransportServerConstructor, RpgWebSocketServer } from "@rpgjs/server/node";
 import type { ViteDevServer } from "vite";
-import { IncomingMessage } from "http";
-import { Duplex } from "stream";
 
-// Types for WebSocket without importing ws directly
-interface WSConnection {
-  readyState: number;
-  send(data: string): void;
-  close(): void;
-  on(event: string, callback: (...args: any[]) => void): void;
-}
-
-interface WSServer {
-  handleUpgrade(
-    request: IncomingMessage,
-    socket: Duplex,
-    head: Buffer,
-    callback: (ws: WSConnection) => void
-  ): void;
-  close(): void;
-}
-
-/**
- * PartyConnection class compatible with PartyKit's Party.Connection interface
- *
- * This class implements the Connection interface expected by RPG-JS server,
- * providing WebSocket communication capabilities and connection state management.
- *
- * @example
- * ```typescript
- * const connection = new PartyConnection(websocket, 'player123');
- * connection.send('Hello player!');
- * connection.setState({ username: 'Alice' });
- * ```
- */
-class PartyConnection {
-  public id: string;
-  public uri: string;
-  private _state: any = {};
-
-  constructor(private ws: WSConnection, id?: string, uri?: string) {
-    this.id = id || this.generateId();
-    this.uri = uri || "";
-  }
-
-  /**
-   * Generates a unique identifier for the connection
-   *
-   * @returns {string} Unique identifier based on timestamp and random number
-   */
-  private generateId(): string {
-    return `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Sends data to the client via WebSocket
-   *
-   * @param {any} data - Data to send (automatically serialized to JSON if not string)
-   */
-  send(data: any): void {
-    if (this.ws.readyState === 1) {
-      // WebSocket.OPEN
-      const message = typeof data === "string" ? data : JSON.stringify(data);
-      this.ws.send(message);
-    }
-  }
-
-  /**
-   * Closes the WebSocket connection
-   */
-  close(): void {
-    if (this.ws.readyState === 1) {
-      // WebSocket.OPEN
-      this.ws.close();
-    }
-  }
-
-  /**
-   * Sets state data for this connection
-   *
-   * @param {any} value - State data to store (max 2KB as per PartyKit spec)
-   */
-  setState(value: any): void {
-    this._state = value;
-  }
-
-  /**
-   * Gets the current state of this connection
-   *
-   * @returns {any} Current connection state
-   */
-  get state(): any {
-    return this._state;
-  }
-}
-
-/**
- * Room class compatible with PartyKit's Party.Room interface
- *
- * This class manages multiple WebSocket connections and provides broadcasting
- * capabilities, storage, and connection management as expected by RPG-JS server.
- *
- * @example
- * ```typescript
- * const room = new Room('lobby-1');
- * room.broadcast('Game started!');
- * const playerCount = [...room.getConnections()].length;
- * ```
- */
-class Room {
-  public id: string;
-  public internalID: string;
-  public env: Record<string, any> = {};
-  public context: any = {};
-  private connections: Map<string, PartyConnection> = new Map();
-  private storageData: Map<string, any> = new Map();
-
-  constructor(id: string) {
-    this.id = id;
-    this.internalID = `internal_${id}_${Date.now()}`;
-  }
-
-  /**
-   * Broadcasts a message to all connected clients
-   *
-   * @param {any} message - Message to broadcast
-   * @param {string[]} except - Array of connection IDs to exclude from broadcast
-   */
-  broadcast(message: any, except: string[] = []): void {
-    const data =
-      typeof message === "string" ? message : JSON.stringify(message);
-
-    for (const [connectionId, connection] of this.connections) {
-      if (!except.includes(connectionId)) {
-        connection.send(data);
-      }
-    }
-  }
-
-  /**
-   * Gets a connection by its ID
-   *
-   * @param {string} id - Connection ID
-   * @returns {PartyConnection | undefined} The connection or undefined if not found
-   */
-  getConnection(id: string): PartyConnection | undefined {
-    return this.connections.get(id);
-  }
-
-  /**
-   * Gets all currently connected clients
-   *
-   * @param {string} tag - Optional tag to filter connections (not implemented yet)
-   * @returns {IterableIterator<PartyConnection>} Iterator of all connections
-   */
-  getConnections(tag?: string): IterableIterator<PartyConnection> {
-    // TODO: Implement tag filtering if needed
-    return this.connections.values();
-  }
-
-  /**
-   * Adds a connection to this room
-   *
-   * @param {PartyConnection} connection - Connection to add
-   */
-  addConnection(connection: PartyConnection): void {
-    this.connections.set(connection.id, connection);
-  }
-
-  /**
-   * Removes a connection from this room
-   *
-   * @param {string} connectionId - ID of connection to remove
-   */
-  removeConnection(connectionId: string): void {
-    this.connections.delete(connectionId);
-  }
-
-  /**
-   * Simple key-value storage for the room
-   */
-  get storage() {
-    return {
-      put: async (key: string, value: any) => {
-        this.storageData.set(key, value);
-      },
-      get: async <T = any>(key: string): Promise<T | undefined> => {
-        return this.storageData.get(key) as T;
-      },
-      delete: async (key: string) => {
-        this.storageData.delete(key);
-      },
-      list: async () => {
-        return Array.from(this.storageData.keys());
-      },
-    };
-  }
-}
-
-/**
- * Utility function to safely import WebSocketServer
- *
- * This function checks if we are in a Node.js environment
- * before trying to import the ws module, thus avoiding
- * browser compatibility errors.
- *
- * @returns {Promise<any>} The WebSocketServer class or null if not available
- */
 async function importWebSocketServer(): Promise<any> {
-  // Check if we are in a Node.js environment
   if (typeof process === "undefined" || !process.versions?.node) {
     console.warn("Not in Node.js environment, WebSocket server not available");
     return null;
   }
 
   try {
-    // Use createRequire to import ws in an ES module context
     const { createRequire } = await import("module");
     const require = createRequire(import.meta.url);
     const ws = require("ws");
@@ -226,46 +19,14 @@ async function importWebSocketServer(): Promise<any> {
   }
 }
 
-/**
- * Creates a Vite plugin for integrating RPG-JS server functionality
- *
- * This plugin configures the development server to automatically start
- * an RPG-JS server instance when Vite's dev server starts. It handles
- * the instantiation and initialization of the server module, and sets up
- * HTTP request and WebSocket connection forwarding to the RPG-JS server.
- *
- * The plugin intercepts:
- * - HTTP requests to `/parties/*` paths and forwards them to the RPG-JS server
- * - WebSocket upgrade requests and establishes connections with the RPG-JS server
- *
- * @param {new () => RpgServerEngine} serverModule - A class constructor that extends RpgServerEngine
- * @returns {Object} Vite plugin configuration object
- *
- * @example
- * ```typescript
- * // In vite.config.ts
- * import { serverPlugin } from '@rpgjs/vite';
- * import startServer from './src/server';
- *
- * export default defineConfig({
- *   plugins: [
- *     serverPlugin(startServer)
- *   ]
- * });
- * ```
- */
-export function serverPlugin(
-  serverModule: new (room: Room) => RpgServerEngine
-) {
-  let wsServer: WSServer | null = null;
-  let rooms: Map<string, Room> = new Map();
-  let servers: Map<string, RpgServerEngine> = new Map();
+export function serverPlugin(serverModule: RpgTransportServerConstructor) {
+  let wsServer: RpgWebSocketServer | null = null;
+  const transport = createRpgServerTransport(serverModule);
 
   return {
     name: "server-plugin",
 
     async configureServer(server: ViteDevServer) {
-      // Dynamic import of WebSocketServer to avoid compatibility issues
       try {
         const WebSocketServerClass = await importWebSocketServer();
         if (WebSocketServerClass) {
@@ -281,203 +42,22 @@ export function serverPlugin(
         wsServer = null;
       }
 
-      console.log('RPG-JS server plugin initialized');
+      console.log("RPG-JS server plugin initialized");
+      logNetworkSimulationStatus();
 
-      // HTTP request interception for /parties/* routes
       server.middlewares.use("/parties", async (req, res, next) => {
-        try {
-          // For now, pass to the next middleware
-          // The RPG-JS server handles its own routes via @signe/room
-          console.log(`RPG-JS HTTP request: ${req.method} ${req.url}`);
-
-          // Create a basic response for test routes
-          if (req.url?.includes("/test")) {
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(
-              JSON.stringify({
-                message: "RPG-JS server is running",
-                timestamp: new Date().toISOString(),
-              })
-            );
-            return;
-          }
-
-          next();
-        } catch (error) {
-          console.error("Error handling RPG-JS request:", error);
-          res.statusCode = 500;
-          res.end(JSON.stringify({ error: "Internal server error" }));
-        }
+        await transport.handleNodeRequest(req, res, next, {
+          mountedPath: "/parties",
+        });
       });
-      // WebSocket upgrade handling (if available)
-      if (wsServer) {
-        server.httpServer?.on(
-          "upgrade",
-          (request: IncomingMessage, socket: Duplex, head: Buffer) => {
-            const url = new URL(request.url!, `http://${request.headers.host}`);
-
-            // Check if it's a WebSocket connection for RPG-JS
-            if (url.pathname.startsWith("/parties/")) {
-              console.log(`WebSocket upgrade request: ${url.pathname}`);
 
-              wsServer!.handleUpgrade(
-                request,
-                socket,
-                head,
-                async (ws: WSConnection) => {
-                  try {
-                    // Extract room name from URL: /parties/main/lobby-1 -> lobby-1
-                    const pathParts = url.pathname.split("/");
-                    const roomName = pathParts[pathParts.length - 1]; // Get the last part (lobby-1)
-
-                    // Extract query parameters (like _pk)
-                    const queryParams = Object.fromEntries(
-                      url.searchParams.entries()
-                    );
-                    console.log(
-                      `Room: ${roomName}, Query params:`,
-                      queryParams
-                    );
-
-                    // Get or create the room
-                    let room = rooms.get(roomName);
-                    if (!room) {
-                      room = new Room(roomName);
-                      rooms.set(roomName, room);
-                      console.log(`Created new room: ${roomName}`);
-                    }
-
-                    // Get or create the server for this room
-                    let rpgServer = servers.get(roomName);
-                    if (!rpgServer) {
-                      rpgServer = new serverModule(room);
-                      servers.set(roomName, rpgServer);
-                      console.log(`Created new server instance for room: ${roomName}`);
-                      
-                      // Call onStart on the new server instance
-                      if (typeof rpgServer.onStart === "function") {
-                        try {
-                          await rpgServer.onStart();
-                          console.log(`Server started for room: ${roomName}`);
-                        } catch (error) {
-                          console.error(`Error starting server for room ${roomName}:`, error);
-                        }
-                      }
-                    }
-
-                    // Create a connection instance
-                    const connection = new PartyConnection(
-                      ws,
-                      undefined,
-                      request.url
-                    );
-
-                    // Add connection to the room
-                    room.addConnection(connection);
-
-                    console.log(
-                      `WebSocket connection established: ${connection.id} in room: ${roomName}`
-                    );
-
-                    // Set up WebSocket event handlers
-                    ws.on("message", async (data: Buffer) => {
-                      try {
-                        const message = data.toString();
-                        // Call onMessage on the RPG-JS server
-                        if (typeof rpgServer.onMessage === "function") {
-                          await rpgServer.onMessage(message, connection as any);
-                        }
-                      } catch (error) {
-                        console.error(
-                          "Error processing WebSocket message:",
-                          error
-                        );
-                      }
-                    });
-
-                    ws.on("close", async () => {
-                      console.log(
-                        `WebSocket connection closed: ${connection.id} from room: ${roomName}`
-                      );
-                      // Remove connection from room
-                      room.removeConnection(connection.id);
-                      // Call onClose on the RPG-JS server
-                      if (typeof rpgServer.onClose === "function") {
-                        await rpgServer.onClose(connection as any);
-                      }
-                    });
-
-                    ws.on("error", async (error: Error) => {
-                      console.error("WebSocket error:", error);
-                      // Remove connection from room
-                      room.removeConnection(connection.id);
-                      // Call onClose on the RPG-JS server
-                      if (typeof rpgServer.onClose === "function") {
-                        await rpgServer.onClose(connection as any);
-                      }
-                    });
-
-                    // Call onConnect on the RPG-JS server if the method exists
-                    if (typeof rpgServer.onConnect === "function") {
-                      // Create a compatible connection context with Headers-like interface
-                      const headers = new Map();
-                      if (request.headers) {
-                        Object.entries(request.headers).forEach(
-                          ([key, value]) => {
-                            headers.set(
-                              key.toLowerCase(),
-                              Array.isArray(value) ? value[0] : value
-                            );
-                          }
-                        );
-                      }
-
-                      const connectionContext = {
-                        request: {
-                          headers: {
-                            has: (name: string) =>
-                              headers.has(name.toLowerCase()),
-                            get: (name: string) =>
-                              headers.get(name.toLowerCase()),
-                            entries: () => headers.entries(),
-                            keys: () => headers.keys(),
-                            values: () => headers.values(),
-                          },
-                          url: request.url,
-                          method: request.method,
-                        },
-                        url: url,
-                      };
-                      await rpgServer.onConnect(
-                        connection as any,
-                        connectionContext as any
-                      );
-                    }
-
-                    // Send connection confirmation
-                    connection.send({
-                      type: "connected",
-                      id: connection.id,
-                      message: "Connected to RPG-JS server",
-                    });
-                  } catch (error) {
-                    console.error(
-                      "Error establishing WebSocket connection:",
-                      error
-                    );
-                    ws.close();
-                  }
-                }
-              );
-            }
-          }
-        );
+      if (wsServer) {
+        server.httpServer?.on("upgrade", (request, socket, head) => {
+          void transport.handleUpgrade(wsServer!, request, socket, head);
+        });
       }
 
-      console.log(
-        "RPG-JS server plugin configured with HTTP and WebSocket forwarding"
-      );
+      console.log("RPG-JS server plugin configured with HTTP and WebSocket forwarding !");
     },
 
     buildStart() {
@@ -485,7 +65,6 @@ export function serverPlugin(
     },
 
     buildEnd() {
-      // Cleanup when server stops
       if (wsServer) {
         wsServer.close();
       }

package/tests/compatibility-v4.spec.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import path from "path";
+import { flagTransform } from "../src/compatibility-v4/flag-transform";
+import { createClientConfigLoad, createModulesLoad, createTiledMapEntries, createWorldMapEntries, loadClientFiles, loadServerFiles, loadSpriteSheet } from "../src/compatibility-v4";
+import { loadConfigFileSync } from "../src/compatibility-v4/load-config-file";
+
+const fixtureRoot = path.resolve(__dirname, "fixtures/v4-game");
+
+describe("compatibilityV4Plugin", () => {
+  it("loads and normalizes a v4 rpg.toml", () => {
+    const config = loadConfigFileSync("development", fixtureRoot);
+
+    expect(config.modules).toEqual(["./src/modules/main"]);
+    expect(config.startMap).toBe("map");
+    expect(config.compilerOptions?.build?.outputDir).toBe("dist");
+  });
+
+  it("generates a v5 server from a v4 module layout", () => {
+    const config = loadConfigFileSync("development", fixtureRoot);
+    const code = loadServerFiles("./src/modules/main", { modulesCreated: [], type: "rpg", serveMode: true, config, tiledMapBasePath: "map" }, config, fixtureRoot);
+
+    expect(code).toContain("createServer");
+    expect(code).toContain("provideServerModules");
+    expect(code).toContain("provideTiledMap()");
+    expect(code).toContain("player.setGraphic('hero')");
+    expect(code).toContain("player.setHitbox(32, 32)");
+    expect(code).toContain("await player.changeMap('map')");
+    expect(code).toContain("events:");
+    expect(code).toContain("database:");
+    expect(code).toContain("worldMaps:");
+  });
+
+  it("generates a v5 client from a v4 module layout", () => {
+    const config = loadConfigFileSync("development", fixtureRoot);
+    const code = loadClientFiles("./src/modules/main", { type: "rpg", serveMode: true, config }, config, fixtureRoot);
+
+    expect(code).toContain("spritesheets:");
+    expect(code).toContain("sprite,");
+    expect(code).toContain("engine,");
+    expect(code).toContain("sceneMap:");
+    expect(code).toContain("gui:");
+    expect(code).toContain("sounds:");
+    expect(code).toContain("prototype.width = 32");
+    expect(code).toContain("prototype.height = 32");
+  });
+
+  it("registers v4 spritesheet images by file basename", () => {
+    const config = loadConfigFileSync("development", fixtureRoot);
+    const spritesheet = loadSpriteSheet("characters", "./src/modules/main", { type: "rpg", serveMode: true, config }, fixtureRoot);
+
+    expect(spritesheet.variablesString).toContain("...");
+    expect(spritesheet.propImagesString).toContain("hero.svg?url");
+    expect(spritesheet.propImagesString).toContain('"hero":');
+    expect(spritesheet.propImagesString).toContain("id,");
+    expect(spritesheet.propImagesString).toContain("image,");
+  });
+
+  it("generates a client config with Tiled as the default map loader", () => {
+    const config = loadConfigFileSync("development", fixtureRoot);
+    const code = createClientConfigLoad(config);
+
+    expect(code).toContain("from '@rpgjs/tiledmap/client'");
+    expect(code).toContain("provideTiledMap({ basePath: 'map' })");
+    expect(code).toContain("provideClientModules(modules)");
+  });
+
+  it("autoloads Tiled maps from v4 map roots with public paths", () => {
+    const config = loadConfigFileSync("development", fixtureRoot);
+    const code = createTiledMapEntries("./src/modules/main", { type: "rpg", serveMode: true, config, tiledMapBasePath: "map" }, fixtureRoot);
+
+    expect(code).toContain("{ id: 'world-map', file: '/map/world-map.tmx' }");
+    expect(code).not.toContain("{ id: 'map'");
+  });
+
+  it("normalizes Tiled world files for the v5 world map manager", () => {
+    const code = createWorldMapEntries("./src/modules/main", fixtureRoot);
+
+    expect(code).toContain('"id":"world"');
+    expect(code).toContain('"id":"world-map"');
+    expect(code).toContain('"worldX":64');
+    expect(code).toContain('"worldY":-160');
+  });
+
+  it("maps RPGJS v4 starter legacy modules to virtual v5 modules", () => {
+    const code = createModulesLoad(["./main", "@rpgjs/mobile-gui", "@rpgjs/default-gui", "@rpgjs/gamepad"]);
+
+    expect(code).toContain("virtual:rpgjs-v4-legacy-mobile-gui");
+    expect(code).toContain("virtual:rpgjs-v4-legacy-default-gui");
+    expect(code).toContain("virtual:rpgjs-v4-legacy-gamepad");
+  });
+
+  it("removes flagged imports for the opposite side", async () => {
+    const plugin = flagTransform({ side: "client", type: "mmorpg", mode: "development" });
+    const result = await plugin.transform?.call({} as any, "export default 1", "/tmp/mod.ts?server");
+
+    expect(result).toEqual({ code: "export default null;", map: null });
+  });
+
+  it("keeps server flagged imports when the import chain is server-side", async () => {
+    const plugin = flagTransform({ side: "client", type: "mmorpg", mode: "development" });
+    const result = await plugin.transform?.call({} as any, "export default 1", "/tmp/mod.ts?server&side=server");
+
+    expect(result).toEqual({ code: "export default 1", map: null });
+  });
+});

package/tests/fixtures/v4-game/rpg.toml

@@ -0,0 +1,11 @@
+modulesRoot = './src/modules'
+modules = ['./main']
+
+[start]
+map = 'map'
+graphic = 'hero'
+hitbox = [32, 32]
+
+[compilerOptions.build]
+pwaEnabled = false
+

package/tests/fixtures/v4-game/src/modules/main/characters/assets/hero.svg

@@ -0,0 +1,2 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32"><rect width="32" height="32"/></svg>
+

package/tests/fixtures/v4-game/src/modules/main/characters/hero.ts

@@ -0,0 +1,2 @@
+export default class HeroSpritesheet {}
+

package/tests/fixtures/v4-game/src/modules/main/client.ts

@@ -0,0 +1,4 @@
+export default {
+  onStart() {}
+}
+

package/tests/fixtures/v4-game/src/modules/main/database/potion.ts

@@ -0,0 +1,6 @@
+export default {
+  Potion: {
+    name: 'Potion'
+  }
+}
+

package/tests/fixtures/v4-game/src/modules/main/events/npc.ts

@@ -0,0 +1,4 @@
+export default {
+  name: 'EV-1'
+}
+

package/tests/fixtures/v4-game/src/modules/main/gui/menu.vue

@@ -0,0 +1,2 @@
+<template><div>Menu</div></template>
+

package/tests/fixtures/v4-game/src/modules/main/maps/map.tmx

@@ -0,0 +1,2 @@
+<map version="1.10" tiledversion="1.10.2" orientation="orthogonal" renderorder="right-down" width="1" height="1" tilewidth="32" tileheight="32" infinite="0"></map>
+

package/tests/fixtures/v4-game/src/modules/main/maps/map.ts

@@ -0,0 +1,7 @@
+export default {
+  id: 'script-map',
+  width: 320,
+  height: 320,
+  events: []
+}
+

package/tests/fixtures/v4-game/src/modules/main/player.ts

@@ -0,0 +1,4 @@
+export default {
+  onConnected() {}
+}
+

package/tests/fixtures/v4-game/src/modules/main/scene-map.ts

@@ -0,0 +1,4 @@
+export default {
+  onAfterLoading() {}
+}
+

package/tests/fixtures/v4-game/src/modules/main/server.ts

@@ -0,0 +1,4 @@
+export default {
+  onStart() {}
+}
+

package/tests/fixtures/v4-game/src/modules/main/sounds/theme.ogg

@@ -0,0 +1,2 @@
+fixture
+

package/tests/fixtures/v4-game/src/modules/main/sounds/theme.ts

@@ -0,0 +1,5 @@
+export default {
+  id: 'theme',
+  src: 'theme.ogg'
+}
+