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

package/dist/services/loadMap.js

@@ -0,0 +1,123 @@
+import { inject } from "../node_modules/.pnpm/@signe_di@2.9.0/node_modules/@signe/di/dist/index.js";
+import { UpdateMapToken } from "@rpgjs/common";
+//#region src/services/loadMap.ts
+var LoadMapToken = "LoadMapToken";
+var LoadMapService = class {
+	constructor(context, options) {
+		this.context = context;
+		this.options = options;
+		if (context["side"] === "server") return;
+		this.updateMapService = inject(context, UpdateMapToken);
+	}
+	async load(mapId) {
+		const map = await this.options(mapId.replace("map-", ""));
+		await this.updateMapService.update(map);
+		return map;
+	}
+};
+/**
+* Creates a dependency injection configuration for custom map loading on the client side.
+* 
+* This function allows you to customize how maps are loaded and displayed by providing
+* a callback that defines custom map data and rendering components. It's designed to work
+* with the RPG-JS dependency injection system and enables integration of custom map formats
+* like Tiled TMX files or any other map data structure.
+* 
+* The function sets up the necessary service providers for map loading, including:
+* - UpdateMapToken: Handles map updates in the client context
+* - LoadMapToken: Provides the LoadMapService with your custom loading logic
+* 
+* **Design Concept:**
+* The function follows the provider pattern, creating a modular way to inject custom
+* map loading behavior into the RPG-JS client engine. It separates the concern of
+* map data fetching from map rendering, allowing developers to focus on their specific
+* map format while leveraging the engine's rendering capabilities.
+* 
+* @param {LoadMapOptions} options - Callback function that handles map loading logic
+* @returns {Array<Object>} Array of dependency injection provider configurations
+* 
+* @example
+* ```typescript
+* import { provideLoadMap } from '@rpgjs/client'
+* import { createModule } from '@rpgjs/common'
+* import MyTiledMapComponent from './MyTiledMapComponent.ce'
+* 
+* // Basic usage with JSON map data
+* export function provideCustomMap() {
+*   return createModule("CustomMap", [
+*     provideLoadMap(async (mapId) => {
+*       const response = await fetch(`/maps/${mapId}.json`)
+*       const mapData = await response.json()
+*       
+*       return {
+*         data: mapData,
+*         component: MyTiledMapComponent,
+*         width: mapData.width,
+*         height: mapData.height,
+*         events: mapData.events
+*       }
+*     })
+*   ])
+* }
+* 
+* // Advanced usage with Tiled TMX files
+* export function provideTiledMap() {
+*   return createModule("TiledMap", [
+*     provideLoadMap(async (mapId) => {
+*       // Load TMX file
+*       const tmxResponse = await fetch(`/tiled/${mapId}.tmx`)
+*       const tmxData = await tmxResponse.text()
+*       
+*       // Parse TMX data (using a TMX parser)
+*       const parsedMap = parseTMX(tmxData)
+*       
+*       return {
+*         data: parsedMap,
+*         component: TiledMapRenderer,
+*         width: parsedMap.width * parsedMap.tilewidth,
+*         height: parsedMap.height * parsedMap.tileheight,
+*         events: parsedMap.objectGroups?.find(g => g.name === 'events')?.objects
+*       }
+*     })
+*   ])
+* }
+* 
+* // Synchronous usage for static maps
+* export function provideStaticMap() {
+*   return createModule("StaticMap", [
+*     provideLoadMap((mapId) => {
+*       const staticMaps = {
+*         'town': { tiles: [...], npcs: [...] },
+*         'dungeon': { tiles: [...], monsters: [...] }
+*       }
+*       
+*       return {
+*         data: staticMaps[mapId],
+*         component: StaticMapComponent,
+*         width: 800,
+*         height: 600
+*       }
+*     })
+*   ])
+* }
+* ```
+* 
+* @since 4.0.0
+* @see {@link LoadMapOptions} for callback function signature
+* @see {@link MapData} for return data structure
+*/
+function provideLoadMap(options) {
+	return [{
+		provide: UpdateMapToken,
+		useFactory: (context) => {
+			if (context["side"] === "client") console.warn("UpdateMapToken is not overridden");
+		}
+	}, {
+		provide: LoadMapToken,
+		useFactory: (context) => new LoadMapService(context, options)
+	}];
+}
+//#endregion
+export { LoadMapService, LoadMapToken, provideLoadMap };
+
+//# sourceMappingURL=loadMap.js.map

package/dist/services/loadMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadMap.js","names":[],"sources":["../../src/services/loadMap.ts"],"sourcesContent":["import { Context, inject } from \"@signe/di\";\nimport { UpdateMapToken, UpdateMapService } from \"@rpgjs/common\";\n\nexport const LoadMapToken = 'LoadMapToken'\n\n/**\n * Represents the structure of map data that should be returned by the load map callback.\n * This interface defines all the properties that can be provided when loading a custom map.\n * \n * @interface MapData\n */\ntype MapData = {\n  /** Raw map data that will be passed to the map component */\n  data: any;\n  /** CanvasEngine component that will render the map */\n  component: any;\n  /** Optional map width in pixels, used for viewport calculations */\n  width?: number;\n  /** Optional map height in pixels, used for viewport calculations */\n  height?: number;\n  /** Optional map events data (NPCs, interactive objects, etc.) */\n  events?: any;\n  /** Optional map identifier, defaults to the mapId parameter if not provided */\n  id?: string;\n}\n\n/**\n * Callback function type for loading map data.\n * This function receives a map ID and should return either a MapData object directly\n * or a Promise that resolves to a MapData object.\n * \n * @callback LoadMapOptions\n * @param {string} mapId - The identifier of the map to load\n * @returns {Promise<MapData> | MapData} The map data object or a promise resolving to it\n */\nexport type LoadMapOptions = (mapId: string) => Promise<MapData> | MapData \n\nexport class LoadMapService {\n  private updateMapService: UpdateMapService;\n\n  constructor(private context: Context, private options: LoadMapOptions) {\n    if (context['side'] === 'server') {\n      return\n    }\n    this.updateMapService = inject(context, UpdateMapToken);\n  }\n\n  async load(mapId: string) {\n    const map = await this.options(mapId.replace('map-', ''))\n    await this.updateMapService.update(map);\n    return map;\n  }\n}\n\n/**\n * Creates a dependency injection configuration for custom map loading on the client side.\n * \n * This function allows you to customize how maps are loaded and displayed by providing\n * a callback that defines custom map data and rendering components. It's designed to work\n * with the RPG-JS dependency injection system and enables integration of custom map formats\n * like Tiled TMX files or any other map data structure.\n * \n * The function sets up the necessary service providers for map loading, including:\n * - UpdateMapToken: Handles map updates in the client context\n * - LoadMapToken: Provides the LoadMapService with your custom loading logic\n * \n * **Design Concept:**\n * The function follows the provider pattern, creating a modular way to inject custom\n * map loading behavior into the RPG-JS client engine. It separates the concern of\n * map data fetching from map rendering, allowing developers to focus on their specific\n * map format while leveraging the engine's rendering capabilities.\n * \n * @param {LoadMapOptions} options - Callback function that handles map loading logic\n * @returns {Array<Object>} Array of dependency injection provider configurations\n * \n * @example\n * ```typescript\n * import { provideLoadMap } from '@rpgjs/client'\n * import { createModule } from '@rpgjs/common'\n * import MyTiledMapComponent from './MyTiledMapComponent.ce'\n * \n * // Basic usage with JSON map data\n * export function provideCustomMap() {\n *   return createModule(\"CustomMap\", [\n *     provideLoadMap(async (mapId) => {\n *       const response = await fetch(`/maps/${mapId}.json`)\n *       const mapData = await response.json()\n *       \n *       return {\n *         data: mapData,\n *         component: MyTiledMapComponent,\n *         width: mapData.width,\n *         height: mapData.height,\n *         events: mapData.events\n *       }\n *     })\n *   ])\n * }\n * \n * // Advanced usage with Tiled TMX files\n * export function provideTiledMap() {\n *   return createModule(\"TiledMap\", [\n *     provideLoadMap(async (mapId) => {\n *       // Load TMX file\n *       const tmxResponse = await fetch(`/tiled/${mapId}.tmx`)\n *       const tmxData = await tmxResponse.text()\n *       \n *       // Parse TMX data (using a TMX parser)\n *       const parsedMap = parseTMX(tmxData)\n *       \n *       return {\n *         data: parsedMap,\n *         component: TiledMapRenderer,\n *         width: parsedMap.width * parsedMap.tilewidth,\n *         height: parsedMap.height * parsedMap.tileheight,\n *         events: parsedMap.objectGroups?.find(g => g.name === 'events')?.objects\n *       }\n *     })\n *   ])\n * }\n * \n * // Synchronous usage for static maps\n * export function provideStaticMap() {\n *   return createModule(\"StaticMap\", [\n *     provideLoadMap((mapId) => {\n *       const staticMaps = {\n *         'town': { tiles: [...], npcs: [...] },\n *         'dungeon': { tiles: [...], monsters: [...] }\n *       }\n *       \n *       return {\n *         data: staticMaps[mapId],\n *         component: StaticMapComponent,\n *         width: 800,\n *         height: 600\n *       }\n *     })\n *   ])\n * }\n * ```\n * \n * @since 4.0.0\n * @see {@link LoadMapOptions} for callback function signature\n * @see {@link MapData} for return data structure\n */\nexport function provideLoadMap(options: LoadMapOptions) {\n  return [\n    {\n      provide: UpdateMapToken,\n      useFactory: (context: Context) => {\n        if (context['side'] === 'client') {\n          console.warn('UpdateMapToken is not overridden')\n        }\n        return\n      },\n    },\n    {\n      provide: LoadMapToken,\n      useFactory: (context: Context) => new LoadMapService(context, options),\n    },\n  ];\n}\n"],"mappings":";;;AAGA,IAAa,eAAe;AAkC5B,IAAa,iBAAb,MAA4B;CAG1B,YAAY,SAA0B,SAAiC;AAAnD,OAAA,UAAA;AAA0B,OAAA,UAAA;AAC5C,MAAI,QAAQ,YAAY,SACtB;AAEF,OAAK,mBAAmB,OAAO,SAAS,eAAe;;CAGzD,MAAM,KAAK,OAAe;EACxB,MAAM,MAAM,MAAM,KAAK,QAAQ,MAAM,QAAQ,QAAQ,GAAG,CAAC;AACzD,QAAM,KAAK,iBAAiB,OAAO,IAAI;AACvC,SAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FX,SAAgB,eAAe,SAAyB;AACtD,QAAO,CACL;EACE,SAAS;EACT,aAAa,YAAqB;AAChC,OAAI,QAAQ,YAAY,SACtB,SAAQ,KAAK,mCAAmC;;EAIrD,EACD;EACE,SAAS;EACT,aAAa,YAAqB,IAAI,eAAe,SAAS,QAAQ;EACvE,CACF"}

package/dist/services/mmorpg.d.ts

@@ -1,32 +1,44 @@
 import { Context } from '@signe/di';
 import { RpgGui } from '../Gui/Gui';
 import { RpgClientEngine } from '../RpgClientEngine';
-import { AbstractWebsocket } from './AbstractSocket';
+import { AbstractWebsocket, SocketUpdateProperties } from './AbstractSocket';
 import { UpdateMapService } from '@rpgjs/common';
 interface MmorpgOptions {
     host?: string;
+    connectionId?: string;
+    connectionIdScope?: "local" | "session" | "ephemeral";
 }
 declare class BridgeWebsocket extends AbstractWebsocket {
     protected context: Context;
     private options;
     private socket;
+    private privateId;
+    private pendingOn;
+    private targetRoom;
     constructor(context: Context, options?: MmorpgOptions);
+    private resolveConnectionId;
     connection(listeners?: (data: any) => void): Promise<void>;
     on(key: string, callback: (data: any) => void): void;
     off(event: string, callback: (data: any) => void): void;
     emit(event: string, data: any): void;
-    updateProperties({ room }: {
-        room: any;
-    }): void;
-    reconnect(listeners?: (data: any) => void): Promise<void>;
+    updateProperties({ room, host, query }: SocketUpdateProperties): void;
+    private waitForNextOpen;
+    reconnect(_listeners?: (data: any) => void): Promise<void>;
+    getCurrentRoom(): string;
 }
 declare class UpdateMapStandaloneService extends UpdateMapService {
     protected context: Context;
-    private options;
-    constructor(context: Context, options: MmorpgOptions);
-    update(map: any): Promise<void>;
+    private _options;
+    constructor(context: Context, _options: MmorpgOptions);
+    update(_map: any): Promise<void>;
 }
-export declare function provideMmorpg(options: MmorpgOptions): (typeof RpgGui | typeof RpgClientEngine | {
+export declare function provideMmorpg(options: MmorpgOptions): (typeof RpgClientEngine | typeof RpgGui | {
+    provide: typeof import('./save').SaveClientService;
+    useClass: typeof import('./save').SaveClientService;
+} | {
+    provide: string;
+    useValue: null;
+} | {
     provide: string;
     useFactory: (context: Context) => BridgeWebsocket;
 } | {

package/dist/services/mmorpg.js

@@ -0,0 +1,131 @@
+import { AbstractWebsocket, WebSocketToken } from "./AbstractSocket.js";
+import { provideSaveClient } from "./save.js";
+import { RpgGui } from "../Gui/Gui.js";
+import { RpgClientEngine } from "../RpgClientEngine.js";
+import { provideKeyboardControls } from "./keyboardControls.js";
+import { connectionRoom } from "../node_modules/.pnpm/@signe_sync@2.9.0/node_modules/@signe/sync/dist/client/index.js";
+import { UpdateMapService, UpdateMapToken } from "@rpgjs/common";
+//#region src/services/mmorpg.ts
+var BridgeWebsocket = class extends AbstractWebsocket {
+	constructor(context, options = {}) {
+		super(context);
+		this.context = context;
+		this.options = options;
+		this.pendingOn = [];
+		this.targetRoom = "lobby-1";
+		this.privateId = this.resolveConnectionId();
+	}
+	resolveConnectionId() {
+		if (this.options.connectionId) return this.options.connectionId;
+		const scope = this.options.connectionIdScope ?? "local";
+		const key = "rpgjs-user-id";
+		if (scope === "ephemeral") return crypto.randomUUID();
+		const storage = scope === "session" ? window.sessionStorage : window.localStorage;
+		const existing = storage.getItem(key);
+		if (existing) return existing;
+		const id = crypto.randomUUID();
+		storage.setItem(key, id);
+		return id;
+	}
+	async connection(listeners) {
+		class Room {}
+		const instance = new Room();
+		this.socket = await connectionRoom({
+			host: this.options.host || window.location.host,
+			room: this.targetRoom,
+			id: this.privateId
+		}, instance);
+		listeners?.(this.socket);
+		this.pendingOn.forEach(({ event, callback }) => this.socket.on(event, callback));
+		this.pendingOn = [];
+	}
+	on(key, callback) {
+		if (!this.socket) {
+			this.pendingOn.push({
+				event: key,
+				callback
+			});
+			return;
+		}
+		this.socket.on(key, callback);
+	}
+	off(event, callback) {
+		if (!this.socket) return;
+		this.socket.off(event, callback);
+	}
+	emit(event, data) {
+		this.socket.emit(event, data);
+	}
+	updateProperties({ room, host, query }) {
+		if (!this.socket?.conn) return;
+		this.targetRoom = room;
+		this.socket.conn.updateProperties({
+			room,
+			id: this.privateId,
+			host: host || this.options.host || window.location.host,
+			query
+		});
+	}
+	waitForNextOpen(conn, timeoutMs = 1e4) {
+		return new Promise((resolve, reject) => {
+			let timeoutId;
+			const onOpen = () => {
+				cleanup();
+				resolve();
+			};
+			const onError = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket reconnect failed"));
+			};
+			const cleanup = () => {
+				conn.removeEventListener("open", onOpen);
+				conn.removeEventListener("error", onError);
+				if (timeoutId !== void 0) window.clearTimeout(timeoutId);
+			};
+			conn.addEventListener("open", onOpen);
+			conn.addEventListener("error", onError);
+			timeoutId = window.setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("WebSocket reconnect timeout"));
+			}, timeoutMs);
+		});
+	}
+	async reconnect(_listeners) {
+		if (!this.socket?.conn) return;
+		const conn = this.socket.conn;
+		const opened = this.waitForNextOpen(conn);
+		conn.reconnect();
+		await opened;
+	}
+	getCurrentRoom() {
+		return this.targetRoom || this.socket?.conn?.room || "lobby-1";
+	}
+};
+var UpdateMapStandaloneService = class extends UpdateMapService {
+	constructor(context, _options) {
+		super(context);
+		this.context = context;
+		this._options = _options;
+	}
+	async update(_map) {}
+};
+function provideMmorpg(options) {
+	return [
+		{
+			provide: WebSocketToken,
+			useFactory: (context) => new BridgeWebsocket(context, options)
+		},
+		{
+			provide: UpdateMapToken,
+			useFactory: (context) => new UpdateMapStandaloneService(context, options)
+		},
+		provideKeyboardControls(),
+		provideSaveClient(),
+		RpgGui,
+		RpgClientEngine
+	];
+}
+//#endregion
+export { provideMmorpg };
+
+//# sourceMappingURL=mmorpg.js.map

package/dist/services/mmorpg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmorpg.js","names":[],"sources":["../../src/services/mmorpg.ts"],"sourcesContent":["import { Context } from \"@signe/di\";\nimport { connectionRoom } from \"@signe/sync/client\";\nimport { RpgGui } from \"../Gui/Gui\";\nimport { RpgClientEngine } from \"../RpgClientEngine\";\nimport { AbstractWebsocket, SocketUpdateProperties, WebSocketToken } from \"./AbstractSocket\";\nimport { UpdateMapService, UpdateMapToken } from \"@rpgjs/common\";\nimport { provideKeyboardControls } from \"./keyboardControls\";\nimport { provideSaveClient } from \"./save\";\n\ninterface MmorpgOptions {\n    host?: string;\n    connectionId?: string;\n    connectionIdScope?: \"local\" | \"session\" | \"ephemeral\";\n}\n\nclass BridgeWebsocket extends AbstractWebsocket {\n  private socket: any;\n  private privateId: string;\n  private pendingOn: Array<{ event: string; callback: (data: any) => void }> = [];\n  private targetRoom = \"lobby-1\";\n\n  constructor(protected context: Context, private options: MmorpgOptions = {}) {\n    super(context);\n    this.privateId = this.resolveConnectionId();\n  }\n\n  private resolveConnectionId(): string {\n    if (this.options.connectionId) {\n      return this.options.connectionId;\n    }\n\n    const scope = this.options.connectionIdScope ?? \"local\";\n    const key = \"rpgjs-user-id\";\n\n    if (scope === \"ephemeral\") {\n      return crypto.randomUUID();\n    }\n\n    const storage =\n      scope === \"session\"\n        ? window.sessionStorage\n        : window.localStorage;\n\n    const existing = storage.getItem(key);\n    if (existing) {\n      return existing;\n    }\n\n    const id = crypto.randomUUID();\n    storage.setItem(key, id);\n    return id;\n  }\n\n  async connection(listeners?: (data: any) => void) {\n    // tmp\n    class Room {\n        \n    }\n    const instance = new Room()\n    const host = this.options.host || window.location.host;\n    this.socket = await connectionRoom({\n        host,\n        room: this.targetRoom,\n        id: this.privateId\n    }, instance)\n\n    listeners?.(this.socket)\n    this.pendingOn.forEach(({ event, callback }) => this.socket.on(event, callback));\n    this.pendingOn = [];\n  }\n\n  on(key: string, callback: (data: any) => void) {\n    if (!this.socket) {\n      this.pendingOn.push({ event: key, callback });\n      return;\n    }\n    this.socket.on(key, callback);\n  }\n\n  off(event: string, callback: (data: any) => void) {\n    if (!this.socket) return;\n    this.socket.off(event, callback);\n  }\n\n  emit(event: string, data: any) {\n    this.socket.emit(event, data);\n  }\n\n  updateProperties({ room, host, query }: SocketUpdateProperties) {\n    if (!this.socket?.conn) return;\n    this.targetRoom = room;\n    this.socket.conn.updateProperties({\n      room,\n      id: this.privateId,\n      host: host || this.options.host || window.location.host,\n      query,\n    })\n  }\n\n  private waitForNextOpen(conn: any, timeoutMs = 10000): Promise<void> {\n    return new Promise((resolve, reject) => {\n      let timeoutId: number | undefined;\n      const onOpen = () => {\n        cleanup();\n        resolve();\n      };\n      const onError = () => {\n        cleanup();\n        reject(new Error(\"WebSocket reconnect failed\"));\n      };\n      const cleanup = () => {\n        conn.removeEventListener(\"open\", onOpen);\n        conn.removeEventListener(\"error\", onError);\n        if (timeoutId !== undefined) {\n          window.clearTimeout(timeoutId);\n        }\n      };\n\n      conn.addEventListener(\"open\", onOpen);\n      conn.addEventListener(\"error\", onError);\n      timeoutId = window.setTimeout(() => {\n        cleanup();\n        reject(new Error(\"WebSocket reconnect timeout\"));\n      }, timeoutMs);\n    });\n  }\n\n  async reconnect(_listeners?: (data: any) => void): Promise<void> {\n    if (!this.socket?.conn) return;\n    const conn = this.socket.conn;\n    const opened = this.waitForNextOpen(conn);\n    conn.reconnect();\n    await opened;\n  }\n\n  getCurrentRoom(): string {\n    return this.targetRoom || this.socket?.conn?.room || \"lobby-1\";\n  }\n}\n\nclass UpdateMapStandaloneService extends UpdateMapService {\n  constructor(protected context: Context, private _options: MmorpgOptions) {\n    super(context);\n  }\n\n  async update(_map: any) {\n    // In MMORPG mode, clients are untrusted and must not push map definitions.\n    // Map bootstrap/update is handled server-side by @rpgjs/vite.\n    return;\n  }\n}\n\nexport function provideMmorpg(options: MmorpgOptions) {\n  return [\n    {\n      provide: WebSocketToken,\n      useFactory: (context: Context) => new BridgeWebsocket(context, options),\n    },\n    {\n      provide: UpdateMapToken,\n      useFactory: (context: Context) => new UpdateMapStandaloneService(context, options),\n    },\n    provideKeyboardControls(),\n    provideSaveClient(),\n    RpgGui,\n    RpgClientEngine,\n  ];\n}\n"],"mappings":"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"}

package/dist/services/save.d.ts

@@ -0,0 +1,19 @@
+import { SaveSlotList, SaveSlotMeta } from '@rpgjs/common';
+export declare const SaveClientToken = "SaveClientToken";
+export declare class SaveClientService {
+    private webSocket;
+    private pending;
+    private requestCounter;
+    initialize(): void;
+    listSlots(): Promise<SaveSlotList>;
+    saveSlot(index: number, meta?: SaveSlotMeta): Promise<SaveSlotList>;
+    loadSlot(index: number): Promise<boolean>;
+    private request;
+    private resolveRequest;
+    private rejectRequest;
+    private nextRequestId;
+}
+export declare function provideSaveClient(): {
+    provide: typeof SaveClientService;
+    useClass: typeof SaveClientService;
+};

package/dist/services/save.js

@@ -0,0 +1,77 @@
+import { inject } from "../core/inject.js";
+import { WebSocketToken } from "./AbstractSocket.js";
+//#region src/services/save.ts
+var SaveClientToken = "SaveClientToken";
+var SaveClientService = class {
+	constructor() {
+		this.webSocket = inject(WebSocketToken);
+		this.pending = /* @__PURE__ */ new Map();
+		this.requestCounter = 0;
+	}
+	initialize() {
+		const saveListResult = (data) => this.resolveRequest(data.requestId, data);
+		const saveSaveResult = (data) => this.resolveRequest(data.requestId, data);
+		const saveLoadResult = (data) => this.resolveRequest(data.requestId, data);
+		const saveErrorResult = (data) => this.rejectRequest(data.requestId, data.message);
+		this.webSocket.off("save.list.result", saveListResult);
+		this.webSocket.off("save.save.result", saveSaveResult);
+		this.webSocket.off("save.load.result", saveLoadResult);
+		this.webSocket.off("save.error", saveErrorResult);
+		this.webSocket.on("save.list.result", saveListResult);
+		this.webSocket.on("save.save.result", saveSaveResult);
+		this.webSocket.on("save.load.result", saveLoadResult);
+		this.webSocket.on("save.error", saveErrorResult);
+	}
+	listSlots() {
+		return this.request("save.list", {}).then((result) => result.slots);
+	}
+	saveSlot(index, meta = {}) {
+		return this.request("save.save", {
+			index,
+			meta
+		}).then((result) => result.slots);
+	}
+	loadSlot(index) {
+		return this.request("save.load", { index }).then((result) => result.ok);
+	}
+	request(event, payload) {
+		return new Promise((resolve, reject) => {
+			if (!this.webSocket) this.initialize();
+			const requestId = this.nextRequestId();
+			this.pending.set(requestId, {
+				resolve,
+				reject
+			});
+			this.webSocket?.emit(event, {
+				requestId,
+				...payload
+			});
+		});
+	}
+	resolveRequest(requestId, result) {
+		const pending = this.pending.get(requestId);
+		if (!pending) return;
+		this.pending.delete(requestId);
+		pending.resolve(result);
+	}
+	rejectRequest(requestId, message) {
+		const pending = this.pending.get(requestId);
+		if (!pending) return;
+		this.pending.delete(requestId);
+		pending.reject(new Error(message));
+	}
+	nextRequestId() {
+		this.requestCounter += 1;
+		return `${Date.now()}-${this.requestCounter}`;
+	}
+};
+function provideSaveClient() {
+	return {
+		provide: SaveClientService,
+		useClass: SaveClientService
+	};
+}
+//#endregion
+export { SaveClientService, SaveClientToken, provideSaveClient };
+
+//# sourceMappingURL=save.js.map

package/dist/services/save.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.js","names":[],"sources":["../../src/services/save.ts"],"sourcesContent":["import type { SaveSlotList, SaveSlotMeta } from \"@rpgjs/common\";\nimport { inject } from \"../core/inject\";\nimport { AbstractWebsocket, WebSocketToken } from \"./AbstractSocket\";\n\nexport const SaveClientToken = \"SaveClientToken\";\n\ntype SaveListResult = {\n  requestId: string;\n  slots: SaveSlotList;\n};\n\ntype SaveSaveResult = {\n  requestId: string;\n  index: number;\n  slots: SaveSlotList;\n};\n\ntype SaveLoadResult = {\n  requestId: string;\n  index: number;\n  ok: boolean;\n  slot?: SaveSlotMeta;\n};\n\ntype SaveErrorResult = {\n  requestId: string;\n  message: string;\n};\n\ntype PendingRequest = {\n  resolve: (value: any) => void;\n  reject: (error: Error) => void;\n};\n\nexport class SaveClientService {\n  private webSocket: AbstractWebsocket = inject(WebSocketToken);\n  private pending: Map<string, PendingRequest> = new Map();\n  private requestCounter = 0;\n\n  initialize() {\n    const saveListResult = (data: SaveListResult) => this.resolveRequest(data.requestId, data);\n    const saveSaveResult = (data: SaveSaveResult) => this.resolveRequest(data.requestId, data);\n    const saveLoadResult = (data: SaveLoadResult) => this.resolveRequest(data.requestId, data);\n    const saveErrorResult = (data: SaveErrorResult) => this.rejectRequest(data.requestId, data.message);\n    this.webSocket.off(\"save.list.result\", saveListResult);\n    this.webSocket.off(\"save.save.result\", saveSaveResult);\n    this.webSocket.off(\"save.load.result\", saveLoadResult);\n    this.webSocket.off(\"save.error\", saveErrorResult);\n    this.webSocket.on(\"save.list.result\", saveListResult);\n    this.webSocket.on(\"save.save.result\", saveSaveResult);\n    this.webSocket.on(\"save.load.result\", saveLoadResult);\n    this.webSocket.on(\"save.error\", saveErrorResult);\n  }\n\n  listSlots(): Promise<SaveSlotList> {\n    return this.request<SaveListResult>(\"save.list\", {}).then((result) => result.slots);\n  }\n\n  saveSlot(index: number, meta: SaveSlotMeta = {}): Promise<SaveSlotList> {\n    return this.request<SaveSaveResult>(\"save.save\", { index, meta }).then((result) => result.slots);\n  }\n\n  loadSlot(index: number): Promise<boolean> {\n    return this.request<SaveLoadResult>(\"save.load\", { index }).then((result) => result.ok);\n  }\n\n  private request<T>(event: string, payload: Record<string, any>): Promise<T> {\n    return new Promise((resolve, reject) => {\n      if (!this.webSocket) {\n        this.initialize();\n      }\n      const requestId = this.nextRequestId();\n      this.pending.set(requestId, { resolve, reject });\n      this.webSocket?.emit(event, { requestId, ...payload });\n    });\n  }\n\n  private resolveRequest(requestId: string, result: any) {\n    const pending = this.pending.get(requestId);\n    if (!pending) return;\n    this.pending.delete(requestId);\n    pending.resolve(result);\n  }\n\n  private rejectRequest(requestId: string, message: string) {\n    const pending = this.pending.get(requestId);\n    if (!pending) return;\n    this.pending.delete(requestId);\n    pending.reject(new Error(message));\n  }\n\n  private nextRequestId(): string {\n    this.requestCounter += 1;\n    return `${Date.now()}-${this.requestCounter}`;\n  }\n}\n\nexport function provideSaveClient() {\n  return {\n    provide: SaveClientService,\n    useClass: SaveClientService,\n  };\n}\n"],"mappings":";;;AAIA,IAAa,kBAAkB;AA8B/B,IAAa,oBAAb,MAA+B;;mBACU,OAAO,eAAe;iCACd,IAAI,KAAK;wBAC/B;;CAEzB,aAAa;EACX,MAAM,kBAAkB,SAAyB,KAAK,eAAe,KAAK,WAAW,KAAK;EAC1F,MAAM,kBAAkB,SAAyB,KAAK,eAAe,KAAK,WAAW,KAAK;EAC1F,MAAM,kBAAkB,SAAyB,KAAK,eAAe,KAAK,WAAW,KAAK;EAC1F,MAAM,mBAAmB,SAA0B,KAAK,cAAc,KAAK,WAAW,KAAK,QAAQ;AACnG,OAAK,UAAU,IAAI,oBAAoB,eAAe;AACtD,OAAK,UAAU,IAAI,oBAAoB,eAAe;AACtD,OAAK,UAAU,IAAI,oBAAoB,eAAe;AACtD,OAAK,UAAU,IAAI,cAAc,gBAAgB;AACjD,OAAK,UAAU,GAAG,oBAAoB,eAAe;AACrD,OAAK,UAAU,GAAG,oBAAoB,eAAe;AACrD,OAAK,UAAU,GAAG,oBAAoB,eAAe;AACrD,OAAK,UAAU,GAAG,cAAc,gBAAgB;;CAGlD,YAAmC;AACjC,SAAO,KAAK,QAAwB,aAAa,EAAE,CAAC,CAAC,MAAM,WAAW,OAAO,MAAM;;CAGrF,SAAS,OAAe,OAAqB,EAAE,EAAyB;AACtE,SAAO,KAAK,QAAwB,aAAa;GAAE;GAAO;GAAM,CAAC,CAAC,MAAM,WAAW,OAAO,MAAM;;CAGlG,SAAS,OAAiC;AACxC,SAAO,KAAK,QAAwB,aAAa,EAAE,OAAO,CAAC,CAAC,MAAM,WAAW,OAAO,GAAG;;CAGzF,QAAmB,OAAe,SAA0C;AAC1E,SAAO,IAAI,SAAS,SAAS,WAAW;AACtC,OAAI,CAAC,KAAK,UACR,MAAK,YAAY;GAEnB,MAAM,YAAY,KAAK,eAAe;AACtC,QAAK,QAAQ,IAAI,WAAW;IAAE;IAAS;IAAQ,CAAC;AAChD,QAAK,WAAW,KAAK,OAAO;IAAE;IAAW,GAAG;IAAS,CAAC;IACtD;;CAGJ,eAAuB,WAAmB,QAAa;EACrD,MAAM,UAAU,KAAK,QAAQ,IAAI,UAAU;AAC3C,MAAI,CAAC,QAAS;AACd,OAAK,QAAQ,OAAO,UAAU;AAC9B,UAAQ,QAAQ,OAAO;;CAGzB,cAAsB,WAAmB,SAAiB;EACxD,MAAM,UAAU,KAAK,QAAQ,IAAI,UAAU;AAC3C,MAAI,CAAC,QAAS;AACd,OAAK,QAAQ,OAAO,UAAU;AAC9B,UAAQ,OAAO,IAAI,MAAM,QAAQ,CAAC;;CAGpC,gBAAgC;AAC9B,OAAK,kBAAkB;AACvB,SAAO,GAAG,KAAK,KAAK,CAAC,GAAG,KAAK;;;AAIjC,SAAgB,oBAAoB;AAClC,QAAO;EACL,SAAS;EACT,UAAU;EACX"}

package/dist/services/standalone.d.ts

@@ -1,28 +1,88 @@
-import { AbstractWebsocket } from './AbstractSocket';
+import { AbstractWebsocket, SocketUpdateProperties } from './AbstractSocket';
 import { Context } from '@signe/di';
 import { RpgClientEngine } from '../RpgClientEngine';
 import { UpdateMapService } from '@rpgjs/common';
 import { RpgGui } from '../Gui/Gui';
+interface StandaloneOptions {
+    env?: Record<string, any>;
+}
 declare class BridgeWebsocket extends AbstractWebsocket {
     protected context: Context;
     private server;
     private room;
     private socket;
-    constructor(context: Context, server: any);
+    private pendingOn;
+    private rooms;
+    private serverInstance;
+    constructor(context: Context, server: any, options?: StandaloneOptions);
     connection(listeners?: (data: any) => void): Promise<any>;
+    private _connection;
     on(key: string, callback: (data: any) => void): void;
     off(event: string, callback: (data: any) => void): void;
     emit(event: string, data: any): void;
-    updateProperties({ room }: {
-        room: any;
-    }): void;
+    /**
+     * Update underlying connection properties before a reconnect
+     *
+     * Design
+     * - Dynamically register a factory for the requested room to ensure a fresh server instance
+     * - Swap the internal ServerIo to target the new room
+     *
+     * @param params - Properties to update
+     * @param params.room - The target room id (e.g. `map-simplemap2`)
+     *
+     * @example
+     * ```ts
+     * websocket.updateProperties({ room: 'map-simplemap2' })
+     * await websocket.reconnect()
+     * ```
+     */
+    updateProperties(_params: SocketUpdateProperties): void;
+    /**
+     * Reconnect the client to the current Party room
+     *
+     * Design
+     * - Must be called after `updateProperties()` when switching rooms
+     * - Rebuilds the client <-> server bridge and re-triggers connection listeners
+     *
+     * @param listeners - Optional callback to re-bind event handlers on the new socket
+     *
+     * @example
+     * ```ts
+     * websocket.updateProperties({ room: 'map-dungeon' })
+     * await websocket.reconnect((socket) => {
+     *   // re-bind events here
+     * })
+     * ```
+     */
     reconnect(listeners?: (data: any) => void): Promise<void>;
+    getServer(): any;
+    getSocket(): any;
 }
 declare class UpdateMapStandaloneService extends UpdateMapService {
     private server;
-    update(mapId: string, map: any): Promise<void>;
+    /**
+     * Update the current room map data on the server side
+     *
+     * Design
+     * - Uses the in-memory server instance stored in context (standalone mode)
+     * - Builds a local HTTP-like request to the current Party room endpoint
+     *
+     * @param map - The map payload to apply on the server
+     *
+     * @example
+     * ```ts
+     * await updateMapService.update({ width: 1024, height: 768, events: [] })
+     * ```
+     */
+    update(map: any): Promise<void>;
 }
-export declare function provideRpg(server: any): (typeof RpgGui | typeof RpgClientEngine | {
+export declare function provideRpg(server: any, options?: StandaloneOptions): (typeof RpgClientEngine | typeof RpgGui | {
+    provide: typeof import('./save').SaveClientService;
+    useClass: typeof import('./save').SaveClientService;
+} | {
+    provide: string;
+    useValue: null;
+} | {
     provide: string;
     useFactory: (context: Context) => BridgeWebsocket;
     useClass?: undefined;