@rpgjs/testing 4.3.0 → 5.0.0-alpha.25

package/dist/index.d.ts

@@ -0,0 +1,239 @@
+import { Provider } from '@signe/di';
+import { RpgClientEngine, RpgClient } from '@rpgjs/client';
+import { RpgServer, RpgPlayer } from '@rpgjs/server';
+/**
+ * Provides a default map loader for testing environments
+ *
+ * This function returns a `provideLoadMap` provider that creates mock maps
+ * with default dimensions (1024x768) and a minimal component. It's automatically
+ * used by `testing()` if no custom `provideLoadMap` is provided in `clientConfig.providers`.
+ *
+ * @returns A provider function that can be used with `provideLoadMap`
+ * @example
+ * ```ts
+ * // Used automatically by testing()
+ * const fixture = await testing([myModule])
+ *
+ * // Or use directly in clientConfig
+ * const fixture = await testing([myModule], {
+ *   providers: [provideTestingLoadMap()]
+ * })
+ * ```
+ */
+export declare function provideTestingLoadMap(): {
+    provide: string;
+    useFactory: (context: import('@signe/di').Context) => void;
+}[];
+/**
+ * Testing utility function to set up server and client instances for unit testing
+ *
+ * This function creates a test environment with both server and client instances,
+ * allowing you to test player interactions, server hooks, and game mechanics.
+ *
+ * @param modules - Array of modules that can be either:
+ *   - Direct module objects: { server: RpgServer, client: RpgClient }
+ *   - Providers returned by createModule(): Provider[] with meta.server/client and useValue
+ * @param clientConfig - Optional client configuration
+ * @param serverConfig - Optional server configuration
+ * @returns Testing fixture with createClient method
+ * @example
+ * ```ts
+ * // Using direct modules
+ * const fixture = await testing([{
+ *   server: serverModule,
+ *   client: clientModule
+ * }])
+ *
+ * // Using createModule
+ * const myModule = createModule('MyModule', [{
+ *   server: serverModule,
+ *   client: clientModule
+ * }])
+ * const fixture = await testing(myModule)
+ * ```
+ */
+export declare function testing(modules?: ({
+    server?: RpgServer;
+    client?: RpgClient;
+} | Provider)[], clientConfig?: any, serverConfig?: any): Promise<{
+    createClient(): Promise<{
+        readonly server: any;
+        socket: any;
+        client: RpgClientEngine<any>;
+        playerId: string;
+        readonly player: RpgPlayer;
+        /**
+         * Wait for player to be on a specific map
+         *
+         * This utility function polls the player's current map until it matches
+         * the expected map ID, or throws an error if the timeout is exceeded.
+         *
+         * @param expectedMapId - The expected map ID (without 'map-' prefix, e.g. 'map1')
+         * @param timeout - Maximum time to wait in milliseconds (default: 5000)
+         * @returns Promise that resolves when player is on the expected map
+         * @throws Error if timeout is exceeded
+         * @example
+         * ```ts
+         * const client = await fixture.createClient()
+         * await client.waitForMapChange('map1')
+         * ```
+         */
+        waitForMapChange(expectedMapId: string, timeout?: number): Promise<RpgPlayer>;
+        /**
+         * Manually trigger a game tick for processing inputs and physics
+         *
+         * This method is a convenience wrapper around the exported nextTick() function.
+         *
+         * @param timestamp - Optional timestamp to use for the tick (default: Date.now())
+         * @returns Promise that resolves when the tick is complete
+         *
+         * @example
+         * ```ts
+         * const client = await fixture.createClient()
+         *
+         * // Manually advance the game by one tick
+         * await client.nextTick()
+         * ```
+         */
+        nextTick(timestamp?: number): Promise<void>;
+    }>;
+    /**
+     * Clear all server, client instances and reset the DOM
+     *
+     * This method should be called in afterEach to clean up test state.
+     * It destroys all created client instances, clears the server, and resets the DOM.
+     *
+     * @example
+     * ```ts
+     * const fixture = await testing([myModule])
+     *
+     * afterEach(() => {
+     *   fixture.clear()
+     * })
+     * ```
+     */
+    clear(): void;
+}>;
+/**
+ * Clear all caches and reset test state
+ *
+ * This function should be called after the end of each test to clean up
+ * all server and client instances, clear caches, and reset the DOM.
+ *
+ * ## Design
+ *
+ * Cleans up all created fixtures, client engines, server instances, and resets
+ * the DOM to a clean state. This ensures no state leaks between tests.
+ *
+ * @returns void
+ *
+ * @example
+ * ```ts
+ * import { clear } from '@rpgjs/testing'
+ *
+ * afterEach(() => {
+ *   clear()
+ * })
+ * ```
+ */
+export declare function clear(): void;
+/**
+ * Manually trigger a game tick for processing inputs and physics
+ *
+ * This function allows you to manually advance the game by one tick.
+ * It performs the following operations:
+ * 1. On server: processes pending inputs and advances physics
+ * 2. Server sends data to client
+ * 3. Client retrieves data and performs inputs (move, etc.) and server reconciliation
+ * 4. A tick is performed on the client
+ * 5. A tick is performed on VueJS (if Vue is used)
+ *
+ * @param client - The RpgClientEngine instance
+ * @param timestamp - Optional timestamp to use for the tick (default: Date.now())
+ * @returns Promise that resolves when the tick is complete
+ *
+ * @example
+ * ```ts
+ * import { nextTick } from '@rpgjs/testing'
+ *
+ * const client = await fixture.createClient()
+ *
+ * // Manually advance the game by one tick
+ * await nextTick(client.client, Date.now())
+ * ```
+ */
+export declare function nextTick(client: RpgClientEngine, timestamp?: number): Promise<void>;
+/**
+ * Wait for synchronization to complete on the client
+ *
+ * This function waits for the client to receive and process synchronization data
+ * from the server. It monitors the `playersReceived$` and `eventsReceived$` observables
+ * in the RpgClientEngine to determine when synchronization is complete.
+ *
+ * ## Design
+ *
+ * - Uses `combineLatest` to wait for both `playersReceived$` and `eventsReceived$` to be `true`
+ * - Filters to only proceed when both are `true`
+ * - Includes a timeout to prevent waiting indefinitely
+ * - Resets the observables to `false` before waiting to ensure we catch the next sync
+ *
+ * @param client - The RpgClientEngine instance
+ * @param timeout - Maximum time to wait in milliseconds (default: 1000ms)
+ * @returns Promise that resolves when synchronization is complete
+ * @throws Error if timeout is exceeded
+ *
+ * @example
+ * ```ts
+ * import { waitForSync } from '@rpgjs/testing'
+ *
+ * const client = await fixture.createClient()
+ *
+ * // Wait for sync to complete
+ * await waitForSync(client.client)
+ *
+ * // Now you can safely test client-side state
+ * expect(client.client.sceneMap.players()).toBeDefined()
+ * ```
+ */
+export declare function waitForSync(client: RpgClientEngine, timeout?: number): Promise<void>;
+/**
+ * Wait for complete synchronization cycle (server sync + client receive)
+ *
+ * This function performs a complete synchronization cycle:
+ * 1. Triggers a game tick using `nextTick()` which calls `syncChanges()` on all players
+ * 2. Waits for the client to receive and process the synchronization data
+ *
+ * This is useful when you need to ensure that server-side changes are fully
+ * synchronized to the client before testing client-side state.
+ *
+ * ## Design
+ *
+ * - Calls `nextTick()` to trigger server-side sync
+ * - Waits for client to receive sync data using `waitForSync()`
+ * - Ensures complete synchronization cycle is finished
+ *
+ * @param player - The RpgPlayer instance (optional, will sync all players if not provided)
+ * @param client - The RpgClientEngine instance
+ * @param timeout - Maximum time to wait in milliseconds (default: 1000ms)
+ * @returns Promise that resolves when synchronization is complete
+ * @throws Error if timeout is exceeded
+ *
+ * @example
+ * ```ts
+ * import { waitForSyncComplete } from '@rpgjs/testing'
+ *
+ * const client = await fixture.createClient()
+ * const player = client.player
+ *
+ * // Make a server-side change
+ * player.addItem('potion', 5)
+ *
+ * // Wait for sync to complete
+ * await waitForSyncComplete(player, client.client)
+ *
+ * // Now you can safely test client-side state
+ * const clientPlayer = client.client.sceneMap.players()[player.id]
+ * expect(clientPlayer.items()).toBeDefined()
+ * ```
+ */
+export declare function waitForSyncComplete(player: RpgPlayer | null, client: RpgClientEngine, timeout?: number): Promise<void>;

package/dist/index.js

@@ -0,0 +1,315 @@
+import { mergeConfig } from './node_modules/.pnpm/@signe_di@2.6.0/node_modules/@signe/di/dist/index.js';
+import { provideLoadMap, LoadMapToken, startGame, provideRpg, provideClientGlobalConfig, provideClientModules, inject, WebSocketToken, RpgClientEngine, clearInject } from '@rpgjs/client';
+import { createServer, provideServerModules, clearInject as clearInject$1 } from '@rpgjs/server';
+import { h, Container } from 'canvasengine';
+import { combineLatest, filter, take, firstValueFrom } from 'rxjs';
+
+function provideTestingLoadMap() {
+  return provideLoadMap((id) => {
+    return {
+      id,
+      data: {
+        width: 1024,
+        height: 768,
+        hitboxes: [],
+        params: {}
+      },
+      component: h(Container),
+      width: 1024,
+      height: 768
+    };
+  });
+}
+function normalizeModules(modules) {
+  if (!modules || modules.length === 0) {
+    return { serverModules: [], clientModules: [] };
+  }
+  const isProviderArray = modules.some(
+    (item) => item && typeof item === "object" && "meta" in item && "useValue" in item
+  );
+  const serverModules = [];
+  const clientModules = [];
+  if (!isProviderArray) {
+    modules.forEach((module) => {
+      if (module && typeof module === "object") {
+        if (module.server) {
+          serverModules.push(module.server);
+        }
+        if (module.client) {
+          clientModules.push(module.client);
+        }
+      }
+    });
+    return { serverModules, clientModules };
+  }
+  const seenUseValues = /* @__PURE__ */ new Set();
+  modules.forEach((provider) => {
+    if (!provider || typeof provider !== "object" || !("meta" in provider) || !("useValue" in provider)) {
+      return;
+    }
+    const { useValue } = provider;
+    if (seenUseValues.has(useValue)) {
+      return;
+    }
+    if (useValue && typeof useValue === "object" && ("server" in useValue || "client" in useValue)) {
+      seenUseValues.add(useValue);
+      if (useValue.server) {
+        serverModules.push(useValue.server);
+      }
+      if (useValue.client) {
+        clientModules.push(useValue.client);
+      }
+    }
+  });
+  return { serverModules, clientModules };
+}
+const globalFixtures = [];
+async function testing(modules = [], clientConfig = {}, serverConfig = {}) {
+  const { serverModules, clientModules } = normalizeModules(modules);
+  const serverClass = createServer({
+    ...serverConfig,
+    providers: [
+      provideServerModules(serverModules),
+      ...serverConfig.providers || []
+    ]
+  });
+  return {
+    async createClient() {
+      const hasLoadMap = clientConfig.providers?.some((provider) => {
+        if (Array.isArray(provider)) {
+          return provider.some((p) => p?.provide === LoadMapToken);
+        }
+        return provider?.provide === LoadMapToken;
+      }) || false;
+      const context = await startGame(
+        mergeConfig({
+          ...clientConfig,
+          providers: [
+            provideClientGlobalConfig({}),
+            ...hasLoadMap ? [] : [provideTestingLoadMap()],
+            // Add only if not already provided
+            provideClientModules(clientModules),
+            ...clientConfig.providers || []
+          ]
+        }, {
+          providers: [provideRpg(serverClass)]
+        })
+      );
+      const websocket = inject(WebSocketToken);
+      const clientEngine = inject(RpgClientEngine);
+      const playerId = clientEngine.playerId;
+      if (!playerId) {
+        throw new Error("Player ID is not available");
+      }
+      const playerIdString = playerId;
+      const server = websocket.getServer();
+      setTimeout(() => {
+        try {
+          const serverMap = server?.subRoom;
+          if (serverMap && typeof serverMap.setAutoTick === "function") {
+            serverMap.setAutoTick(false);
+          }
+        } catch (error) {
+        }
+      }, 0);
+      const clientInstance = {
+        context,
+        clientEngine,
+        websocket,
+        server
+      };
+      globalFixtures.push(clientInstance);
+      return {
+        get server() {
+          return websocket.getServer();
+        },
+        socket: websocket.getSocket(),
+        client: clientEngine,
+        playerId: playerIdString,
+        get player() {
+          return this.server.subRoom.players()[playerIdString];
+        },
+        /**
+         * Wait for player to be on a specific map
+         * 
+         * This utility function polls the player's current map until it matches
+         * the expected map ID, or throws an error if the timeout is exceeded.
+         * 
+         * @param expectedMapId - The expected map ID (without 'map-' prefix, e.g. 'map1')
+         * @param timeout - Maximum time to wait in milliseconds (default: 5000)
+         * @returns Promise that resolves when player is on the expected map
+         * @throws Error if timeout is exceeded
+         * @example
+         * ```ts
+         * const client = await fixture.createClient()
+         * await client.waitForMapChange('map1')
+         * ```
+         */
+        async waitForMapChange(expectedMapId, timeout = 5e3) {
+          const startTime = Date.now();
+          while (Date.now() - startTime < timeout) {
+            const currentMap2 = this.player.getCurrentMap();
+            if (currentMap2?.id === expectedMapId) {
+              return this.player;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+          }
+          const currentMap = this.player.getCurrentMap();
+          throw new Error(
+            `Timeout: Player did not reach map ${expectedMapId} within ${timeout}ms. Current map: ${currentMap?.id || "null"}`
+          );
+        },
+        /**
+         * Manually trigger a game tick for processing inputs and physics
+         * 
+         * This method is a convenience wrapper around the exported nextTick() function.
+         * 
+         * @param timestamp - Optional timestamp to use for the tick (default: Date.now())
+         * @returns Promise that resolves when the tick is complete
+         * 
+         * @example
+         * ```ts
+         * const client = await fixture.createClient()
+         * 
+         * // Manually advance the game by one tick
+         * await client.nextTick()
+         * ```
+         */
+        async nextTick(timestamp) {
+          return nextTick(this.client);
+        }
+      };
+    },
+    /**
+     * Clear all server, client instances and reset the DOM
+     * 
+     * This method should be called in afterEach to clean up test state.
+     * It destroys all created client instances, clears the server, and resets the DOM.
+     * 
+     * @example
+     * ```ts
+     * const fixture = await testing([myModule])
+     * 
+     * afterEach(() => {
+     *   fixture.clear()
+     * })
+     * ```
+     */
+    clear() {
+      clear();
+    }
+  };
+}
+function clear() {
+  for (const client of globalFixtures) {
+    try {
+      if (client.clientEngine && typeof client.clientEngine.clear === "function") {
+        client.clientEngine.clear();
+      }
+      const serverMap = client.server?.subRoom;
+      if (serverMap && typeof serverMap.clear === "function") {
+        serverMap.clear();
+      }
+    } catch (error) {
+      console.warn("Error during cleanup:", error);
+    }
+  }
+  globalFixtures.length = 0;
+  try {
+    clearInject();
+  } catch (error) {
+    console.warn("Error clearing client inject:", error);
+  }
+  try {
+    clearInject$1();
+  } catch (error) {
+    console.warn("Error clearing server inject:", error);
+  }
+  if (typeof window !== "undefined" && window.document) {
+    window.document.body.innerHTML = `<div id="rpg"></div>`;
+  }
+}
+async function nextTick(client, timestamp) {
+  if (!client) {
+    throw new Error("nextTick: client parameter is required");
+  }
+  const delta = 16;
+  const websocket = client.webSocket;
+  if (!websocket) {
+    throw new Error("nextTick: websocket not found in client");
+  }
+  const server = websocket.getServer();
+  if (!server) {
+    throw new Error("nextTick: server not found");
+  }
+  const serverMap = server.subRoom;
+  if (!serverMap) {
+    return;
+  }
+  for (const player of serverMap.getPlayers()) {
+    if (player.pendingInputs && player.pendingInputs.length > 0) {
+      await serverMap.processInput(player.id);
+    }
+  }
+  if (typeof serverMap.runFixedTicks === "function") {
+    serverMap.runFixedTicks(delta);
+  }
+  for (const player of serverMap.getPlayers()) {
+    if (player && typeof player.syncChanges === "function") {
+      player.syncChanges();
+    }
+  }
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const sceneMap = client.sceneMap;
+  if (sceneMap && typeof sceneMap.stepPredictionTick === "function") {
+    sceneMap.stepPredictionTick();
+  }
+}
+async function waitForSync(client, timeout = 1e3) {
+  if (!client) {
+    throw new Error("waitForSync: client parameter is required");
+  }
+  const playersReceived$ = client.playersReceived$;
+  const eventsReceived$ = client.eventsReceived$;
+  if (!playersReceived$ || !eventsReceived$) {
+    throw new Error("waitForSync: playersReceived$ or eventsReceived$ not found in client");
+  }
+  const playersAlreadyTrue = playersReceived$.getValue ? playersReceived$.getValue() === true : false;
+  const eventsAlreadyTrue = eventsReceived$.getValue ? eventsReceived$.getValue() === true : false;
+  if (playersAlreadyTrue && eventsAlreadyTrue) {
+    return;
+  }
+  playersReceived$.next(false);
+  eventsReceived$.next(false);
+  const syncComplete$ = combineLatest([
+    playersReceived$.pipe(filter((received) => received === true)),
+    eventsReceived$.pipe(filter((received) => received === true))
+  ]).pipe(
+    take(1)
+  );
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(new Error(`waitForSync: Timeout after ${timeout}ms. Synchronization did not complete.`));
+    }, timeout);
+  });
+  await Promise.race([
+    firstValueFrom(syncComplete$),
+    timeoutPromise
+  ]);
+}
+async function waitForSyncComplete(player, client, timeout = 1e3) {
+  if (!client) {
+    throw new Error("waitForSyncComplete: client parameter is required");
+  }
+  const playersReceived$ = client.playersReceived$;
+  const eventsReceived$ = client.eventsReceived$;
+  if (playersReceived$ && eventsReceived$) {
+    playersReceived$.next(false);
+    eventsReceived$.next(false);
+  }
+  await nextTick(client);
+  await waitForSync(client, timeout);
+}
+
+export { clear, nextTick, provideTestingLoadMap, testing, waitForSync, waitForSyncComplete };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { mergeConfig, Provider } from \"@signe/di\";\nimport { provideRpg, startGame, provideClientModules, provideLoadMap, provideClientGlobalConfig, inject, WebSocketToken, AbstractWebsocket, RpgClientEngine, RpgClient, LoadMapToken } from \"@rpgjs/client\";\nimport { createServer, provideServerModules, RpgServer, RpgPlayer } from \"@rpgjs/server\";\nimport { h, Container } from \"canvasengine\";\nimport { clearInject as clearClientInject } from \"@rpgjs/client\";\nimport { clearInject as clearServerInject } from \"@rpgjs/server\";\nimport { combineLatest, filter, take, race, timer, firstValueFrom } from \"rxjs\";\n\n/**\n * Provides a default map loader for testing environments\n * \n * This function returns a `provideLoadMap` provider that creates mock maps\n * with default dimensions (1024x768) and a minimal component. It's automatically\n * used by `testing()` if no custom `provideLoadMap` is provided in `clientConfig.providers`.\n * \n * @returns A provider function that can be used with `provideLoadMap`\n * @example\n * ```ts\n * // Used automatically by testing()\n * const fixture = await testing([myModule])\n * \n * // Or use directly in clientConfig\n * const fixture = await testing([myModule], {\n *   providers: [provideTestingLoadMap()]\n * })\n * ```\n */\nexport function provideTestingLoadMap() {\n    return provideLoadMap((id: string) => {\n        return {\n            id,\n            data: {\n                width: 1024,\n                height: 768,\n                hitboxes: [],\n                params: {}\n            },\n            component: h(Container),\n            width: 1024,\n            height: 768,\n        }\n    })\n}\n\n/**\n * Normalizes modules input to extract server/client modules from createModule providers or direct module objects\n * \n * @param modules - Array of modules that can be either:\n *   - Direct module objects: { server: RpgServer, client: RpgClient }\n *   - Providers returned by createModule(): Provider[] with meta.server/client and useValue\n * @returns Object with separate arrays for server and client modules\n * @example\n * ```ts\n * // Direct modules\n * normalizeModules([{ server: serverModule, client: clientModule }])\n * \n * // createModule providers\n * const providers = createModule('MyModule', [{ server: serverModule, client: clientModule }])\n * normalizeModules(providers)\n * ```\n */\nfunction normalizeModules(modules: any[]): { serverModules: RpgServer[], clientModules: RpgClient[] } {\n    if (!modules || modules.length === 0) {\n        return { serverModules: [], clientModules: [] }\n    }\n\n    // Check if first item is a provider (has meta and useValue properties)\n    const isProviderArray = modules.some((item: any) => \n        item && typeof item === 'object' && 'meta' in item && 'useValue' in item\n    )\n\n    const serverModules: RpgServer[] = []\n    const clientModules: RpgClient[] = []\n\n    if (!isProviderArray) {\n        // Direct module objects, extract server and client separately\n        modules.forEach((module: any) => {\n            if (module && typeof module === 'object') {\n                if (module.server) {\n                    serverModules.push(module.server)\n                }\n                if (module.client) {\n                    clientModules.push(module.client)\n                }\n            }\n        })\n        return { serverModules, clientModules }\n    }\n\n    // Extract modules from createModule providers\n    // createModule returns providers where useValue contains the original { server, client } object\n    // We need to group providers by their useValue to reconstruct the original modules\n    const seenUseValues = new Set<any>()\n\n    modules.forEach((provider: any) => {\n        if (!provider || typeof provider !== 'object' || !('meta' in provider) || !('useValue' in provider)) {\n            return\n        }\n\n        const { useValue } = provider\n        \n        // Skip if we've already processed this useValue (same module, different provider for server/client)\n        if (seenUseValues.has(useValue)) {\n            return\n        }\n\n        // Check if useValue has server or client properties (it's a module object)\n        if (useValue && typeof useValue === 'object' && ('server' in useValue || 'client' in useValue)) {\n            seenUseValues.add(useValue)\n            if (useValue.server) {\n                serverModules.push(useValue.server)\n            }\n            if (useValue.client) {\n                clientModules.push(useValue.client)\n            }\n        }\n    })\n\n    return { serverModules, clientModules }\n}\n\n// Global storage for all created fixtures and clients (for clear() function)\nconst globalFixtures: Array<{\n    context: any;\n    clientEngine: RpgClientEngine;\n    websocket: AbstractWebsocket;\n    server?: any;\n}> = []\n\n/**\n * Testing utility function to set up server and client instances for unit testing\n * \n * This function creates a test environment with both server and client instances,\n * allowing you to test player interactions, server hooks, and game mechanics.\n * \n * @param modules - Array of modules that can be either:\n *   - Direct module objects: { server: RpgServer, client: RpgClient }\n *   - Providers returned by createModule(): Provider[] with meta.server/client and useValue\n * @param clientConfig - Optional client configuration\n * @param serverConfig - Optional server configuration\n * @returns Testing fixture with createClient method\n * @example\n * ```ts\n * // Using direct modules\n * const fixture = await testing([{\n *   server: serverModule,\n *   client: clientModule\n * }])\n * \n * // Using createModule\n * const myModule = createModule('MyModule', [{\n *   server: serverModule,\n *   client: clientModule\n * }])\n * const fixture = await testing(myModule)\n * ```\n */\nexport async function testing(\n    modules: ({ server?: RpgServer, client?: RpgClient } | Provider)[] = [], \n    clientConfig: any = {}, \n    serverConfig: any = {}\n) {\n    // Normalize modules to extract server/client from providers if needed\n    const { serverModules, clientModules } = normalizeModules(modules as any[])\n    \n    const serverClass = createServer({\n        ...serverConfig,\n        providers: [\n            provideServerModules(serverModules),\n            ...(serverConfig.providers || [])\n        ]\n    })\n    \n    // Store created instances for cleanup\n    const createdClients: Array<{\n        context: any;\n        clientEngine: RpgClientEngine;\n        websocket: AbstractWebsocket;\n        server?: any;\n    }> = []\n    \n    return {\n        async createClient() {\n            // Check if LoadMapToken is already provided in clientConfig.providers\n            // (provideLoadMap returns an array with LoadMapToken)\n            const hasLoadMap = clientConfig.providers?.some((provider: any) => {\n                if (Array.isArray(provider)) {\n                    return provider.some((p: any) => p?.provide === LoadMapToken)\n                }\n                return provider?.provide === LoadMapToken\n            }) || false\n            \n            const context = await startGame(\n                mergeConfig({\n                    ...clientConfig,\n                    providers: [\n                        provideClientGlobalConfig({}),\n                        ...(hasLoadMap ? [] : [provideTestingLoadMap()]), // Add only if not already provided\n                        provideClientModules(clientModules),\n                        ...(clientConfig.providers || [])\n                    ]\n                }, {\n                    providers: [provideRpg(serverClass)],\n                })\n            )\n            const websocket = inject<AbstractWebsocket>(WebSocketToken) as any\n            const clientEngine = inject<RpgClientEngine>(RpgClientEngine)\n            const playerId = clientEngine.playerId\n            if (!playerId) {\n                throw new Error('Player ID is not available')\n            }\n            const playerIdString: string = playerId\n            \n            // Get server instance\n            const server = websocket.getServer()\n            \n            // Disable auto tick for unit tests (manual control via nextTick)\n            // The map will be available after the player connects, so we disable it asynchronously\n            setTimeout(() => {\n                try {\n                    const serverMap = server?.subRoom as any\n                    if (serverMap && typeof serverMap.setAutoTick === 'function') {\n                        serverMap.setAutoTick(false)\n                    }\n                } catch (error) {\n                    // Ignore errors if map is not ready yet\n                }\n            }, 0)\n            \n            // Store instance for cleanup (both locally and globally)\n            const clientInstance = {\n                context,\n                clientEngine,\n                websocket,\n                server\n            }\n            createdClients.push(clientInstance)\n            globalFixtures.push(clientInstance)\n            \n            return {\n                get server() {\n                    return  websocket.getServer()\n                },\n                socket: websocket.getSocket(),\n                client: clientEngine,\n                playerId: playerIdString,\n                get player(): RpgPlayer {\n                    return this.server.subRoom.players()[playerIdString] as RpgPlayer\n                },\n                /**\n                 * Wait for player to be on a specific map\n                 * \n                 * This utility function polls the player's current map until it matches\n                 * the expected map ID, or throws an error if the timeout is exceeded.\n                 * \n                 * @param expectedMapId - The expected map ID (without 'map-' prefix, e.g. 'map1')\n                 * @param timeout - Maximum time to wait in milliseconds (default: 5000)\n                 * @returns Promise that resolves when player is on the expected map\n                 * @throws Error if timeout is exceeded\n                 * @example\n                 * ```ts\n                 * const client = await fixture.createClient()\n                 * await client.waitForMapChange('map1')\n                 * ```\n                 */\n                async waitForMapChange(expectedMapId: string, timeout = 5000): Promise<RpgPlayer> {\n                    const startTime = Date.now()\n\n                    while (Date.now() - startTime < timeout) {\n                        const currentMap = this.player.getCurrentMap()\n                        if (currentMap?.id === expectedMapId) {\n                            return this.player\n                        }\n                        await new Promise(resolve => setTimeout(resolve, 50)) // Wait 50ms before next check\n                    }\n                    \n                    const currentMap = this.player.getCurrentMap()\n                    throw new Error(\n                        `Timeout: Player did not reach map ${expectedMapId} within ${timeout}ms. ` +\n                        `Current map: ${currentMap?.id || 'null'}`\n                    )\n                },\n                /**\n                 * Manually trigger a game tick for processing inputs and physics\n                 * \n                 * This method is a convenience wrapper around the exported nextTick() function.\n                 * \n                 * @param timestamp - Optional timestamp to use for the tick (default: Date.now())\n                 * @returns Promise that resolves when the tick is complete\n                 * \n                 * @example\n                 * ```ts\n                 * const client = await fixture.createClient()\n                 * \n                 * // Manually advance the game by one tick\n                 * await client.nextTick()\n                 * ```\n                 */\n                async nextTick(timestamp?: number): Promise<void> {\n                    return nextTick(this.client, timestamp)\n                }\n            }\n        },\n        /**\n         * Clear all server, client instances and reset the DOM\n         * \n         * This method should be called in afterEach to clean up test state.\n         * It destroys all created client instances, clears the server, and resets the DOM.\n         * \n         * @example\n         * ```ts\n         * const fixture = await testing([myModule])\n         * \n         * afterEach(() => {\n         *   fixture.clear()\n         * })\n         * ```\n         */\n        clear() {\n            // Use the global clear function\n            clear()\n        }\n    }\n}\n\n/**\n * Clear all caches and reset test state\n * \n * This function should be called after the end of each test to clean up\n * all server and client instances, clear caches, and reset the DOM.\n * \n * ## Design\n * \n * Cleans up all created fixtures, client engines, server instances, and resets\n * the DOM to a clean state. This ensures no state leaks between tests.\n * \n * @returns void\n * \n * @example\n * ```ts\n * import { clear } from '@rpgjs/testing'\n * \n * afterEach(() => {\n *   clear()\n * })\n * ```\n */\nexport function clear(): void {\n    // Clean up all created client and server instances from all fixtures\n    for (const client of globalFixtures) {\n        try {\n            // Clear client engine\n            if (client.clientEngine && typeof (client.clientEngine as any).clear === 'function') {\n                (client.clientEngine as any).clear()\n            }\n            \n            // Clear server map (subRoom)\n            const serverMap = client.server?.subRoom as any\n            if (serverMap && typeof serverMap.clear === 'function') {\n                serverMap.clear()\n            }\n        } catch (error) {\n            // Silently ignore cleanup errors\n            console.warn('Error during cleanup:', error)\n        }\n    }\n    \n    // Clear the global fixtures array\n    globalFixtures.length = 0\n    \n    // Clear client context injection\n    try {\n        clearClientInject()\n    } catch (error) {\n        console.warn('Error clearing client inject:', error)\n    }\n    \n    // Clear server context injection\n    try {\n        clearServerInject()\n    } catch (error) {\n        console.warn('Error clearing server inject:', error)\n    }\n    \n    // Reset DOM\n    if (typeof window !== 'undefined' && window.document) {\n        window.document.body.innerHTML = `<div id=\"rpg\"></div>`\n    }\n}\n\n/**\n * Manually trigger a game tick for processing inputs and physics\n * \n * This function allows you to manually advance the game by one tick.\n * It performs the following operations:\n * 1. On server: processes pending inputs and advances physics\n * 2. Server sends data to client\n * 3. Client retrieves data and performs inputs (move, etc.) and server reconciliation\n * 4. A tick is performed on the client\n * 5. A tick is performed on VueJS (if Vue is used)\n * \n * @param client - The RpgClientEngine instance\n * @param timestamp - Optional timestamp to use for the tick (default: Date.now())\n * @returns Promise that resolves when the tick is complete\n * \n * @example\n * ```ts\n * import { nextTick } from '@rpgjs/testing'\n * \n * const client = await fixture.createClient()\n * \n * // Manually advance the game by one tick\n * await nextTick(client.client, Date.now())\n * ```\n */\nexport async function nextTick(client: RpgClientEngine, timestamp?: number): Promise<void> {\n    if (!client) {\n        throw new Error('nextTick: client parameter is required')\n    }\n\n    const tickTimestamp = timestamp ?? Date.now()\n    const delta = 16 // 16ms for 60fps\n\n    // Get server instance from client context\n    const websocket = (client as any).webSocket\n    if (!websocket) {\n        throw new Error('nextTick: websocket not found in client')\n    }\n\n    const server = websocket.getServer()\n    if (!server) {\n        throw new Error('nextTick: server not found')\n    }\n\n    // Get server map (subRoom)\n    const serverMap = server.subRoom as any\n    if (!serverMap) {\n        return\n    }\n\n    // 1. On server: Process inputs for all players\n    for (const player of serverMap.getPlayers()) {\n        if (player.pendingInputs && player.pendingInputs.length > 0) {\n            await serverMap.processInput(player.id)\n        }\n    }\n\n    // 2. Run physics tick on server map\n    if (typeof serverMap.runFixedTicks === 'function') {\n        serverMap.runFixedTicks(delta)\n    }\n\n    // 3. Server sends data to client - trigger sync for all players\n    // The sync is triggered by calling syncChanges() on each player\n    for (const player of serverMap.getPlayers()) {\n        if (player && typeof (player as any).syncChanges === 'function') {\n            (player as any).syncChanges()\n        }\n    }\n\n    // 4. Client retrieves data and performs reconciliation\n    // The sync data will be received by the client through the websocket\n    // We need to wait a bit for the sync data to be processed\n    await new Promise(resolve => setTimeout(resolve, 0))\n\n    // 5. Run physics tick on client map (performs client-side prediction)\n    const sceneMap = (client as any).sceneMap\n    if (sceneMap && typeof sceneMap.stepPredictionTick === 'function') {\n        sceneMap.stepPredictionTick()\n    }\n\n    // 6. Trigger VueJS tick if Vue is used (handled by CanvasEngine internally)\n    // CanvasEngine handles this automatically through its tick system\n}\n\n/**\n * Wait for synchronization to complete on the client\n * \n * This function waits for the client to receive and process synchronization data\n * from the server. It monitors the `playersReceived$` and `eventsReceived$` observables\n * in the RpgClientEngine to determine when synchronization is complete.\n * \n * ## Design\n * \n * - Uses `combineLatest` to wait for both `playersReceived$` and `eventsReceived$` to be `true`\n * - Filters to only proceed when both are `true`\n * - Includes a timeout to prevent waiting indefinitely\n * - Resets the observables to `false` before waiting to ensure we catch the next sync\n * \n * @param client - The RpgClientEngine instance\n * @param timeout - Maximum time to wait in milliseconds (default: 1000ms)\n * @returns Promise that resolves when synchronization is complete\n * @throws Error if timeout is exceeded\n * \n * @example\n * ```ts\n * import { waitForSync } from '@rpgjs/testing'\n * \n * const client = await fixture.createClient()\n * \n * // Wait for sync to complete\n * await waitForSync(client.client)\n * \n * // Now you can safely test client-side state\n * expect(client.client.sceneMap.players()).toBeDefined()\n * ```\n */\nexport async function waitForSync(client: RpgClientEngine, timeout: number = 1000): Promise<void> {\n    if (!client) {\n        throw new Error('waitForSync: client parameter is required')\n    }\n\n    // Access private observables via type assertion\n    const playersReceived$ = (client as any).playersReceived$ as any\n    const eventsReceived$ = (client as any).eventsReceived$ as any\n\n    if (!playersReceived$ || !eventsReceived$) {\n        throw new Error('waitForSync: playersReceived$ or eventsReceived$ not found in client')\n    }\n\n    // Check if observables are already true - if so, sync has already arrived, don't reset\n    const playersAlreadyTrue = playersReceived$.getValue ? playersReceived$.getValue() === true : false;\n    const eventsAlreadyTrue = eventsReceived$.getValue ? eventsReceived$.getValue() === true : false;\n\n    // If both observables are already true, sync has already completed - return immediately\n    if (playersAlreadyTrue && eventsAlreadyTrue) {\n        return;\n    }\n\n    // Reset observables to false to ensure we catch the next sync\n    // Note: This is only needed when waitForSync is called standalone.\n    // When called from waitForSyncComplete, observables are already reset before nextTick\n    playersReceived$.next(false)\n    eventsReceived$.next(false)\n\n    // Wait for both observables to be true\n    const syncComplete$ = combineLatest([\n        playersReceived$.pipe(filter(received => received === true)),\n        eventsReceived$.pipe(filter(received => received === true))\n    ]).pipe(\n        take(1)\n    )\n\n    // Create a timeout promise\n    const timeoutPromise = new Promise<never>((_, reject) => {\n        setTimeout(() => {\n            reject(new Error(`waitForSync: Timeout after ${timeout}ms. Synchronization did not complete.`))\n        }, timeout)\n    })\n\n    // Race between sync completion and timeout\n    await Promise.race([\n        firstValueFrom(syncComplete$),\n        timeoutPromise\n    ])\n}\n\n/**\n * Wait for complete synchronization cycle (server sync + client receive)\n * \n * This function performs a complete synchronization cycle:\n * 1. Triggers a game tick using `nextTick()` which calls `syncChanges()` on all players\n * 2. Waits for the client to receive and process the synchronization data\n * \n * This is useful when you need to ensure that server-side changes are fully\n * synchronized to the client before testing client-side state.\n * \n * ## Design\n * \n * - Calls `nextTick()` to trigger server-side sync\n * - Waits for client to receive sync data using `waitForSync()`\n * - Ensures complete synchronization cycle is finished\n * \n * @param player - The RpgPlayer instance (optional, will sync all players if not provided)\n * @param client - The RpgClientEngine instance\n * @param timeout - Maximum time to wait in milliseconds (default: 1000ms)\n * @returns Promise that resolves when synchronization is complete\n * @throws Error if timeout is exceeded\n * \n * @example\n * ```ts\n * import { waitForSyncComplete } from '@rpgjs/testing'\n * \n * const client = await fixture.createClient()\n * const player = client.player\n * \n * // Make a server-side change\n * player.addItem('potion', 5)\n * \n * // Wait for sync to complete\n * await waitForSyncComplete(player, client.client)\n * \n * // Now you can safely test client-side state\n * const clientPlayer = client.client.sceneMap.players()[player.id]\n * expect(clientPlayer.items()).toBeDefined()\n * ```\n */\nexport async function waitForSyncComplete(player: RpgPlayer | null, client: RpgClientEngine, timeout: number = 1000): Promise<void> {\n    if (!client) {\n        throw new Error('waitForSyncComplete: client parameter is required')\n    }\n\n    // Reset observables BEFORE calling nextTick to ensure we catch the sync that will be sent\n    // This prevents race condition where sync arrives before we start waiting\n    const playersReceived$ = (client as any).playersReceived$ as any\n    const eventsReceived$ = (client as any).eventsReceived$ as any\n    if (playersReceived$ && eventsReceived$) {\n        playersReceived$.next(false)\n        eventsReceived$.next(false)\n    }\n\n    // Trigger sync by calling nextTick (which calls syncChanges on all players)\n    await nextTick(client)\n\n    // Wait for client to receive and process the sync\n    await waitForSync(client, timeout)\n}"],"names":["currentMap","clearClientInject","clearServerInject"],"mappings":"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"}