@rpgjs/client 5.0.0-alpha.3 → 5.0.0-alpha.30

package/dist/services/loadMap.d.ts

@@ -1,14 +1,135 @@
 import { Context } from '@signe/di';
 export declare const LoadMapToken = "LoadMapToken";
-export type LoadMapOptions = (mapId: string) => Promise<void>;
+/**
+ * Represents the structure of map data that should be returned by the load map callback.
+ * This interface defines all the properties that can be provided when loading a custom map.
+ *
+ * @interface MapData
+ */
+type MapData = {
+    /** Raw map data that will be passed to the map component */
+    data: any;
+    /** CanvasEngine component that will render the map */
+    component: any;
+    /** Optional map width in pixels, used for viewport calculations */
+    width?: number;
+    /** Optional map height in pixels, used for viewport calculations */
+    height?: number;
+    /** Optional map events data (NPCs, interactive objects, etc.) */
+    events?: any;
+    /** Optional map identifier, defaults to the mapId parameter if not provided */
+    id?: string;
+};
+/**
+ * Callback function type for loading map data.
+ * This function receives a map ID and should return either a MapData object directly
+ * or a Promise that resolves to a MapData object.
+ *
+ * @callback LoadMapOptions
+ * @param {string} mapId - The identifier of the map to load
+ * @returns {Promise<MapData> | MapData} The map data object or a promise resolving to it
+ */
+export type LoadMapOptions = (mapId: string) => Promise<MapData> | MapData;
 export declare class LoadMapService {
     private context;
     private options;
     private updateMapService;
     constructor(context: Context, options: LoadMapOptions);
-    load(mapId: string): Promise<void>;
+    load(mapId: string): Promise<MapData>;
 }
+/**
+ * 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
+ */
 export declare function provideLoadMap(options: LoadMapOptions): {
     provide: string;
     useFactory: (context: Context) => void;
 }[];
+export {};

package/dist/{index7.js → services/loadMap.js}

@@ -1,4 +1,4 @@
-import { inject } from './index15.js';
+import { inject } from '../node_modules/.pnpm/@signe_di@2.8.2/node_modules/@signe/di/dist/index.js';
 import { UpdateMapToken } from '@rpgjs/common';
 
 const LoadMapToken = "LoadMapToken";
@@ -6,11 +6,14 @@ class LoadMapService {
   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(mapId, map);
+    await this.updateMapService.update(map);
     return map;
   }
 }
@@ -18,7 +21,12 @@ function provideLoadMap(options) {
   return [
     {
       provide: UpdateMapToken,
-      useFactory: (context) => console.warn("UpdateMapToken is not overridden")
+      useFactory: (context) => {
+        if (context["side"] === "client") {
+          console.warn("UpdateMapToken is not overridden");
+        }
+        return;
+      }
     },
     {
       provide: LoadMapToken,
@@ -28,4 +36,4 @@ function provideLoadMap(options) {
 }
 
 export { LoadMapService, LoadMapToken, provideLoadMap };
-//# sourceMappingURL=index7.js.map
+//# sourceMappingURL=loadMap.js.map

package/dist/services/loadMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadMap.js","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"],"names":[],"mappings":";;;AAGO,MAAM,YAAA,GAAe;AAkCrB,MAAM,cAAA,CAAe;AAAA,EAG1B,WAAA,CAAoB,SAA0B,OAAA,EAAyB;AAAnD,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AAA0B,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AAC5C,IAAA,IAAI,OAAA,CAAQ,MAAM,CAAA,KAAM,QAAA,EAAU;AAChC,MAAA;AAAA,IACF;AACA,IAAA,IAAA,CAAK,gBAAA,GAAmB,MAAA,CAAO,OAAA,EAAS,cAAc,CAAA;AAAA,EACxD;AAAA,EAEA,MAAM,KAAK,KAAA,EAAe;AACxB,IAAA,MAAM,GAAA,GAAM,MAAM,IAAA,CAAK,OAAA,CAAQ,MAAM,OAAA,CAAQ,MAAA,EAAQ,EAAE,CAAC,CAAA;AACxD,IAAA,MAAM,IAAA,CAAK,gBAAA,CAAiB,MAAA,CAAO,GAAG,CAAA;AACtC,IAAA,OAAO,GAAA;AAAA,EACT;AACF;AA6FO,SAAS,eAAe,OAAA,EAAyB;AACtD,EAAA,OAAO;AAAA,IACL;AAAA,MACE,OAAA,EAAS,cAAA;AAAA,MACT,UAAA,EAAY,CAAC,OAAA,KAAqB;AAChC,QAAA,IAAI,OAAA,CAAQ,MAAM,CAAA,KAAM,QAAA,EAAU;AAChC,UAAA,OAAA,CAAQ,KAAK,kCAAkC,CAAA;AAAA,QACjD;AACA,QAAA;AAAA,MACF;AAAA,KACF;AAAA,IACA;AAAA,MACE,OAAA,EAAS,YAAA;AAAA,MACT,YAAY,CAAC,OAAA,KAAqB,IAAI,cAAA,CAAe,SAAS,OAAO;AAAA;AACvE,GACF;AACF;;;;"}

package/dist/services/mmorpg.d.ts

@@ -4,17 +4,23 @@ import { RpgClientEngine } from '../RpgClientEngine';
 import { AbstractWebsocket } from './AbstractSocket';
 import { UpdateMapService } from '@rpgjs/common';
 interface MmorpgOptions {
-    host: string;
+    host?: string;
 }
 declare class BridgeWebsocket extends AbstractWebsocket {
     protected context: Context;
     private options;
     private socket;
-    constructor(context: Context, options: MmorpgOptions);
-    connection(): Promise<void>;
+    private privateId;
+    private pendingOn;
+    constructor(context: Context, options?: MmorpgOptions);
+    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>;
 }
 declare class UpdateMapStandaloneService extends UpdateMapService {
     protected context: Context;
@@ -22,7 +28,13 @@ declare class UpdateMapStandaloneService extends UpdateMapService {
     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,84 @@
+import { connectionRoom } from '../node_modules/.pnpm/@signe_sync@2.8.2/node_modules/@signe/sync/dist/client/index.js';
+import { RpgGui } from '../Gui/Gui.js';
+import { RpgClientEngine } from '../RpgClientEngine.js';
+import { WebSocketToken, AbstractWebsocket } from './AbstractSocket.js';
+import { UpdateMapToken, UpdateMapService } from '@rpgjs/common';
+import { provideKeyboardControls } from './keyboardControls.js';
+import { provideSaveClient } from './save.js';
+
+class BridgeWebsocket extends AbstractWebsocket {
+  constructor(context, options = {}) {
+    super(context);
+    this.context = context;
+    this.options = options;
+    this.pendingOn = [];
+    const id = localStorage.getItem("rpgjs-user-id") || crypto.randomUUID();
+    localStorage.setItem("rpgjs-user-id", id);
+    this.privateId = id;
+  }
+  async connection(listeners) {
+    class Room {
+    }
+    const instance = new Room();
+    this.socket = await connectionRoom({
+      host: this.options.host || window.location.host,
+      room: "lobby-1",
+      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 }) {
+    this.socket.conn.updateProperties({
+      room,
+      id: this.privateId,
+      host: this.options.host
+    });
+  }
+  async reconnect(listeners) {
+    this.socket.conn.reconnect();
+  }
+}
+class UpdateMapStandaloneService 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
+  ];
+}
+
+export { provideMmorpg };
+//# sourceMappingURL=mmorpg.js.map

package/dist/services/mmorpg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmorpg.js","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, WebSocketToken } from \"./AbstractSocket\";\nimport { UpdateMapService, UpdateMapToken } from \"@rpgjs/common\";\nimport { provideKeyboardControls } from \"./keyboardControls\";\nimport { provideSaveClient } from \"./save\";\n\ninterface MmorpgOptions {\n    host?: string;\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\n  constructor(protected context: Context, private options: MmorpgOptions = {}) {\n    super(context);\n    const id = localStorage.getItem(\"rpgjs-user-id\") || crypto.randomUUID()\n    localStorage.setItem(\"rpgjs-user-id\", id)\n    this.privateId = id\n  }\n\n  async connection(listeners?: (data: any) => void) {\n    // tmp\n    class Room {\n        \n    }\n    const instance = new Room()\n    this.socket = await connectionRoom({\n        host: this.options.host || window.location.host,\n        room: \"lobby-1\",\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 }: { room: any }) {\n    this.socket.conn.updateProperties({\n      room: room,\n      id: this.privateId,\n      host: this.options.host\n    })\n  }\n\n  async reconnect(listeners?: (data: any) => void) {\n   this.socket.conn.reconnect()\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    // nothing\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"],"names":[],"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,69 @@
+import { inject } from '../core/inject.js';
+import { WebSocketToken } from './AbstractSocket.js';
+
+const SaveClientToken = "SaveClientToken";
+class SaveClientService {
+  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
+  };
+}
+
+export { SaveClientService, SaveClientToken, provideSaveClient };
+//# sourceMappingURL=save.js.map

package/dist/services/save.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.js","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"],"names":[],"mappings":";;;AAIO,MAAM,eAAA,GAAkB;AA8BxB,MAAM,iBAAA,CAAkB;AAAA,EAAxB,WAAA,GAAA;AACL,IAAA,IAAA,CAAQ,SAAA,GAA+B,OAAO,cAAc,CAAA;AAC5D,IAAA,IAAA,CAAQ,OAAA,uBAA2C,GAAA,EAAI;AACvD,IAAA,IAAA,CAAQ,cAAA,GAAiB,CAAA;AAAA,EAAA;AAAA,EAEzB,UAAA,GAAa;AACX,IAAA,MAAM,iBAAiB,CAAC,IAAA,KAAyB,KAAK,cAAA,CAAe,IAAA,CAAK,WAAW,IAAI,CAAA;AACzF,IAAA,MAAM,iBAAiB,CAAC,IAAA,KAAyB,KAAK,cAAA,CAAe,IAAA,CAAK,WAAW,IAAI,CAAA;AACzF,IAAA,MAAM,iBAAiB,CAAC,IAAA,KAAyB,KAAK,cAAA,CAAe,IAAA,CAAK,WAAW,IAAI,CAAA;AACzF,IAAA,MAAM,eAAA,GAAkB,CAAC,IAAA,KAA0B,IAAA,CAAK,cAAc,IAAA,CAAK,SAAA,EAAW,KAAK,OAAO,CAAA;AAClG,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,kBAAA,EAAoB,cAAc,CAAA;AACrD,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,kBAAA,EAAoB,cAAc,CAAA;AACrD,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,kBAAA,EAAoB,cAAc,CAAA;AACrD,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,YAAA,EAAc,eAAe,CAAA;AAChD,IAAA,IAAA,CAAK,SAAA,CAAU,EAAA,CAAG,kBAAA,EAAoB,cAAc,CAAA;AACpD,IAAA,IAAA,CAAK,SAAA,CAAU,EAAA,CAAG,kBAAA,EAAoB,cAAc,CAAA;AACpD,IAAA,IAAA,CAAK,SAAA,CAAU,EAAA,CAAG,kBAAA,EAAoB,cAAc,CAAA;AACpD,IAAA,IAAA,CAAK,SAAA,CAAU,EAAA,CAAG,YAAA,EAAc,eAAe,CAAA;AAAA,EACjD;AAAA,EAEA,SAAA,GAAmC;AACjC,IAAA,OAAO,IAAA,CAAK,OAAA,CAAwB,WAAA,EAAa,EAAE,EAAE,IAAA,CAAK,CAAC,MAAA,KAAW,MAAA,CAAO,KAAK,CAAA;AAAA,EACpF;AAAA,EAEA,QAAA,CAAS,KAAA,EAAe,IAAA,GAAqB,EAAC,EAA0B;AACtE,IAAA,OAAO,IAAA,CAAK,OAAA,CAAwB,WAAA,EAAa,EAAE,KAAA,EAAO,IAAA,EAAM,CAAA,CAAE,IAAA,CAAK,CAAC,MAAA,KAAW,MAAA,CAAO,KAAK,CAAA;AAAA,EACjG;AAAA,EAEA,SAAS,KAAA,EAAiC;AACxC,IAAA,OAAO,IAAA,CAAK,OAAA,CAAwB,WAAA,EAAa,EAAE,KAAA,EAAO,CAAA,CAAE,IAAA,CAAK,CAAC,MAAA,KAAW,MAAA,CAAO,EAAE,CAAA;AAAA,EACxF;AAAA,EAEQ,OAAA,CAAW,OAAe,OAAA,EAA0C;AAC1E,IAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,EAAS,MAAA,KAAW;AACtC,MAAA,IAAI,CAAC,KAAK,SAAA,EAAW;AACnB,QAAA,IAAA,CAAK,UAAA,EAAW;AAAA,MAClB;AACA,MAAA,MAAM,SAAA,GAAY,KAAK,aAAA,EAAc;AACrC,MAAA,IAAA,CAAK,QAAQ,GAAA,CAAI,SAAA,EAAW,EAAE,OAAA,EAAS,QAAQ,CAAA;AAC/C,MAAA,IAAA,CAAK,WAAW,IAAA,CAAK,KAAA,EAAO,EAAE,SAAA,EAAW,GAAG,SAAS,CAAA;AAAA,IACvD,CAAC,CAAA;AAAA,EACH;AAAA,EAEQ,cAAA,CAAe,WAAmB,MAAA,EAAa;AACrD,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAI,SAAS,CAAA;AAC1C,IAAA,IAAI,CAAC,OAAA,EAAS;AACd,IAAA,IAAA,CAAK,OAAA,CAAQ,OAAO,SAAS,CAAA;AAC7B,IAAA,OAAA,CAAQ,QAAQ,MAAM,CAAA;AAAA,EACxB;AAAA,EAEQ,aAAA,CAAc,WAAmB,OAAA,EAAiB;AACxD,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAI,SAAS,CAAA;AAC1C,IAAA,IAAI,CAAC,OAAA,EAAS;AACd,IAAA,IAAA,CAAK,OAAA,CAAQ,OAAO,SAAS,CAAA;AAC7B,IAAA,OAAA,CAAQ,MAAA,CAAO,IAAI,KAAA,CAAM,OAAO,CAAC,CAAA;AAAA,EACnC;AAAA,EAEQ,aAAA,GAAwB;AAC9B,IAAA,IAAA,CAAK,cAAA,IAAkB,CAAA;AACvB,IAAA,OAAO,GAAG,IAAA,CAAK,GAAA,EAAK,CAAA,CAAA,EAAI,KAAK,cAAc,CAAA,CAAA;AAAA,EAC7C;AACF;AAEO,SAAS,iBAAA,GAAoB;AAClC,EAAA,OAAO;AAAA,IACL,OAAA,EAAS,iBAAA;AAAA,IACT,QAAA,EAAU;AAAA,GACZ;AACF;;;;"}

package/dist/services/standalone.d.ts

@@ -3,26 +3,88 @@ 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;
+    /**
+     * 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({ room }: {
         room: any;
     }): 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;