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

package/dist/mmorpg-build-plugin.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+interface MmorpgBuildPluginOptions {
+    rpgType: string;
+    serverEntry: string;
+    adapterEntries?: Record<string, string>;
+}
+export declare function mmorpgBuildPlugin({ rpgType, serverEntry, adapterEntries, }: MmorpgBuildPluginOptions): Plugin;
+export {};

package/dist/rpgjs-plugin.d.ts

@@ -1,16 +1,22 @@
+type MmorpgEntryPoints = string | {
+    client?: string;
+    server?: string;
+    adapters?: Record<string, string>;
+};
 interface RpgjsPluginOptions {
     server: any;
     entryPoints?: {
-        rpg: string;
-        mmorpg: string;
+        rpg?: string;
+        mmorpg?: MmorpgEntryPoints;
     };
 }
 export declare function rpgjs({ server, entryPoints }: RpgjsPluginOptions): (import('vite').Plugin<any> | {
     name: string;
+    config(config: any, { command }: any): void;
     transform(code: string, id: string): {
         code: string;
         map: null;
-    } | undefined;
+    } | null;
 } | {
     name: string;
     transform(code: string, id: string): string | undefined;

package/dist/server-plugin.d.ts

@@ -1,155 +1,8 @@
-import { RpgServerEngine } from '@rpgjs/server';
+import { RpgTransportServerConstructor } from '@rpgjs/server/node';
 import { ViteDevServer } from 'vite';
-interface WSConnection {
-    readyState: number;
-    send(data: string): void;
-    close(): void;
-    on(event: string, callback: (...args: any[]) => void): 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' });
- * ```
- */
-declare class PartyConnection {
-    private ws;
-    id: string;
-    uri: string;
-    private _state;
-    constructor(ws: WSConnection, id?: string, uri?: string);
-    /**
-     * Generates a unique identifier for the connection
-     *
-     * @returns {string} Unique identifier based on timestamp and random number
-     */
-    private generateId;
-    /**
-     * Sends data to the client via WebSocket
-     *
-     * @param {any} data - Data to send (automatically serialized to JSON if not string)
-     */
-    send(data: any): void;
-    /**
-     * Closes the WebSocket connection
-     */
-    close(): void;
-    /**
-     * Sets state data for this connection
-     *
-     * @param {any} value - State data to store (max 2KB as per PartyKit spec)
-     */
-    setState(value: any): void;
-    /**
-     * Gets the current state of this connection
-     *
-     * @returns {any} Current connection state
-     */
-    get state(): any;
-}
-/**
- * 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;
- * ```
- */
-declare class Room {
-    id: string;
-    internalID: string;
-    env: Record<string, any>;
-    context: any;
-    private connections;
-    private storageData;
-    constructor(id: string);
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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>;
-    /**
-     * Adds a connection to this room
-     *
-     * @param {PartyConnection} connection - Connection to add
-     */
-    addConnection(connection: PartyConnection): void;
-    /**
-     * Removes a connection from this room
-     *
-     * @param {string} connectionId - ID of connection to remove
-     */
-    removeConnection(connectionId: string): void;
-    /**
-     * Simple key-value storage for the room
-     */
-    get storage(): {
-        put: (key: string, value: any) => Promise<void>;
-        get: <T = any>(key: string) => Promise<T | undefined>;
-        delete: (key: string) => Promise<void>;
-        list: () => Promise<string[]>;
-    };
-}
-/**
- * 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 declare function serverPlugin(serverModule: new (room: Room) => RpgServerEngine): {
+export declare function serverPlugin(serverModule: RpgTransportServerConstructor): {
     name: string;
     configureServer(server: ViteDevServer): Promise<void>;
     buildStart(): void;
     buildEnd(): void;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/vite",
-  "version": "5.0.0-alpha.9",
+  "version": "5.0.0-beta.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [],
@@ -12,20 +12,29 @@
     "access": "public"
   },
   "dependencies": {
-    "@canvasengine/compiler": "2.0.0-beta.21",
-    "@hono/vite-dev-server": "^0.19.1",
-    "@rpgjs/server": "5.0.0-alpha.9",
-    "@types/node": "^20.0.0",
-    "acorn": "^8.14.1",
-    "acorn-walk": "^8.3.4",
-    "magic-string": "^0.30.0",
-    "typescript": "^5.0.0",
-    "vite": "^6.2.5",
-    "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3.1.1",
-    "ws": "^8.18.0"
+    "@babel/generator": "^7.29.1",
+    "@babel/parser": "^7.29.3",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "@canvasengine/compiler": "2.0.0-rc.1",
+    "@canvasengine/tiled": "2.0.0-rc.1",
+    "@hono/vite-dev-server": "^0.25.3",
+    "@iarna/toml": "^2.2.5",
+    "@rpgjs/server": "5.0.0-beta.10",
+    "@types/node": "^25.8.0",
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5",
+    "image-size": "^2.0.2",
+    "magic-string": "^0.30.21",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.13",
+    "vite-plugin-dts": "^5.0.0",
+    "vitest": "^4.1.6",
+    "ws": "^8.20.1"
   },
   "devDependencies": {
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
     "@types/ws": "^8.18.1"
   },
   "scripts": {

package/src/compatibility-v4/flag-transform.ts

@@ -0,0 +1,61 @@
+import type { Plugin } from "vite";
+
+export function flagTransform(options: { side?: "client" | "server"; mode?: string; type?: "rpg" | "mmorpg" } = {}): Plugin {
+  function getImportSide(importer?: string): "client" | "server" {
+    if (importer?.includes("?server") || importer?.includes("server-entry")) return "server";
+    if (importer?.includes("?client") || importer?.includes("client-entry") || importer?.includes("standalone-entry")) return "client";
+    return options.side ?? "client";
+  }
+
+  function hasFlag(id: string, flag: string) {
+    return id.endsWith(`?${flag}`) || id.includes(`?${flag}&`);
+  }
+
+  function getSideFromId(id: string): "client" | "server" {
+    const side = id.match(/[?&]side=(client|server)/)?.[1];
+    return side === "server" ? "server" : "client";
+  }
+
+  return {
+    name: "rpgjs-v4-flag-transform",
+    async resolveId(this: any, source: string, importer?: string, resolveOptions?: any) {
+      const flags = ["client!", "server!", "rpg!", "mmorpg!", "production!", "development!"];
+      for (const flag of flags) {
+        if (!source.startsWith(flag)) continue;
+        const id = source.slice(flag.length);
+        const resolution = await this.resolve(id, importer, {
+          skipSelf: true,
+          ...resolveOptions,
+        });
+        if (!resolution) return null;
+        const importSide = getImportSide(importer);
+        return {
+          ...resolution,
+          id: `${resolution.id}?${flag.slice(0, -1)}&side=${importSide}`,
+        };
+      }
+      return null;
+    },
+    transform(code, id) {
+      const { mode = "development", type = "mmorpg" } = options;
+      const side = getSideFromId(id);
+
+      if (mode === "test") return { code, map: null };
+
+      if (hasFlag(id, side === "client" ? "server" : "client") && type !== "rpg") {
+        return { code: "export default null;", map: null };
+      }
+
+      if (
+        (hasFlag(id, "production") && mode !== "production") ||
+        (hasFlag(id, "development") && mode !== "development") ||
+        (hasFlag(id, "rpg") && type !== "rpg") ||
+        (hasFlag(id, "mmorpg") && type !== "mmorpg")
+      ) {
+        return { code: "export default null;", map: null };
+      }
+
+      return { code, map: null };
+    },
+  };
+}