@rpgjs/vite 5.0.0-alpha.8 → 5.0.0-beta.1

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,8 +1,13 @@
+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> | {
@@ -10,7 +15,7 @@ export declare function rpgjs({ server, entryPoints }: RpgjsPluginOptions): (imp
     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.8",
+  "version": "5.0.0-beta.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [],
@@ -12,18 +12,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@canvasengine/compiler": "2.0.0-beta.21",
-    "@hono/vite-dev-server": "^0.19.1",
-    "@rpgjs/server": "5.0.0-alpha.8",
-    "@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"
+    "@canvasengine/tiled": "2.0.0-beta.54",
+    "@canvasengine/compiler": "2.0.0-beta.54",
+    "@hono/vite-dev-server": "^0.25.0",
+    "@rpgjs/server": "5.0.0-beta.1",
+    "@types/node": "^25.3.5",
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5",
+    "magic-string": "^0.30.21",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"

package/src/mmorpg-build-plugin.ts

@@ -0,0 +1,123 @@
+import { existsSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { build as viteBuild, type Plugin, type ResolvedConfig } from "vite";
+
+interface MmorpgBuildPluginOptions {
+  rpgType: string;
+  serverEntry: string;
+  adapterEntries?: Record<string, string>;
+}
+
+function isBareImport(id: string): boolean {
+  return !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0");
+}
+
+function resolveEntry(root: string, entry: string): string {
+  return resolve(root, entry);
+}
+
+function collectServerEntries(
+  root: string,
+  serverEntry: string,
+  adapterEntries: Record<string, string>,
+): Record<string, string> {
+  const entries: Record<string, string> = {};
+  const resolvedServerEntry = resolveEntry(root, serverEntry);
+
+  if (!existsSync(resolvedServerEntry)) {
+    throw new Error(`[rpgjs:mmorpg-build] Missing server entry: ${serverEntry}`);
+  }
+
+  entries.server = resolvedServerEntry;
+
+  for (const [name, entry] of Object.entries(adapterEntries)) {
+    const resolvedAdapterEntry = resolveEntry(root, entry);
+    if (!existsSync(resolvedAdapterEntry)) {
+      throw new Error(`[rpgjs:mmorpg-build] Missing adapter entry "${name}": ${entry}`);
+    }
+    entries[name] = resolvedAdapterEntry;
+  }
+
+  return entries;
+}
+
+export function mmorpgBuildPlugin({
+  rpgType,
+  serverEntry,
+  adapterEntries = {},
+}: MmorpgBuildPluginOptions): Plugin {
+  let config: ResolvedConfig;
+  let didBuildServer = false;
+  let didCleanDist = false;
+
+  return {
+    name: "rpgjs:mmorpg-build",
+    apply: "build",
+    enforce: "post",
+    config(_, env) {
+      if (env.command !== "build" || rpgType !== "mmorpg") {
+        return;
+      }
+
+      return {
+        build: {
+          outDir: "dist/client",
+        },
+      };
+    },
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    buildStart() {
+      if (rpgType !== "mmorpg" || didCleanDist) {
+        return;
+      }
+      didCleanDist = true;
+      rmSync(resolve(config.root, "dist"), { recursive: true, force: true });
+    },
+    async closeBundle() {
+      if (rpgType !== "mmorpg" || didBuildServer) {
+        return;
+      }
+      didBuildServer = true;
+
+      const entries = collectServerEntries(config.root, serverEntry, adapterEntries);
+      console.log(
+        `[rpgjs:mmorpg-build] Building server bundle(s): ${Object.keys(entries).join(", ")}`,
+      );
+
+      await viteBuild({
+        configFile: false,
+        root: config.root,
+        define: config.define,
+        resolve: {
+          alias: config.resolve.alias,
+          dedupe: config.resolve.dedupe,
+          extensions: config.resolve.extensions,
+          mainFields: config.resolve.mainFields,
+          conditions: config.resolve.conditions,
+        },
+        publicDir: false,
+        build: {
+          emptyOutDir: true,
+          minify: false,
+          outDir: "dist/server",
+          sourcemap: config.build.sourcemap,
+          target: "node18",
+          lib: {
+            entry: entries,
+            formats: ["es"],
+          },
+          rollupOptions: {
+            external(id) {
+              return isBareImport(id);
+            },
+            output: {
+              entryFileNames: "[name].js",
+            },
+          },
+        },
+      });
+    },
+  };
+}

package/src/module-config.ts

@@ -1,6 +1,8 @@
 import { defineConfig, build } from "vite";
 import canvasengine from "@canvasengine/compiler";
 import dts from "vite-plugin-dts";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
 import { directivePlugin, removeImportsPlugin } from "./index";
 
 /**
@@ -22,6 +24,14 @@ import { directivePlugin, removeImportsPlugin } from "./index";
  */
 function createBuildConfig({ side, watch }: { side: 'client' | 'server', watch: boolean }) {
   const isClient = side === 'client';
+  const runtimeDir = resolve(process.cwd(), "runtime");
+  const resolveOptions = existsSync(runtimeDir)
+    ? {
+        alias: {
+          "@common": runtimeDir,
+        },
+      }
+    : undefined;
   
   const plugins = isClient 
     ? [
@@ -36,6 +46,7 @@ function createBuildConfig({ side, watch }: { side: 'client' | 'server', watch:
 
   return {
     configFile: false as const, // Prevent using this config file
+    resolve: resolveOptions,
     plugins: [
       ...plugins,
       dts({ 
@@ -57,7 +68,9 @@ function createBuildConfig({ side, watch }: { side: 'client' | 'server', watch:
       rollupOptions: {
         external: [
           /@rpgjs/,
+          /@signestack/,
           "canvasengine",
+          "pixi.js",
           "esbuild",
           "@canvasengine/presets",
           "rxjs",

package/src/rpgjs-plugin.ts

@@ -2,12 +2,37 @@ import canvasengine from "@canvasengine/compiler";
 import { replaceConfigImport } from "./replace-config-import";
 import { serverPlugin } from "./server-plugin";
 import { entryPointPlugin } from "./entry-point-plugin";
+import { mmorpgBuildPlugin } from "./mmorpg-build-plugin";
+
+type MmorpgEntryPoints =
+  | string
+  | {
+      client?: string;
+      server?: string;
+      adapters?: Record<string, string>;
+    };
 
 interface RpgjsPluginOptions {
   server: any;
   entryPoints?: {
-    rpg: string;
-    mmorpg: string;
+    rpg?: string;
+    mmorpg?: MmorpgEntryPoints;
+  };
+}
+
+function normalizeMmorpgEntryPoints(entryPoints?: MmorpgEntryPoints) {
+  if (!entryPoints || typeof entryPoints === "string") {
+    return {
+      client: entryPoints ?? "./src/client.ts",
+      server: "./src/server.ts",
+      adapters: {},
+    };
+  }
+
+  return {
+    client: entryPoints.client ?? "./src/client.ts",
+    server: entryPoints.server ?? "./src/server.ts",
+    adapters: entryPoints.adapters ?? {},
   };
 }
 
@@ -15,15 +40,22 @@ export function rpgjs({
   server,
   entryPoints
 }: RpgjsPluginOptions) {
+  const mmorpgEntryPoints = normalizeMmorpgEntryPoints(entryPoints?.mmorpg);
+
   return [
     canvasengine(),
     replaceConfigImport(),
     serverPlugin(server),
+    mmorpgBuildPlugin({
+      rpgType: process.env.RPG_TYPE || "rpg",
+      serverEntry: mmorpgEntryPoints.server,
+      adapterEntries: mmorpgEntryPoints.adapters,
+    }),
     entryPointPlugin({
       entryPoints: {
         rpg: entryPoints?.rpg ?? './src/standalone.ts',
-        mmorpg: entryPoints?.mmorpg ?? './src/client.ts'
+        mmorpg: mmorpgEntryPoints.client,
       }
     })
   ]
-}
+}