@signe/room 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,7 +1,43 @@
 import { Request as Request$1, WebSocket, DurableObjectState, AnalyticsEngineDataset, DurableObjectStorage, VectorizeIndex, R2Bucket, KVNamespace } from '@cloudflare/workers-types';
 
-declare function action(name: string, bodyValidation?: any): (target: any, propertyKey: string) => void;
-declare function Room$1(options: any): (target: any) => void;
+declare function Action(name: string, bodyValidation?: any): (target: any, propertyKey: string) => void;
+interface RoomOptions {
+    path: string;
+    maxUsers?: number;
+    throttleStorage?: number;
+    throttleSync?: number;
+    hibernate?: boolean;
+}
+declare function Room$1(options: RoomOptions): (target: any) => void;
+
+declare class MockPartySocket {
+    private events;
+    id: string;
+    addEventListener(event: any, cb: any): void;
+    removeEventListener(event: any, cb: any): void;
+    _trigger(event: any, data: any): void;
+}
+declare class MockStorage {
+    private storage;
+    get(key: string): Promise<any>;
+    put(key: string, value: any): Promise<void>;
+    list(): Promise<Map<string, any>>;
+}
+declare class MockPartyRoom {
+    id?: string;
+    private clients;
+    storage: MockStorage;
+    constructor(id?: string);
+    connection(client: any): void;
+    broadcast(data: any): void;
+    clear(): void;
+}
+declare class MockConnection {
+    state: any;
+    setState(value: any): void;
+}
+declare const ServerIo: typeof MockPartyRoom;
+declare const ClientIo: typeof MockPartySocket;
 
 type AssetFetcher = {
     fetch(path: string): Promise<Response | null>;
@@ -173,17 +209,170 @@ type ServerOptions = {
     hibernate?: boolean;
 };
 
+/**
+ * @class Server
+ * @implements {Party.Server}
+ * @description Represents a server that manages rooms and connections for a multiplayer game or application.
+ *
+ * @example
+ * ```typescript
+ * import { Room, Server, ServerIo } from "@yourpackage/room";
+ *
+ * @Room({ path: "game" })
+ * class GameRoom {
+ *   // Room implementation
+ * }
+ *
+ * class MyServer extends Server {
+ *   rooms = [GameRoom];
+ * }
+ *
+ * const server = new MyServer(new ServerIo("game"));
+ * server.onStart();
+ * ```
+ */
 declare class Server implements Server$1 {
     readonly room: Room;
-    memoryAll: {};
-    subRoom: {};
+    subRoom: any;
     rooms: any[];
-    static onBeforeConnect(request: Request): Promise<Response | Request>;
+    /**
+     * @constructor
+     * @param {Party.Room} room - The room object representing the current game or application instance.
+     *
+     * @example
+     * ```typescript
+     * const server = new MyServer(new ServerIo("game"));
+     * ```
+     */
     constructor(room: Room);
+    /**
+      * @readonly
+      * @property {boolean} isHibernate - Indicates whether the server is in hibernate mode.
+      *
+      * @example
+      * ```typescript
+      * if (!server.isHibernate) {
+      *   console.log("Server is active");
+      * }
+      * ```
+      */
+    get isHibernate(): boolean;
+    /**
+     * @method onStart
+     * @async
+     * @description Initializes the server and creates the initial room if not in hibernate mode.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * async function initServer() {
+     *   await server.onStart();
+     *   console.log("Server started");
+     * }
+     * ```
+     */
+    onStart(): Promise<void>;
+    /**
+     * @method createRoom
+     * @private
+     * @async
+     * @param {CreateRoomOptions} [options={}] - Options for creating the room.
+     * @returns {Promise<Object>} The created room instance.
+     * @throws {Error} If no matching room is found.
+     *
+     * @example
+     * ```typescript
+     * // This method is private and called internally
+     * async function internalCreateRoom() {
+     *   const room = await this.createRoom({ getMemoryAll: true });
+     *   console.log("Room created:", room);
+     * }
+     * ```
+     */
+    private createRoom;
+    /**
+     * @method getSubRoom
+     * @private
+     * @async
+     * @param {Object} [options={}] - Options for getting the sub-room.
+     * @returns {Promise<Object>} The sub-room instance.
+     *
+     * @example
+     * ```typescript
+     * // This method is private and called internally
+     * async function internalGetSubRoom() {
+     *   const subRoom = await this.getSubRoom();
+     *   console.log("Sub-room retrieved:", subRoom);
+     * }
+     * ```
+     */
+    private getSubRoom;
+    /**
+     * @method getUsersProperty
+     * @private
+     * @param {Object} subRoom - The sub-room instance.
+     * @returns {Object|null} The users property of the sub-room, or null if not found.
+     *
+     * @example
+     * ```typescript
+     * // This method is private and called internally
+     * function internalGetUsers(subRoom) {
+     *   const users = this.getUsersProperty(subRoom);
+     *   console.log("Users:", users);
+     * }
+     * ```
+     */
     private getUsersProperty;
+    /**
+     * @method onConnect
+     * @async
+     * @param {Party.Connection} conn - The connection object for the new user.
+     * @param {Party.ConnectionContext} ctx - The context of the connection.
+     * @description Handles a new user connection, creates a user object, and sends initial sync data.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * server.onConnect = async (conn, ctx) => {
+     *   await server.onConnect(conn, ctx);
+     *   console.log("New user connected:", conn.id);
+     * };
+     * ```
+     */
     onConnect(conn: Connection, ctx: ConnectionContext): Promise<void>;
+    /**
+     * @method onMessage
+     * @async
+     * @param {string} message - The message received from a user.
+     * @param {Party.Connection} sender - The connection object of the sender.
+     * @description Processes incoming messages and triggers corresponding actions in the sub-room.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * server.onMessage = async (message, sender) => {
+     *   await server.onMessage(message, sender);
+     *   console.log("Message processed from:", sender.id);
+     * };
+     * ```
+     */
     onMessage(message: string, sender: Connection): Promise<void>;
+    /**
+     * @method onClose
+     * @async
+     * @param {Party.Connection} conn - The connection object of the disconnecting user.
+     * @description Handles user disconnection, removing them from the room and triggering the onLeave event.
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * server.onClose = async (conn) => {
+     *   await server.onClose(conn);
+     *   console.log("User disconnected:", conn.id);
+     * };
+     * ```
+     */
     onClose(conn: Connection): Promise<void>;
 }
 
-export { Room$1 as Room, Server, action };
+export { Action, ClientIo, MockConnection, Room$1 as Room, type RoomOptions, Server, ServerIo };