quake2ts 0.0.596 → 0.0.598

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

@@ -41,6 +41,7 @@ __export(index_exports, {
   captureCanvasDrawCalls: () => captureCanvasDrawCalls,
   captureGameScreenshot: () => captureGameScreenshot,
   captureGameState: () => captureGameState,
+  compareScreenshot: () => compareScreenshot,
   compareScreenshots: () => compareScreenshots,
   createBandwidthTestScenario: () => createBandwidthTestScenario,
   createBinaryStreamMock: () => createBinaryStreamMock,
@@ -165,6 +166,7 @@ __export(index_exports, {
   simulateServerTick: () => simulateServerTick,
   simulateSnapshotDelivery: () => simulateSnapshotDelivery,
   stairTrace: () => import_shared2.stairTrace,
+  takeScreenshot: () => takeScreenshot,
   teardownBrowserEnvironment: () => teardownBrowserEnvironment,
   teardownMockAudioContext: () => teardownMockAudioContext,
   teardownNodeEnvironment: () => teardownNodeEnvironment,
@@ -3236,9 +3238,81 @@ function throttleBandwidth(bytesPerSecond) {
 }
 
 // src/e2e/visual.ts
+var import_canvas3 = require("@napi-rs/canvas");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_path = __toESM(require("path"), 1);
 async function captureGameScreenshot(page, name) {
   return await page.screenshot({ path: `${name}.png` });
 }
+async function takeScreenshot(canvas, filepath) {
+  let buffer;
+  if ("toBuffer" in canvas && typeof canvas.toBuffer === "function") {
+    buffer = canvas.toBuffer("image/png");
+  } else if ("toDataURL" in canvas) {
+    const dataUrl = canvas.toDataURL("image/png");
+    const base64 = dataUrl.replace(/^data:image\/png;base64,/, "");
+    buffer = Buffer.from(base64, "base64");
+  } else {
+    throw new Error("Unsupported canvas type for screenshot");
+  }
+  await import_promises.default.mkdir(import_path.default.dirname(filepath), { recursive: true });
+  await import_promises.default.writeFile(filepath, buffer);
+}
+async function compareScreenshot(canvas, baselinePath) {
+  try {
+    await import_promises.default.access(baselinePath);
+  } catch {
+    console.warn(`Baseline not found at ${baselinePath}, saving current as baseline.`);
+    await takeScreenshot(canvas, baselinePath);
+    return true;
+  }
+  const baselineBuffer = await import_promises.default.readFile(baselinePath);
+  const baselineImage = new import_canvas3.Image();
+  baselineImage.src = baselineBuffer;
+  const width = baselineImage.width;
+  const height = baselineImage.height;
+  let currentBuffer;
+  if ("toBuffer" in canvas && typeof canvas.toBuffer === "function") {
+    currentBuffer = canvas.toBuffer("image/png");
+  } else if ("toDataURL" in canvas) {
+    const dataUrl = canvas.toDataURL("image/png");
+    currentBuffer = Buffer.from(dataUrl.replace(/^data:image\/png;base64,/, ""), "base64");
+  } else {
+    throw new Error("Unsupported canvas type");
+  }
+  if (baselineBuffer.equals(currentBuffer)) {
+    return true;
+  }
+  const baselineCanvas = new import_canvas3.Canvas(width, height);
+  const ctx = baselineCanvas.getContext("2d");
+  ctx.drawImage(baselineImage, 0, 0);
+  const baselineData = ctx.getImageData(0, 0, width, height).data;
+  const currentImage = new import_canvas3.Image();
+  currentImage.src = currentBuffer;
+  if (currentImage.width !== width || currentImage.height !== height) {
+    console.error(`Dimension mismatch: Baseline ${width}x${height} vs Current ${currentImage.width}x${currentImage.height}`);
+    return false;
+  }
+  const currentCanvas = new import_canvas3.Canvas(width, height);
+  const ctx2 = currentCanvas.getContext("2d");
+  ctx2.drawImage(currentImage, 0, 0);
+  const currentData = ctx2.getImageData(0, 0, width, height).data;
+  let diffPixels = 0;
+  const totalPixels = width * height;
+  for (let i = 0; i < baselineData.length; i += 4) {
+    if (baselineData[i] !== currentData[i] || // R
+    baselineData[i + 1] !== currentData[i + 1] || // G
+    baselineData[i + 2] !== currentData[i + 2] || // B
+    baselineData[i + 3] !== currentData[i + 3]) {
+      diffPixels++;
+    }
+  }
+  if (diffPixels > 0) {
+    console.error(`Visual regression: ${diffPixels} pixels differ (${(diffPixels / totalPixels * 100).toFixed(2)}%)`);
+    return false;
+  }
+  return true;
+}
 function compareScreenshots(baseline, current, threshold = 0.01) {
   if (baseline.length !== current.length) {
     return { diffPercentage: 1 };
@@ -3253,7 +3327,6 @@ function compareScreenshots(baseline, current, threshold = 0.01) {
   const diffPercentage = diffPixels / totalPixels;
   return {
     diffPercentage
-    // Generating a diff image buffer would require a library like pixelmatch
   };
 }
 function createVisualTestScenario(sceneName) {
@@ -3276,6 +3349,7 @@ function createVisualTestScenario(sceneName) {
   captureCanvasDrawCalls,
   captureGameScreenshot,
   captureGameState,
+  compareScreenshot,
   compareScreenshots,
   createBandwidthTestScenario,
   createBinaryStreamMock,
@@ -3400,6 +3474,7 @@ function createVisualTestScenario(sceneName) {
   simulateServerTick,
   simulateSnapshotDelivery,
   stairTrace,
+  takeScreenshot,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
   teardownNodeEnvironment,