quake2ts 0.0.562 → 0.0.563

package/packages/test-utils/dist/index.d.ts

@@ -310,11 +310,14 @@ declare function createMockImageData(width: number, height: number, fillColor?:
  */
 declare function createMockImage(width?: number, height?: number, src?: string): HTMLImageElement;
 
+interface NodeSetupOptions {
+    polyfillFetch?: boolean;
+}
 /**
  * Sets up a Node.js environment for testing.
  * This is primarily for backend or shared logic that doesn't rely on browser APIs.
  */
-declare function setupNodeEnvironment(): void;
+declare function setupNodeEnvironment(options?: NodeSetupOptions): void;
 
 declare function createMockWebGL2Context(canvas: HTMLCanvasElement): WebGL2RenderingContext;
 
@@ -334,14 +337,14 @@ declare function createMockSessionStorage(initialData?: Record<string, string>):
  */
 declare function createMockIndexedDB(): IDBFactory;
 interface StorageScenario {
-    storage: Storage;
-    populate(data: Record<string, string>): void;
-    verify(key: string, value: string): boolean;
+    storage: Storage | IDBFactory;
+    populate(data: Record<string, any>): Promise<void> | void;
+    verify(key: string, value: any): Promise<boolean> | boolean;
 }
 /**
  * Helper to setup a storage test scenario.
  */
-declare function createStorageTestScenario(storageType?: 'local' | 'session'): StorageScenario;
+declare function createStorageTestScenario(storageType?: 'local' | 'session' | 'indexed'): StorageScenario;
 
 declare function createMockAudioContext(): AudioContext;
 /**
@@ -358,8 +361,7 @@ interface AudioEvent {
 }
 /**
  * Captures audio operations for verification.
- * Currently requires manual instrumentation or a more sophisticated Proxy mock.
- * This is a placeholder for future implementation.
+ * Note: Only works if the context was created via createMockAudioContext which proxies calls.
  */
 declare function captureAudioEvents(context: AudioContext): AudioEvent[];
 
@@ -452,4 +454,59 @@ declare class InputInjector {
     wheel(deltaY: number): void;
 }
 
-export { type AudioEvent, type BinaryStreamMock, type BinaryWriterMock, type BrowserSetupOptions, type ControlledTimer, type DrawCall, type GameState, type GameStateCapture, InputInjector, type MockEngine, type MockGame, MockPointerLock, type MockRAF, type MockServer, MockTransport, type MockUDPSocket, type NetworkAddress, type PlaywrightOptions, type PlaywrightTestClient, type StorageScenario, type TestContext, captureAudioEvents, captureCanvasDrawCalls, captureGameState, createBinaryStreamMock, createBinaryWriterMock, createControlledTimer, createEntity, createEntityStateFactory, createGameStateSnapshotFactory, createMockAudioContext, createMockCanvas, createMockCanvasContext2D, createMockEngine, createMockGame, createMockGameState, createMockImage, createMockImageData, createMockIndexedDB, createMockLocalStorage, createMockNetworkAddress, createMockPerformance, createMockRAF, createMockServer, createMockServerClient, createMockServerState, createMockServerStatic, createMockSessionStorage, createMockTransport, createMockUDPSocket, createMockWebGL2Context, createNetChanMock, createPlayerStateFactory, createPlaywrightTestClient, createSpawnContext, createStorageTestScenario, createTestContext, makeAxisBrush, makeBrushFromMinsMaxs, makeBspModel, makeLeaf, makeLeafModel, makeNode, makePlane, setupBrowserEnvironment, setupMockAudioContext, setupNodeEnvironment, simulateFrames, simulateFramesWithMock, teardownBrowserEnvironment, teardownMockAudioContext, waitForGameReady };
+interface NetworkSimulator {
+    apply(page: any): Promise<void>;
+    clear(page: any): Promise<void>;
+}
+type NetworkCondition = 'good' | 'slow' | 'unstable' | 'offline';
+interface NetworkConfig {
+    offline: boolean;
+    downloadThroughput: number;
+    uploadThroughput: number;
+    latency: number;
+}
+/**
+ * Simulates network conditions using Chrome DevTools Protocol (CDP) via Playwright.
+ */
+declare function simulateNetworkCondition(condition: NetworkCondition): NetworkSimulator;
+/**
+ * Creates a custom network condition simulator.
+ *
+ * @param latency Latency in milliseconds
+ * @param jitter Approximate jitter (variation in latency) - Note: CDP doesn't support jitter natively.
+ * @param packetLoss Packet loss percentage (0-100) - Ignored for basic CDP emulation.
+ */
+declare function createCustomNetworkCondition(latency: number, jitter?: number, packetLoss?: number, baseConfig?: NetworkConfig): NetworkSimulator;
+/**
+ * Throttles bandwidth for the given page.
+ */
+declare function throttleBandwidth(page: any, bytesPerSecond: number): Promise<void>;
+
+interface VisualDiff {
+    pixelDiff: number;
+    diffPath?: string;
+    matched: boolean;
+}
+/**
+ * Captures a screenshot of the current game state.
+ */
+declare function captureGameScreenshot(page: Page, name: string, options?: {
+    dir?: string;
+    fullPage?: boolean;
+}): Promise<Buffer>;
+/**
+ * Compares two image buffers pixel-by-pixel.
+ * Note: A robust implementation would use a library like 'pixelmatch' or 'looks-same'.
+ * For now, we provide a basic placeholder or rely on simple buffer comparison.
+ */
+declare function compareScreenshots(baseline: Buffer, current: Buffer, threshold?: number): Promise<VisualDiff>;
+interface VisualScenario {
+    capture(name: string): Promise<Buffer>;
+    compare(name: string, baselineDir: string): Promise<VisualDiff>;
+}
+/**
+ * Creates a helper for visual regression testing scenarios.
+ */
+declare function createVisualTestScenario(page: Page, sceneName: string): VisualScenario;
+
+export { type AudioEvent, type BinaryStreamMock, type BinaryWriterMock, type BrowserSetupOptions, type ControlledTimer, type DrawCall, type GameState, type GameStateCapture, InputInjector, type MockEngine, type MockGame, MockPointerLock, type MockRAF, type MockServer, MockTransport, type MockUDPSocket, type NetworkAddress, type NetworkCondition, type NetworkConfig, type NetworkSimulator, type NodeSetupOptions, type PlaywrightOptions, type PlaywrightTestClient, type StorageScenario, type TestContext, type VisualDiff, type VisualScenario, captureAudioEvents, captureCanvasDrawCalls, captureGameScreenshot, captureGameState, compareScreenshots, createBinaryStreamMock, createBinaryWriterMock, createControlledTimer, createCustomNetworkCondition, createEntity, createEntityStateFactory, createGameStateSnapshotFactory, createMockAudioContext, createMockCanvas, createMockCanvasContext2D, createMockEngine, createMockGame, createMockGameState, createMockImage, createMockImageData, createMockIndexedDB, createMockLocalStorage, createMockNetworkAddress, createMockPerformance, createMockRAF, createMockServer, createMockServerClient, createMockServerState, createMockServerStatic, createMockSessionStorage, createMockTransport, createMockUDPSocket, createMockWebGL2Context, createNetChanMock, createPlayerStateFactory, createPlaywrightTestClient, createSpawnContext, createStorageTestScenario, createTestContext, createVisualTestScenario, makeAxisBrush, makeBrushFromMinsMaxs, makeBspModel, makeLeaf, makeLeafModel, makeNode, makePlane, setupBrowserEnvironment, setupMockAudioContext, setupNodeEnvironment, simulateFrames, simulateFramesWithMock, simulateNetworkCondition, teardownBrowserEnvironment, teardownMockAudioContext, throttleBandwidth, waitForGameReady };

package/packages/test-utils/dist/index.js

@@ -1080,8 +1080,8 @@ function createMockImage(width, height, src) {
 }
 
 // src/setup/node.ts
-function setupNodeEnvironment() {
-  if (typeof global.fetch === "undefined") {
+function setupNodeEnvironment(options = {}) {
+  if (options.polyfillFetch && typeof global.fetch === "undefined") {
   }
 }
 
@@ -1110,6 +1110,61 @@ function createMockIndexedDB() {
   return indexedDB;
 }
 function createStorageTestScenario(storageType = "local") {
+  if (storageType === "indexed") {
+    const dbName = `test-db-${Math.random().toString(36).substring(7)}`;
+    const storeName = "test-store";
+    const storage2 = createMockIndexedDB();
+    return {
+      storage: storage2,
+      populate: async (data) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onupgradeneeded = (e) => {
+            const db = e.target.result;
+            db.createObjectStore(storeName);
+          };
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            const tx = db.transaction(storeName, "readwrite");
+            const store = tx.objectStore(storeName);
+            Object.entries(data).forEach(([k, v]) => store.put(v, k));
+            tx.oncomplete = () => {
+              db.close();
+              resolve();
+            };
+            tx.onerror = () => reject(tx.error);
+          };
+          req.onerror = () => reject(req.error);
+        });
+      },
+      verify: async (key, value) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+              db.close();
+              resolve(false);
+              return;
+            }
+            const tx = db.transaction(storeName, "readonly");
+            const store = tx.objectStore(storeName);
+            const getReq = store.get(key);
+            getReq.onsuccess = () => {
+              const result = getReq.result === value;
+              db.close();
+              resolve(result);
+            };
+            getReq.onerror = () => {
+              db.close();
+              resolve(false);
+            };
+          };
+          req.onerror = () => reject(req.error);
+        });
+      }
+    };
+  }
   const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
   return {
     storage,
@@ -1124,7 +1179,7 @@ function createStorageTestScenario(storageType = "local") {
 
 // src/setup/audio.ts
 function createMockAudioContext() {
-  return {
+  const context = {
     createGain: () => ({
       connect: () => {
       },
@@ -1173,8 +1228,23 @@ function createMockAudioContext() {
       sampleRate,
       numberOfChannels: channels,
       getChannelData: () => new Float32Array(length)
-    })
+    }),
+    // Helper to track events if needed
+    _events: []
   };
+  return new Proxy(context, {
+    get(target, prop, receiver) {
+      if (prop === "_events") return target._events;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return (...args) => {
+          target._events.push({ type: String(prop), args });
+          return Reflect.apply(value, target, args);
+        };
+      }
+      return value;
+    }
+  });
 }
 function setupMockAudioContext() {
   if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
@@ -1195,7 +1265,7 @@ function teardownMockAudioContext() {
   }
 }
 function captureAudioEvents(context) {
-  return [];
+  return context._events || [];
 }
 
 // src/setup/timing.ts
@@ -1487,16 +1557,129 @@ async function captureGameState(page) {
     return {};
   });
 }
+
+// src/e2e/network.ts
+var CONDITIONS = {
+  "good": {
+    offline: false,
+    downloadThroughput: 10 * 1024 * 1024,
+    // 10 Mbps
+    uploadThroughput: 5 * 1024 * 1024,
+    // 5 Mbps
+    latency: 20
+  },
+  "slow": {
+    offline: false,
+    downloadThroughput: 500 * 1024,
+    // 500 Kbps
+    uploadThroughput: 500 * 1024,
+    latency: 400
+  },
+  "unstable": {
+    offline: false,
+    downloadThroughput: 1 * 1024 * 1024,
+    uploadThroughput: 1 * 1024 * 1024,
+    latency: 100
+  },
+  "offline": {
+    offline: true,
+    downloadThroughput: 0,
+    uploadThroughput: 0,
+    latency: 0
+  }
+};
+function simulateNetworkCondition(condition) {
+  const config = CONDITIONS[condition];
+  return createCustomNetworkCondition(config.latency, 0, 0, config);
+}
+function createCustomNetworkCondition(latency, jitter = 0, packetLoss = 0, baseConfig) {
+  return {
+    async apply(page) {
+      const client = await page.context().newCDPSession(page);
+      await client.send("Network.enable");
+      await client.send("Network.emulateNetworkConditions", {
+        offline: baseConfig?.offline || false,
+        latency: latency + Math.random() * jitter,
+        downloadThroughput: baseConfig?.downloadThroughput || -1,
+        uploadThroughput: baseConfig?.uploadThroughput || -1
+      });
+    },
+    async clear(page) {
+      const client = await page.context().newCDPSession(page);
+      await client.send("Network.emulateNetworkConditions", {
+        offline: false,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1
+      });
+    }
+  };
+}
+async function throttleBandwidth(page, bytesPerSecond) {
+  const simulator = createCustomNetworkCondition(0, 0, 0, {
+    offline: false,
+    latency: 0,
+    downloadThroughput: bytesPerSecond,
+    uploadThroughput: bytesPerSecond
+  });
+  await simulator.apply(page);
+}
+
+// src/e2e/visual.ts
+import path from "path";
+import fs from "fs/promises";
+async function captureGameScreenshot(page, name, options = {}) {
+  const dir = options.dir || "__screenshots__";
+  const screenshotPath = path.join(dir, `${name}.png`);
+  await fs.mkdir(dir, { recursive: true });
+  return await page.screenshot({
+    path: screenshotPath,
+    fullPage: options.fullPage ?? false,
+    animations: "disabled",
+    caret: "hide"
+  });
+}
+async function compareScreenshots(baseline, current, threshold = 0.1) {
+  if (baseline.equals(current)) {
+    return { pixelDiff: 0, matched: true };
+  }
+  return {
+    pixelDiff: -1,
+    // Unknown magnitude
+    matched: false
+  };
+}
+function createVisualTestScenario(page, sceneName) {
+  return {
+    async capture(snapshotName) {
+      return await captureGameScreenshot(page, `${sceneName}-${snapshotName}`);
+    },
+    async compare(snapshotName, baselineDir) {
+      const name = `${sceneName}-${snapshotName}`;
+      const current = await captureGameScreenshot(page, name, { dir: "__screenshots__/current" });
+      try {
+        const baselinePath = path.join(baselineDir, `${name}.png`);
+        const baseline = await fs.readFile(baselinePath);
+        return await compareScreenshots(baseline, current);
+      } catch (e) {
+        return { pixelDiff: -1, matched: false };
+      }
+    }
+  };
+}
 export {
   InputInjector,
   MockPointerLock,
   MockTransport,
   captureAudioEvents,
   captureCanvasDrawCalls,
+  captureGameScreenshot,
   captureGameState,
+  compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
   createControlledTimer,
+  createCustomNetworkCondition,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
@@ -1527,6 +1710,7 @@ export {
   createSpawnContext,
   createStorageTestScenario,
   createTestContext,
+  createVisualTestScenario,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -1541,9 +1725,11 @@ export {
   setupNodeEnvironment,
   simulateFrames,
   simulateFramesWithMock,
+  simulateNetworkCondition,
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
+  throttleBandwidth,
   waitForGameReady
 };
 //# sourceMappingURL=index.js.map