@rpgjs/vite 5.0.0-alpha.10 → 5.0.0-alpha.3

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @rpgjs/vite
+
+## 5.0.0-alpha.3
+
+### Patch Changes
+
+- alpha

package/dist/index.d.ts

@@ -2,7 +2,3 @@ export { tiledMapFolderPlugin, type DataFolderPluginOptions } from './tiled-map-
 export { rpgjsModuleViteConfig } from './module-config';
 export { directivePlugin, type DirectivePluginOptions } from './directive-plugin';
 export { removeImportsPlugin, type RemoveImportsPluginOptions } from './remove-imports-plugin';
-export { replaceConfigImport } from './replace-config-import';
-export { rpgjs } from './rpgjs-plugin';
-export { serverPlugin } from './server-plugin';
-export { entryPointPlugin, type EntryPointPluginOptions } from './entry-point-plugin';

package/dist/index.js

@@ -8497,415 +8497,5 @@ function removeImportsPlugin(options) {
   };
 }
 
-function replaceConfigImport() {
-  return {
-    name: "replace-config-import",
-    transform(code, id) {
-      if (!id.endsWith("src/index.ts")) {
-        return;
-      }
-      const baseDir = dirname(id);
-      const isProd = process.env.NODE_ENV === "production";
-      const configFile = isProd ? "config.prod.ts" : "config.dev.ts";
-      const configPath = join(baseDir, configFile);
-      if (existsSync(configPath)) {
-        const newImport = isProd ? "./config.prod" : "./config.dev";
-        return code.replace(/['"]\.\/(config)['"]/g, `"${newImport}"`);
-      }
-    }
-  };
-}
-
-class PartyConnection {
-  constructor(ws, id, uri) {
-    this.ws = ws;
-    this._state = {};
-    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
-   */
-  generateId() {
-    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) {
-    if (this.ws.readyState === 1) {
-      const message = typeof data === "string" ? data : JSON.stringify(data);
-      this.ws.send(message);
-    }
-  }
-  /**
-   * Closes the WebSocket connection
-   */
-  close() {
-    if (this.ws.readyState === 1) {
-      this.ws.close();
-    }
-  }
-  /**
-   * Sets state data for this connection
-   *
-   * @param {any} value - State data to store (max 2KB as per PartyKit spec)
-   */
-  setState(value) {
-    this._state = value;
-  }
-  /**
-   * Gets the current state of this connection
-   *
-   * @returns {any} Current connection state
-   */
-  get state() {
-    return this._state;
-  }
-}
-class Room {
-  constructor(id) {
-    this.env = {};
-    this.context = {};
-    this.connections = /* @__PURE__ */ new Map();
-    this.storageData = /* @__PURE__ */ new Map();
-    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, except = []) {
-    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) {
-    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) {
-    return this.connections.values();
-  }
-  /**
-   * Adds a connection to this room
-   *
-   * @param {PartyConnection} connection - Connection to add
-   */
-  addConnection(connection) {
-    this.connections.set(connection.id, connection);
-  }
-  /**
-   * Removes a connection from this room
-   *
-   * @param {string} connectionId - ID of connection to remove
-   */
-  removeConnection(connectionId) {
-    this.connections.delete(connectionId);
-  }
-  /**
-   * Simple key-value storage for the room
-   */
-  get storage() {
-    return {
-      put: async (key, value) => {
-        this.storageData.set(key, value);
-      },
-      get: async (key) => {
-        return this.storageData.get(key);
-      },
-      delete: async (key) => {
-        this.storageData.delete(key);
-      },
-      list: async () => {
-        return Array.from(this.storageData.keys());
-      }
-    };
-  }
-}
-async function importWebSocketServer() {
-  if (typeof process === "undefined" || !process.versions?.node) {
-    console.warn("Not in Node.js environment, WebSocket server not available");
-    return null;
-  }
-  try {
-    const { createRequire } = await import('module');
-    const require = createRequire(import.meta.url);
-    const ws = require("ws");
-    return ws.WebSocketServer || ws.default?.WebSocketServer || ws;
-  } catch (error) {
-    console.warn("Failed to load ws module:", error);
-    return null;
-  }
-}
-function serverPlugin(serverModule) {
-  let wsServer = null;
-  let rooms = /* @__PURE__ */ new Map();
-  let servers = /* @__PURE__ */ new Map();
-  return {
-    name: "server-plugin",
-    async configureServer(server) {
-      try {
-        const WebSocketServerClass = await importWebSocketServer();
-        if (WebSocketServerClass) {
-          wsServer = new WebSocketServerClass({
-            noServer: true
-          });
-          console.log("WebSocket server initialized successfully");
-        } else {
-          console.log("WebSocket server not available in this environment");
-        }
-      } catch (error) {
-        console.warn("WebSocket server not available:", error);
-        wsServer = null;
-      }
-      console.log("RPG-JS server plugin initialized");
-      server.middlewares.use("/parties", async (req, res, next) => {
-        try {
-          console.log(`RPG-JS HTTP request: ${req.method} ${req.url}`);
-          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: (/* @__PURE__ */ 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" }));
-        }
-      });
-      if (wsServer) {
-        server.httpServer?.on(
-          "upgrade",
-          (request, socket, head) => {
-            const url = new URL(request.url, `http://${request.headers.host}`);
-            if (url.pathname.startsWith("/parties/")) {
-              console.log(`WebSocket upgrade request: ${url.pathname}`);
-              wsServer.handleUpgrade(
-                request,
-                socket,
-                head,
-                async (ws) => {
-                  try {
-                    const pathParts = url.pathname.split("/");
-                    const roomName = pathParts[pathParts.length - 1];
-                    const queryParams = Object.fromEntries(
-                      url.searchParams.entries()
-                    );
-                    console.log(
-                      `Room: ${roomName}, Query params:`,
-                      queryParams
-                    );
-                    let room = rooms.get(roomName);
-                    if (!room) {
-                      room = new Room(roomName);
-                      rooms.set(roomName, room);
-                      console.log(`Created new room: ${roomName}`);
-                    }
-                    let rpgServer = servers.get(roomName);
-                    if (!rpgServer) {
-                      rpgServer = new serverModule(room);
-                      servers.set(roomName, rpgServer);
-                      console.log(`Created new server instance for room: ${roomName}`);
-                      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);
-                        }
-                      }
-                    }
-                    const connection = new PartyConnection(
-                      ws,
-                      void 0,
-                      request.url
-                    );
-                    room.addConnection(connection);
-                    console.log(
-                      `WebSocket connection established: ${connection.id} in room: ${roomName}`
-                    );
-                    ws.on("message", async (data) => {
-                      try {
-                        const message = data.toString();
-                        if (typeof rpgServer.onMessage === "function") {
-                          await rpgServer.onMessage(message, connection);
-                        }
-                      } catch (error) {
-                        console.error(
-                          "Error processing WebSocket message:",
-                          error
-                        );
-                      }
-                    });
-                    ws.on("close", async () => {
-                      console.log(
-                        `WebSocket connection closed: ${connection.id} from room: ${roomName}`
-                      );
-                      room.removeConnection(connection.id);
-                      if (typeof rpgServer.onClose === "function") {
-                        await rpgServer.onClose(connection);
-                      }
-                    });
-                    ws.on("error", async (error) => {
-                      console.error("WebSocket error:", error);
-                      room.removeConnection(connection.id);
-                      if (typeof rpgServer.onClose === "function") {
-                        await rpgServer.onClose(connection);
-                      }
-                    });
-                    if (typeof rpgServer.onConnect === "function") {
-                      const headers = /* @__PURE__ */ 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) => headers.has(name.toLowerCase()),
-                            get: (name) => headers.get(name.toLowerCase()),
-                            entries: () => headers.entries(),
-                            keys: () => headers.keys(),
-                            values: () => headers.values()
-                          },
-                          url: request.url,
-                          method: request.method
-                        },
-                        url
-                      };
-                      await rpgServer.onConnect(
-                        connection,
-                        connectionContext
-                      );
-                    }
-                    connection.send({
-                      type: "connected",
-                      id: connection.id,
-                      message: "Connected to RPG-JS server"
-                    });
-                  } catch (error) {
-                    console.error(
-                      "Error establishing WebSocket connection:",
-                      error
-                    );
-                    ws.close();
-                  }
-                }
-              );
-            }
-          }
-        );
-      }
-      console.log(
-        "RPG-JS server plugin configured with HTTP and WebSocket forwarding"
-      );
-    },
-    buildStart() {
-      console.log("RPG-JS server starting...");
-    },
-    buildEnd() {
-      if (wsServer) {
-        wsServer.close();
-      }
-      console.log("RPG-JS server stopped");
-    }
-  };
-}
-
-function entryPointPlugin(options = {}) {
-  const {
-    entryPoints = {
-      rpg: "./src/standalone.ts",
-      mmorpg: "./src/client.ts"
-    },
-    rpgType = process.env.RPG_TYPE || "rpg"
-  } = options;
-  return {
-    name: "rpgjs:entry-point",
-    transformIndexHtml: {
-      order: "pre",
-      handler(html) {
-        const currentEntryPoint = entryPoints[rpgType];
-        if (!currentEntryPoint) {
-          console.warn(`[rpgjs:entry-point] Unknown RPG_TYPE: ${rpgType}. Using default 'rpg' type.`);
-          const fallbackEntryPoint = entryPoints.rpg || "./src/standalone.ts";
-          return html.replace(
-            /<script\s+type="module"\s+src="[^"]*"[^>]*><\/script>/gi,
-            `<script type="module" src="${fallbackEntryPoint}"><\/script>`
-          );
-        }
-        const transformedHtml = html.replace(
-          /<script\s+type="module"\s+src="[^"]*"[^>]*><\/script>/gi,
-          `<script type="module" src="${currentEntryPoint}"><\/script>`
-        );
-        if (transformedHtml === html && !html.includes('<script type="module"')) {
-          return html.replace(
-            /<\/head>/i,
-            `  <script type="module" src="${currentEntryPoint}"><\/script>
-  </head>`
-          );
-        }
-        return transformedHtml;
-      }
-    },
-    configResolved(config) {
-      console.log(`[rpgjs:entry-point] Using RPG_TYPE: ${rpgType}`);
-      console.log(`[rpgjs:entry-point] Entry point: ${entryPoints[rpgType]}`);
-    }
-  };
-}
-
-function rpgjs({
-  server,
-  entryPoints
-}) {
-  return [
-    canvasengine(),
-    replaceConfigImport(),
-    serverPlugin(server),
-    entryPointPlugin({
-      entryPoints: {
-        rpg: entryPoints?.rpg ?? "./src/standalone.ts",
-        mmorpg: entryPoints?.mmorpg ?? "./src/client.ts"
-      }
-    })
-  ];
-}
-
-export { directivePlugin, entryPointPlugin, removeImportsPlugin, replaceConfigImport, rpgjs, rpgjsModuleViteConfig, serverPlugin, tiledMapFolderPlugin };
+export { directivePlugin, removeImportsPlugin, rpgjsModuleViteConfig, tiledMapFolderPlugin };
 //# sourceMappingURL=index.js.map