@pixsame/cypress-plugin-visual-regression-diff 0.0.0 → 1.0.0-canary-20261012-spwhnz4b

package/dist/plugins.mjs

@@ -0,0 +1,567 @@
+import fs, { promises } from 'fs';
+import { PNG } from 'pngjs';
+import pixelmatch from 'pixelmatch';
+import { moveFile } from 'move-file';
+import path from 'path';
+import sharp from 'sharp';
+import metaPngPkg from 'meta-png';
+import { globSync } from 'glob';
+
+const PLUGIN_NAME = 'cp-visual-regression-diff';
+const IMAGE_SNAPSHOT_PREFIX = `__${PLUGIN_NAME}_snapshots__`;
+var FILE_SUFFIX;
+(function (FILE_SUFFIX) {
+  FILE_SUFFIX["diff"] = ".diff";
+  FILE_SUFFIX["actual"] = ".actual";
+})(FILE_SUFFIX || (FILE_SUFFIX = {}));
+const TASK = {
+  getScreenshotPathInfo: `${PLUGIN_NAME}-getScreenshotPathInfo`,
+  compareImages: `${PLUGIN_NAME}-compareImages`,
+  approveImage: `${PLUGIN_NAME}-approveImage`,
+  cleanupImages: `${PLUGIN_NAME}-cleanupImages`,
+  doesFileExist: `${PLUGIN_NAME}-doesFileExist`,
+  processImgPath: `${PLUGIN_NAME}-processImgPath`,
+  recordPendingDiff: `${PLUGIN_NAME}-recordPendingDiff`,
+  getPendingDiffs: `${PLUGIN_NAME}-getPendingDiffs`,
+  clearPendingDiffs: `${PLUGIN_NAME}-clearPendingDiffs`
+  /* c8 ignore next */
+};
+const PATH_VARIABLES = {
+  specPath: '{spec_path}',
+  unixSystemRootPath: '{unix_system_root_path}',
+  winSystemRootPath: '{win_system_root_path}'
+};
+const WINDOWS_LIKE_DRIVE_REGEX = /^[A-Z]:$/;
+const METADATA_KEY = 'FRSOURCE_CPVRD_V';
+
+const supportsExpose = version => {
+  const [major, minor] = version.split('.').map(Number);
+  return major > 15 || major === 15 && minor >= 10;
+};
+const getPluginConfig = (config, key) => {
+  var _config$version, _config$env;
+  if (supportsExpose((_config$version = config.version) != null ? _config$version : '')) {
+    var _config$expose;
+    return (_config$expose = config.expose) == null ? void 0 : _config$expose[key];
+  }
+  return (_config$env = config.env) == null ? void 0 : _config$env[key];
+};
+
+function isHighSurrogate(codePoint) {
+  return codePoint >= 0xd800 && codePoint <= 0xdbff;
+}
+
+function isLowSurrogate(codePoint) {
+  return codePoint >= 0xdc00 && codePoint <= 0xdfff;
+}
+
+// Truncate string by size in bytes
+var truncate = function truncate(getLength, string, byteLength) {
+  if (typeof string !== "string") {
+    throw new Error("Input must be string");
+  }
+
+  var charLength = string.length;
+  var curByteLength = 0;
+  var codePoint;
+  var segment;
+
+  for (var i = 0; i < charLength; i += 1) {
+    codePoint = string.charCodeAt(i);
+    segment = string[i];
+
+    if (isHighSurrogate(codePoint) && isLowSurrogate(string.charCodeAt(i + 1))) {
+      i += 1;
+      segment += string[i];
+    }
+
+    curByteLength += getLength(segment);
+
+    if (curByteLength === byteLength) {
+      return string.slice(0, i + 1);
+    }
+    else if (curByteLength > byteLength) {
+      return string.slice(0, i - segment.length + 1);
+    }
+  }
+
+  return string;
+};
+
+var getLength = Buffer.byteLength.bind(Buffer);
+var truncateUtf8Bytes = truncate.bind(null, getLength);
+
+/*jshint node:true*/
+
+/**
+ * Replaces characters in strings that are illegal/unsafe for filenames.
+ * Unsafe characters are either removed or replaced by a substitute set
+ * in the optional `options` object.
+ *
+ * Illegal Characters on Various Operating Systems
+ * / ? < > \ : * | "
+ * https://kb.acronis.com/content/39790
+ *
+ * Unicode Control codes
+ * C0 0x00-0x1f & C1 (0x80-0x9f)
+ * http://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * Reserved filenames on Unix-based systems (".", "..")
+ * Reserved filenames in Windows ("CON", "PRN", "AUX", "NUL", "COM1",
+ * "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+ * "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", and
+ * "LPT9") case-insesitively and with or without filename extensions.
+ *
+ * Capped at 255 characters in length.
+ * http://unix.stackexchange.com/questions/32795/what-is-the-maximum-allowed-filename-and-folder-size-with-ecryptfs
+ *
+ * @param  {String} input   Original filename
+ * @param  {Object} options {replacement: String | Function }
+ * @return {String}         Sanitized filename
+ */
+
+
+
+var illegalRe = /[\/\?<>\\:\*\|"]/g;
+var controlRe = /[\x00-\x1f\x80-\x9f]/g;
+var reservedRe = /^\.+$/;
+var windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
+
+/**
+ * Strip trailing spaces and dots, which are not allowed on some Windows file
+ * systems. Does not use a regex to avoid a quadratic ReDoS vulnerability
+ * (CWE-1333).
+ */
+function replaceTrailingDotsAndSpaces(str, replacement) {
+  var end = str.length;
+  while (end > 0 && (str[end - 1] === '.' || str[end - 1] === ' ')) end--;
+  return end < str.length ? str.slice(0, end) + replacement : str;
+}
+
+function sanitize(input, replacement) {
+  if (typeof input !== 'string') {
+    throw new Error('Input must be string');
+  }
+  var sanitized = input
+    .replace(illegalRe, replacement)
+    .replace(controlRe, replacement)
+    .replace(reservedRe, replacement)
+    .replace(windowsReservedRe, replacement);
+  sanitized = replaceTrailingDotsAndSpaces(sanitized, replacement);
+  return truncateUtf8Bytes(sanitized, 255);
+}
+
+var sanitizeFilename = function (input, options) {
+  var replacement = (options && options.replacement) || '';
+  var output = sanitize(input, replacement);
+  if (replacement === '') {
+    return output;
+  }
+  return sanitize(output, '');
+};
+
+// highest `_#n` index handed out per screenshot path during the current spec
+const nameCacheCounter = {};
+// counters as they were before the current test attempt started, for every
+// path the attempt touched - a retry restores them so the regenerated
+// screenshots get the same names again
+const countersBeforeAttempt = {};
+let currentAttempt;
+const resetMap = map => {
+  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+  for (const key in map) delete map[key];
+};
+const parsePathPartVariables = (specPath, pathPart, i) => {
+  if (pathPart === PATH_VARIABLES.specPath) {
+    return path.dirname(specPath);
+  } else if (i === 0 && !pathPart) {
+    // when unix-like absolute path
+    return PATH_VARIABLES.unixSystemRootPath;
+  } else if (i === 0 && WINDOWS_LIKE_DRIVE_REGEX.test(pathPart)) {
+    // when win-like absolute path
+    return path.join(PATH_VARIABLES.winSystemRootPath, pathPart[0]);
+  }
+  return pathPart;
+};
+const startAttempt = (testId, retry) => {
+  var _currentAttempt;
+  const isSameTest = ((_currentAttempt = currentAttempt) == null ? void 0 : _currentAttempt.testId) === testId;
+  if (isSameTest && currentAttempt && retry > currentAttempt.retry) {
+    for (const screenshotPath in countersBeforeAttempt) {
+      nameCacheCounter[screenshotPath] = countersBeforeAttempt[screenshotPath];
+    }
+  }
+  if (!isSameTest || currentAttempt && retry !== currentAttempt.retry) {
+    resetMap(countersBeforeAttempt);
+  }
+  currentAttempt = {
+    testId,
+    retry
+  };
+};
+const generateScreenshotPath = ({
+  titleFromOptions,
+  imagesPath,
+  specPath,
+  currentRetryNumber,
+  testId
+}) => {
+  const screenshotPath = path.join(...imagesPath.split('/').map(parsePathPartVariables.bind(void 0, specPath)), sanitizeFilename(titleFromOptions));
+  startAttempt(testId, currentRetryNumber);
+  if (typeof nameCacheCounter[screenshotPath] === 'undefined') {
+    nameCacheCounter[screenshotPath] = -1;
+  }
+  if (!(screenshotPath in countersBeforeAttempt)) {
+    countersBeforeAttempt[screenshotPath] = nameCacheCounter[screenshotPath];
+  }
+  return path.join(IMAGE_SNAPSHOT_PREFIX, `${screenshotPath}_#${++nameCacheCounter[screenshotPath]}${FILE_SUFFIX.actual}.png`);
+};
+const screenshotPathRegex = new RegExp(`^([\\s\\S]+?)_#([0-9]+)(?:(?:\\${FILE_SUFFIX.diff})|(?:\\${FILE_SUFFIX.actual}))?\\.(?:png|PNG)$`);
+const wasScreenshotUsed = imagePath => {
+  const matched = imagePath.match(screenshotPathRegex);
+  /* c8 ignore next */
+  if (!matched) return false;
+  const [, screenshotPath, numString] = matched;
+  const num = parseInt(numString);
+  /* c8 ignore next */
+  if (!screenshotPath || isNaN(num)) return false;
+  return screenshotPath in nameCacheCounter && num <= nameCacheCounter[screenshotPath];
+};
+const resetScreenshotNameCache = () => {
+  currentAttempt = undefined;
+  resetMap(nameCacheCounter);
+  resetMap(countersBeforeAttempt);
+};
+
+const {
+  addMetadata,
+  getMetadata
+} = metaPngPkg;
+// version of images generated by this plugin
+// bump only when there is a breaking change to:
+// image comparison or image generation algorithms
+const DIFF_IMAGES_VERSION = '1';
+const addPNGMetadata = (config, png) => addMetadata(new Uint8Array(png), METADATA_KEY, JSON.stringify({
+  version: DIFF_IMAGES_VERSION,
+  testingType: config.testingType || 'e2e'
+}) /* c8 ignore next */);
+const getPNGMetadata = png => {
+  const metadataString = getMetadata(new Uint8Array(png), METADATA_KEY /* c8 ignore next */);
+  if (metadataString === undefined) return;
+  try {
+    return JSON.parse(metadataString);
+  } catch (_unused) /* v8 ignore next 2 */{
+    return {
+      version: metadataString
+    };
+  }
+};
+const isImageCurrentVersion = png => {
+  var _getPNGMetadata;
+  return ((_getPNGMetadata = getPNGMetadata(png)) == null ? void 0 : _getPNGMetadata.version) === DIFF_IMAGES_VERSION;
+};
+const isImageGeneratedByPlugin = png => !!getPNGMetadata(png /* c8 ignore next */);
+const isImageOfTestType = (png, testingType) => {
+  var _getPNGMetadata2;
+  if (!isImageGeneratedByPlugin(png)) return false;
+  const imageTestingType = (_getPNGMetadata2 = getPNGMetadata(png /* c8 ignore next */)) == null ? void 0 : _getPNGMetadata2.testingType;
+  return imageTestingType === testingType || testingType === undefined;
+};
+const writePNG = (config, name, png) => fs.writeFileSync(name, addPNGMetadata(config, png instanceof PNG ? PNG.sync.write(png) : png));
+const inArea = (x, y, height, width) => y > height || x > width;
+const fillSizeDifference = (image, width, height) => {
+  for (let y = 0; y < image.height; y++) {
+    for (let x = 0; x < image.width; x++) {
+      if (inArea(x, y, height, width)) {
+        const idx = image.width * y + x << 2;
+        image.data[idx] = 0;
+        image.data[idx + 1] = 0;
+        image.data[idx + 2] = 0;
+        image.data[idx + 3] = 64;
+      }
+    }
+  }
+  return image;
+  /* c8 ignore next */
+};
+const createImageResizer = (width, height) => source => {
+  const resized = new PNG({
+    width,
+    height,
+    fill: true
+  });
+  PNG.bitblt(source, resized, 0, 0, source.width, source.height, 0, 0);
+  return resized;
+  /* c8 ignore next */
+};
+const scaleImageAndWrite = async ({
+  scaleFactor,
+  path
+}) => {
+  const imgBuffer = fs.readFileSync(path);
+  if (scaleFactor === 1) return imgBuffer;
+  const rawImgNew = PNG.sync.read(imgBuffer);
+  const newImageWidth = Math.ceil(rawImgNew.width * scaleFactor);
+  const newImageHeight = Math.ceil(rawImgNew.height * scaleFactor);
+  await sharp(imgBuffer).resize(newImageWidth, newImageHeight).toFile(path);
+  return fs.readFileSync(path);
+};
+const alignImagesToSameSize = (firstImage, secondImage) => {
+  const firstImageWidth = firstImage.width;
+  const firstImageHeight = firstImage.height;
+  const secondImageWidth = secondImage.width;
+  const secondImageHeight = secondImage.height;
+  const resizeToSameSize = createImageResizer(Math.max(firstImageWidth, secondImageWidth), Math.max(firstImageHeight, secondImageHeight));
+  const resizedFirst = resizeToSameSize(firstImage);
+  const resizedSecond = resizeToSameSize(secondImage);
+  return [fillSizeDifference(resizedFirst, firstImageWidth, firstImageHeight), fillSizeDifference(resizedSecond, secondImageWidth, secondImageHeight)];
+};
+const cleanupUnused = config => {
+  globSync('**/*.png', {
+    cwd: config.projectRoot,
+    ignore: 'node_modules/**/*'
+  }).forEach(pngPath => {
+    const absolutePath = path.join(config.projectRoot, pngPath);
+    if (!wasScreenshotUsed(pngPath) && isImageOfTestType(fs.readFileSync(absolutePath), config.testingType)) {
+      fs.unlinkSync(absolutePath);
+    }
+  });
+};
+
+let pendingDiffs = [];
+const round = n => Math.ceil(n * 1000) / 1000;
+const unlinkSyncSafe = path => fs.existsSync(path) && fs.unlinkSync(path);
+// `.diff.png` sibling of an `.actual.png`; null when the name has no `.actual`
+// suffix (only happens with hand-picked paths), so nothing else gets deleted
+const diffPathFor = actualPath => {
+  const diffPath = actualPath.replace(FILE_SUFFIX.actual, FILE_SUFFIX.diff);
+  return diffPath === actualPath ? null : diffPath;
+};
+const removeStaleDiff = actualPath => {
+  const diffPath = diffPathFor(actualPath);
+  if (diffPath) unlinkSyncSafe(diffPath);
+};
+const getScreenshotPathInfoTask = cfg => {
+  const screenshotPath = generateScreenshotPath(cfg);
+  return {
+    screenshotPath,
+    title: path.basename(screenshotPath, '.png')
+  };
+};
+const cleanupImagesTask = config => {
+  if (getPluginConfig(config, 'pluginVisualRegressionCleanupUnusedImages')) {
+    cleanupUnused(config);
+  }
+  resetScreenshotNameCache();
+  return null;
+};
+const approveImageTask = async ({
+  img,
+  imgOld
+}) => {
+  const oldImg = imgOld != null ? imgOld : img.replace(FILE_SUFFIX.actual, '');
+  unlinkSyncSafe(oldImg);
+  const diffImg = img.replace(FILE_SUFFIX.actual, FILE_SUFFIX.diff);
+  unlinkSyncSafe(diffImg);
+  await moveFile(img, oldImg);
+  return null;
+};
+const compareImagesTask = async (cypressConfig, cfg) => {
+  const messages = [];
+  // Stamp the screenshot with plugin metadata exactly once, so that every file
+  // derived from it (baseline via moveFile, kept .actual.png, manual rename)
+  // carries FRSOURCE_CPVRD_V and won't be silently rewritten on the next run.
+  const stampedImgNew = addPNGMetadata(cypressConfig, await scaleImageAndWrite({
+    scaleFactor: cfg.scaleFactor,
+    path: cfg.imgNew
+  }));
+  fs.writeFileSync(cfg.imgNew, stampedImgNew);
+  const rawImgNewBuffer = Buffer.from(stampedImgNew);
+  let imgDiff;
+  let imgNewBase64, imgOldBase64, imgDiffBase64;
+  let error = false;
+  if (fs.existsSync(cfg.imgOld) && cfg.updateImages !== true) {
+    const rawImgNew = PNG.sync.read(rawImgNewBuffer);
+    const rawImgOldBuffer = fs.readFileSync(cfg.imgOld);
+    const rawImgOld = PNG.sync.read(rawImgOldBuffer);
+    const isImgSizeDifferent = rawImgNew.height !== rawImgOld.height || rawImgNew.width !== rawImgOld.width;
+    const [imgNew, imgOld] = isImgSizeDifferent ? alignImagesToSameSize(rawImgNew, rawImgOld) : [rawImgNew, rawImgOld];
+    const {
+      width,
+      height
+    } = imgNew;
+    const diff = new PNG({
+      width,
+      height
+    });
+    const diffConfig = Object.assign({
+      includeAA: true
+    }, cfg.diffConfig);
+    const diffPixels = pixelmatch(new Uint8Array(imgNew.data), new Uint8Array(imgOld.data), diff.data, width, height, diffConfig);
+    imgDiff = diffPixels / (width * height);
+    if (isImgSizeDifferent) {
+      messages.push(`Warning: Images size mismatch - new screenshot is ${rawImgNew.width}px by ${rawImgNew.height}px while old one is ${rawImgOld.width}px by ${rawImgOld.height} (width x height).`);
+    }
+    if (imgDiff > cfg.maxDiffThreshold) {
+      messages.unshift(`Image diff factor (${round(imgDiff * 100)}%) is bigger than maximum threshold option ${round(cfg.maxDiffThreshold * 100)}%.`);
+      error = true;
+    }
+    const diffBuffer = PNG.sync.write(diff);
+    imgNewBase64 = PNG.sync.write(imgNew).toString('base64');
+    imgDiffBase64 = diffBuffer.toString('base64');
+    imgOldBase64 = PNG.sync.write(imgOld).toString('base64');
+    if (error && cfg.updateImages === 'failures-only') {
+      await moveFile(cfg.imgNew, cfg.imgOld);
+      // a diff image left by an earlier failed attempt is stale now
+      removeStaleDiff(cfg.imgNew);
+      error = false;
+      messages[0] = messages[0].replace('is bigger than maximum threshold option', 'was bigger than maximum threshold option (baseline updated):');
+    } else if (error) {
+      writePNG(cypressConfig, cfg.imgNew.replace(FILE_SUFFIX.actual, FILE_SUFFIX.diff), diffBuffer);
+    } else {
+      removeStaleDiff(cfg.imgNew);
+      if (rawImgOld && !isImageCurrentVersion(rawImgOldBuffer)) {
+        await moveFile(cfg.imgNew, cfg.imgOld);
+      } else {
+        // don't overwrite file if it's the same (imgDiff < cfg.maxDiffThreshold && !isImgSizeDifferent)
+        fs.unlinkSync(cfg.imgNew);
+      }
+    }
+  } else {
+    // there is no "old screenshot" or screenshots should be immediately updated
+    imgDiff = 0;
+    imgNewBase64 = '';
+    imgDiffBase64 = '';
+    imgOldBase64 = '';
+    if (cfg.createMissingImages) {
+      await moveFile(cfg.imgNew, cfg.imgOld);
+      removeStaleDiff(cfg.imgNew);
+    } else {
+      error = true;
+      messages.unshift(`Baseline image is missing at path: "${cfg.imgOld}". Provide a baseline image or enable "createMissingImages" option in plugin configuration.`);
+    }
+  }
+  if (typeof imgDiff !== 'undefined') {
+    if (!error) {
+      messages.unshift(`Image diff factor (${round(imgDiff * 100)}%) is within boundaries of maximum threshold option ${round(cfg.maxDiffThreshold * 100)}%.`);
+    }
+    return {
+      error,
+      message: messages.join('\n'),
+      imgDiff,
+      imgNewBase64,
+      imgDiffBase64,
+      imgOldBase64,
+      maxDiffThreshold: cfg.maxDiffThreshold
+    };
+  }
+  /* c8 ignore next */
+  return null;
+};
+const doesFileExistTask = ({
+  path
+}) => fs.existsSync(path);
+const processImgPathTask = ({
+  path
+}) => path;
+const recordPendingDiffTask = record => {
+  pendingDiffs.push(record);
+  return pendingDiffs.filter(d => !d.passed).length;
+};
+const getPendingDiffsTask = () => [...pendingDiffs];
+const clearPendingDiffsTask = () => {
+  pendingDiffs = [];
+  return null;
+};
+/* c8 ignore start */
+const initTaskHook = config => ({
+  [TASK.getScreenshotPathInfo]: getScreenshotPathInfoTask,
+  [TASK.cleanupImages]: cleanupImagesTask.bind(undefined, config),
+  [TASK.doesFileExist]: doesFileExistTask,
+  [TASK.approveImage]: approveImageTask,
+  [TASK.compareImages]: compareImagesTask.bind(undefined, config),
+  [TASK.processImgPath]: processImgPathTask,
+  [TASK.recordPendingDiff]: recordPendingDiffTask,
+  [TASK.getPendingDiffs]: getPendingDiffsTask,
+  [TASK.clearPendingDiffs]: clearPendingDiffsTask
+});
+/* c8 ignore stop */
+
+const MIMIC_ROOT_WIN_REGEX = new RegExp(`^${PATH_VARIABLES.winSystemRootPath}\\${path.sep}([A-Z])\\${path.sep}`);
+const MIMIC_ROOT_UNIX_REGEX = new RegExp(`^${PATH_VARIABLES.unixSystemRootPath}\\${path.sep}`);
+const getConfigVariableOrThrow = (config, name) => {
+  if (config[name]) {
+    return config[name];
+  }
+  /* c8 ignore start */
+  throw `[@pixsame/cypress-plugin-visual-regression-diff] CypressConfig.${name} cannot be missing or \`false\`!`;
+};
+/* c8 ignore stop */
+const parseAbsolutePath = ({
+  screenshotPath,
+  projectRoot
+}) => {
+  let newAbsolutePath;
+  const matchedMimicingWinRoot = screenshotPath.match(MIMIC_ROOT_WIN_REGEX);
+  const matchedMimicingUnixRoot = screenshotPath.match(MIMIC_ROOT_UNIX_REGEX);
+  if (matchedMimicingWinRoot && matchedMimicingWinRoot[1]) {
+    const driveLetter = matchedMimicingWinRoot[1];
+    newAbsolutePath = path.join(`${driveLetter}:\\`, screenshotPath.substring(matchedMimicingWinRoot[0].length));
+  } else if (matchedMimicingUnixRoot) {
+    newAbsolutePath = path.sep + screenshotPath.substring(matchedMimicingUnixRoot[0].length);
+  } else {
+    newAbsolutePath = path.join(projectRoot, screenshotPath);
+  }
+  return path.normalize(newAbsolutePath);
+};
+const initAfterScreenshotHook = config => details => {
+  var _details$name;
+  // it's not a screenshot generated by FRSOURCE Cypress Plugin Visual Regression Diff
+  /* c8 ignore start */
+  if (((_details$name = details.name) == null ? void 0 : _details$name.indexOf(IMAGE_SNAPSHOT_PREFIX)) !== 0) return;
+  /* c8 ignore stop */
+  const screenshotsFolder = getConfigVariableOrThrow(config, 'screenshotsFolder');
+  const screenshotPath = details.name.substring(IMAGE_SNAPSHOT_PREFIX.length + path.sep.length);
+  const newAbsolutePath = parseAbsolutePath({
+    screenshotPath,
+    projectRoot: config.projectRoot
+  });
+  return (async () => {
+    await moveFile(details.path, newAbsolutePath);
+    await promises.rm(path.join(screenshotsFolder, IMAGE_SNAPSHOT_PREFIX), {
+      recursive: true,
+      force: true
+    });
+    return {
+      path: newAbsolutePath
+    };
+  })();
+};
+
+/* c8 ignore start */
+const initForceDeviceScaleFactor = on => {
+  // based on https://github.com/cypress-io/cypress/issues/2102#issuecomment-521299946
+  on('before:browser:launch', (browser, launchOptions) => {
+    if (browser.name === 'chrome' || browser.name === 'chromium') {
+      launchOptions.args.push('--force-device-scale-factor=1');
+      launchOptions.args.push('--high-dpi-support=1');
+      return launchOptions;
+    } else if (browser.name === 'electron' && browser.isHeaded) {
+      // eslint-disable-next-line no-console
+      console.log("There isn't currently a way of setting the device scale factor in Cypress when running headed electron so we disable the image regression commands.");
+    }
+  });
+};
+/* c8 ignore stop */
+const initPlugin = (on, config) => {
+  /* c8 ignore start */
+  if (getPluginConfig(config, 'pluginVisualRegressionForceDeviceScaleFactor') !== false) {
+    initForceDeviceScaleFactor(on);
+  }
+  /* c8 ignore stop */
+  on('task', initTaskHook(config));
+  on('after:screenshot', initAfterScreenshotHook(config));
+};
+
+export { initPlugin };
+//# sourceMappingURL=plugins.mjs.map