@syngrisi/syngrisi/dist/server/lib/comparison/imageDiffProcess.js

Syngrisi - Visual Testing Tool

// src/server/lib/comparison/imageDiffProcess.ts
import { createRequire } from "module";

// src/server/lib/comparison/compareImagesNode.ts
import resemble from "@syngrisi/node-resemble.js";
async function streamToBuffer(stream) {
  return new Promise((resolve, reject) => {
    const data = [];
    stream.on("data", (chunk) => {
      data.push(chunk);
    });
    stream.on("end", () => {
      resolve(Buffer.concat(data));
    });
    stream.on("error", (err) => {
      reject(err);
    });
  });
}
function compareImages(image1, image2, options) {
  return new Promise((resolve, reject) => {
    try {
      const ignoreTransform = {
        antialiasing: "ignoreAntialiasing",
        colors: "ignoreColors",
        nothing: "ignoreNothing"
      };
      const ignoreMethod = ignoreTransform[options.ignore] ? ignoreTransform[options.ignore] : "ignoreNothing";
      const outputOpts = options.output;
      resemble.outputSettings(outputOpts);
      let ignoredRect;
      if (options.ignoreRectangles) {
        ignoredRect = options.ignoreRectangles.map((it) => {
          delete it.name;
          return [it.left, it.top, it.right - it.left, it.bottom - it.top];
        });
      }
      resemble(image1).compareTo(image2)[ignoreMethod]().ignoreRectangles(ignoredRect).onComplete(async (data) => {
        console.log(data);
        const stream = await data.getDiffImage();
        const buffer = await streamToBuffer(stream.pack());
        data.getBuffer = function() {
          return buffer;
        };
        resolve(data);
      });
    } catch (e) {
      reject(e);
    }
  });
}

// src/server/lib/comparison/imageDiffProcess.ts
var require2 = createRequire(import.meta.url);
var currentId = null;
var sendError = (id, error) => {
  const message = error instanceof Error ? error.message : String(error);
  process.send?.({ id, ok: false, error: message });
};
process.on("message", async (payload) => {
  if (!payload) return;
  const { id, baselineOrigin, actualOrigin, options } = payload;
  currentId = id;
  try {
    const baselineBuffer = Buffer.isBuffer(baselineOrigin) ? baselineOrigin : Buffer.from(baselineOrigin);
    const actualBuffer = Buffer.isBuffer(actualOrigin) ? actualOrigin : Buffer.from(actualOrigin);
    if (!baselineBuffer?.length || !actualBuffer?.length) {
      throw new Error("Input file is missing or empty");
    }
    const compareResult = await compareImages(baselineBuffer, actualBuffer, options);
    const diffBuffer = typeof compareResult?.getBuffer === "function" ? await compareResult.getBuffer() : null;
    const plainResult = {};
    if (compareResult && typeof compareResult === "object") {
      for (const [key, value] of Object.entries(compareResult)) {
        if (typeof value === "function") continue;
        plainResult[key] = value;
      }
    }
    process.send?.({ id, ok: true, result: plainResult, diffBuffer });
    currentId = null;
  } catch (error) {
    sendError(id, error);
    currentId = null;
  }
});
process.on("uncaughtException", (error) => {
  sendError(currentId, error);
});
process.on("unhandledRejection", (reason) => {
  sendError(currentId, reason);
});
process.on("disconnect", () => {
  process.exit(0);
});
//# sourceMappingURL=imageDiffProcess.js.map