@wdio/image-comparison-core 1.1.4 → 1.2.1

package/dist/methods/rectangles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangles.d.ts","sourceRoot":"","sources":["../../src/methods/rectangles.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,+BAA+B,EAC/B,gBAAgB,EAChB,iBAAiB,EACjB,8BAA8B,EAC9B,wBAAwB,EACxB,gBAAgB,EAChB,uBAAuB,EACvB,YAAY,EACZ,8BAA8B,EAC9B,qCAAqC,EACxC,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAEvE;;GAEG;AACH,wBAAsB,0BAA0B,CAAC,EAC7C,eAAe,EACf,WAAW,EACX,OAAO,EACP,OAAO,GACV,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA4C/C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,CAoCjH;AAED;;GAEG;AACH,wBAAgB,uCAAuC,CAAC,EAAE,gBAAgB,EAAE,OAAO,EAAE,EAAC;IAClF,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,OAAO,EAAE,qCAAqC,CAAC;CAClD,GAAG,8BAA8B,CAgDjC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,WASvC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,WAS9C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,UAG9D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAC,OAAO,EAAE,GAAG,YAAY,CA4B1D;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,eAAe,EAAE,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAQ/I;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CACxC,eAAe,EAAE,WAAW,CAAC,OAAO,EACpC,OAAO,EAAE,aAAa,EAAE,GACzB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAY7B;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,YAAY,EAAE,EAAE,+BAA+B,+BAwBhI;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAyGxH"}
+{"version":3,"file":"rectangles.d.ts","sourceRoot":"","sources":["../../src/methods/rectangles.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACR,+BAA+B,EAC/B,wCAAwC,EACxC,sCAAsC,EACtC,uCAAuC,EACvC,gBAAgB,EAChB,iBAAiB,EACjB,8BAA8B,EAC9B,wBAAwB,EACxB,gBAAgB,EAChB,uBAAuB,EACvB,YAAY,EACZ,8BAA8B,EAC9B,qCAAqC,EACxC,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAA;AAEvE;;GAEG;AACH,wBAAsB,0BAA0B,CAAC,EAC7C,eAAe,EACf,WAAW,EACX,OAAO,EACP,OAAO,GACV,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA4C/C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,gBAAgB,CAoCjH;AAED;;GAEG;AACH,wBAAgB,uCAAuC,CAAC,EAAE,gBAAgB,EAAE,OAAO,EAAE,EAAC;IAClF,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,OAAO,EAAE,qCAAqC,CAAC;CAClD,GAAG,8BAA8B,CAgDjC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,WASvC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,WAS9C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,UAG9D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAC,OAAO,EAAE,GAAG,YAAY,CA4B1D;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,eAAe,EAAE,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAQ/I;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CACxC,eAAe,EAAE,WAAW,CAAC,OAAO,EACpC,OAAO,EAAE,CAAC,aAAa,GAAG,aAAa,EAAE,CAAC,EAAE,GAC7C,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAY7B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,+BAA+B,CACjD,OAAO,EAAE,sCAAsC,EAC/C,OAAO,EAAE,CAAC,aAAa,GAAG,aAAa,EAAE,CAAC,EAAE,GAC7C,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA4E7B;AAED;;;;;;GAMG;AACH,wBAAsB,iCAAiC,CACnD,OAAO,EAAE,wCAAwC,EACjD,OAAO,EAAE,CAAC,aAAa,GAAG,aAAa,EAAE,CAAC,EAAE,GAC7C,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA4D7B;AAED;;;;;;;;;GASG;AACH,wBAAsB,gCAAgC,CAClD,OAAO,EAAE,uCAAuC,EAChD,OAAO,EAAE,CAAC,aAAa,GAAG,aAAa,EAAE,CAAC,EAAE,GAC7C,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAiF7B;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,EAAE,SAAS,EAAE,oBAAoB,EAAE,YAAY,EAAE,EAAE,+BAA+B,+BAwBhI;AAuDD;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAkIxH"}

package/dist/methods/rectangles.interfaces.d.ts

@@ -118,6 +118,10 @@ export interface PrepareIgnoreRectanglesOptions {
         blockOutStatusBar?: boolean;
         blockOutToolBar?: boolean;
     };
+    /** Whether this is a hybrid (native + webview) app; enables status bar fallback when overlay reports zero */
+    isHybridApp?: boolean;
+    /** Platform version from the device (e.g. "14.0"); used for Android API level lookup in fallback */
+    platformVersion?: string;
     actualFilePath?: string;
 }
 export interface PreparedIgnoreRectangles {
@@ -126,6 +130,60 @@ export interface PreparedIgnoreRectangles {
     /** Whether any ignore rectangles were found */
     hasIgnoreRectangles: boolean;
 }
+export interface DetermineWebScreenIgnoreRegionsOptions {
+    /** The browser instance */
+    browserInstance: WebdriverIO.Browser;
+    /** The device pixel ratio */
+    devicePixelRatio: number;
+    /** The device rectangles (contains viewport offset for mobile) */
+    deviceRectangles: DeviceRectangles;
+    /** Whether this is an Android device */
+    isAndroid: boolean;
+    /** Whether this is an Android native web screenshot */
+    isAndroidNativeWebScreenshot: boolean;
+    /** Whether this is an iOS device */
+    isIOS: boolean;
+    /** Padding in device pixels added to each side of computed ignore regions (caller defaults to 1). */
+    ignoreRegionPadding: number;
+}
+/**
+ * Options for full-page web ignore regions (desktop and mobile).
+ * Full-page image is in document coordinates; on mobile scroll-and-stitch the canvas
+ * crops off the top addressBarShadowPadding (CSS px), so we subtract that from y.
+ */
+export interface DetermineWebFullPageIgnoreRegionsOptions {
+    /** The browser instance */
+    browserInstance: WebdriverIO.Browser;
+    /** The device pixel ratio */
+    devicePixelRatio: number;
+    /** Padding in device pixels added to each side of computed ignore regions (caller defaults to 1). */
+    ignoreRegionPadding: number;
+    /**
+     * Top crop offset in CSS pixels (e.g. addressBarShadowPadding on mobile full-page).
+     * When set, canvas y = (documentY - fullPageCropTopPaddingCSS) × DPR so ignore regions
+     * align with the stitched image which crops this much from the top of each tile.
+     * @default 0
+     */
+    fullPageCropTopPaddingCSS?: number;
+}
+export interface DetermineWebElementIgnoreRegionsOptions {
+    /** The browser instance */
+    browserInstance: WebdriverIO.Browser;
+    /** The device pixel ratio */
+    devicePixelRatio: number;
+    /** The root element being captured in the element screenshot */
+    rootElement: WebdriverIO.Element;
+    /** Padding in device pixels added to each side of computed ignore regions (caller defaults to 1). */
+    ignoreRegionPadding: number;
+    /**
+     * When both this and isWebDriverElementScreenshot are true, the element image is at CSS pixel size
+     * (native driver returns a downscaled image). We then output ignore regions in CSS pixel coordinates
+     * by dividing by DPR; otherwise regions are in device pixels.
+     */
+    isAndroidNativeWebScreenshot?: boolean;
+    /** When true, the element screenshot came from the native driver (no fallback crop). */
+    isWebDriverElementScreenshot?: boolean;
+}
 export interface BoundingBox extends BaseBoundingBox {
 }
 export interface IgnoreBoxes extends BoundingBox {

package/dist/methods/rectangles.interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangles.interfaces.d.ts","sourceRoot":"","sources":["../../src/methods/rectangles.interfaces.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rectangles.interfaces.d.ts","sourceRoot":"","sources":["../../src/methods/rectangles.interfaces.ts"],"names":[],"mappings":"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"}

package/dist/methods/rectangles.js

@@ -1,4 +1,5 @@
 import { Jimp } from 'jimp';
+import { ANDROID_OFFSETS, IOS_OFFSETS } from '../helpers/constants.js';
 import { calculateDprData, getBase64ScreenshotSize, isObject } from '../helpers/utils.js';
 import { getElementPositionAndroid, getElementPositionDesktop, getElementWebviewPosition } from './elementPosition.js';
 /**
@@ -186,6 +187,218 @@ export async function determineIgnoreRegions(browserInstance, ignores) {
         height: Math.round(region.height),
     }));
 }
+/**
+ * Translate ignores to regions for web screen (viewport) screenshots.
+ * Uses getBoundingClientRect (CSS pixels) and converts to device pixels,
+ * accounting for the viewport offset on native web screenshot devices.
+ *
+ * Coordinate systems per platform:
+ * - Desktop / Android ChromeDriver: screenshot is viewport-only, BCR × DPR
+ * - iOS: full-device screenshot, viewport offset is in CSS points → (BCR + offset) × DPR
+ * - Android native web: full-device screenshot, viewport offset is already in
+ *   device pixels (injectWebviewOverlay pre-scales by DPR) → BCR × DPR + offset
+ */
+export async function determineWebScreenIgnoreRegions(options, ignores) {
+    const awaitedIgnores = await Promise.all(ignores);
+    const { elements, regions } = splitIgnores(awaitedIgnores);
+    const { browserInstance, devicePixelRatio, deviceRectangles, isAndroid, isAndroidNativeWebScreenshot, isIOS, ignoreRegionPadding: padding } = options;
+    // Get raw (unrounded) BCR values so we can multiply by DPR before
+    // rounding. The shared getBoundingClientRect script pre-rounds to CSS
+    // integers which loses sub-pixel precision that matters at higher DPRs.
+    const rawBcr = (el) => {
+        const rect = el.getBoundingClientRect();
+        return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+    };
+    // Browsers can invalidate element references when the DOM is mutated
+    // (e.g. by beforeScreenshot CSS/style injection). Re-query via $$ to
+    // get fresh refs. Use $$ per unique selector so multiple elements
+    // sharing the same selector (e.g. from a $$ call) each resolve to
+    // the correct match by index.
+    const regionsFromElements = [];
+    const selectorCache = new Map();
+    const selectorIndex = new Map();
+    for (const element of elements) {
+        const selector = element.selector;
+        if (!selectorCache.has(selector)) {
+            const fresh = await browserInstance.$$(selector);
+            selectorCache.set(selector, fresh);
+            selectorIndex.set(selector, 0);
+        }
+        const idx = selectorIndex.get(selector);
+        const cached = selectorCache.get(selector);
+        const el = idx < cached.length ? cached[idx] : element;
+        selectorIndex.set(selector, idx + 1);
+        const bcr = await browserInstance.execute(rawBcr, el);
+        regionsFromElements.push(bcr);
+    }
+    return [...regions, ...regionsFromElements]
+        .map((region) => {
+        // Use floor for top-left and ceil for bottom-right so the
+        // device-pixel rectangle fully covers the CSS-pixel element.
+        // Rounding position and size independently can miss edge pixels.
+        let cssX = region.x;
+        let cssY = region.y;
+        if (isIOS) {
+            cssX += deviceRectangles.viewport.x;
+            cssY += deviceRectangles.viewport.y;
+        }
+        const left = Math.floor(cssX * devicePixelRatio);
+        const top = Math.floor(cssY * devicePixelRatio);
+        const right = Math.ceil((cssX + region.width) * devicePixelRatio);
+        const bottom = Math.ceil((cssY + region.height) * devicePixelRatio);
+        let x = left;
+        let y = top;
+        if (isAndroid && isAndroidNativeWebScreenshot) {
+            // Android native web viewport offset is already in device pixels
+            x += deviceRectangles.viewport.x;
+            y += deviceRectangles.viewport.y;
+        }
+        let width = right - left;
+        let height = bottom - top;
+        if (padding > 0) {
+            x = Math.max(0, x - padding);
+            y = Math.max(0, y - padding);
+            width += 2 * padding;
+            height += 2 * padding;
+        }
+        return { x, y, width, height };
+    });
+}
+/**
+ * Translate ignores to regions for web full-page screenshots (desktop and mobile).
+ * Full-page image (BiDi or scroll-and-stitch) is in document coordinates: (0,0) = top-left
+ * of document, device pixels. Uses getBoundingClientRect + (scrollX, scrollY) for elements,
+ * then converts to device pixels. Same logic for all platforms; no viewport offset needed
+ * because the stitched canvas is built in document space.
+ */
+export async function determineWebFullPageIgnoreRegions(options, ignores) {
+    const awaitedIgnores = await Promise.all(ignores);
+    const { elements, regions } = splitIgnores(awaitedIgnores);
+    const { browserInstance, devicePixelRatio, ignoreRegionPadding: padding, fullPageCropTopPaddingCSS: cropTop = 0 } = options;
+    const rawDocumentBcr = (el) => {
+        const rect = el.getBoundingClientRect();
+        return {
+            x: rect.x + window.scrollX,
+            y: rect.y + window.scrollY,
+            width: rect.width,
+            height: rect.height,
+        };
+    };
+    const regionsFromElements = [];
+    const selectorCache = new Map();
+    const selectorIndex = new Map();
+    for (const element of elements) {
+        const selector = element.selector;
+        if (!selectorCache.has(selector)) {
+            const fresh = await browserInstance.$$(selector);
+            selectorCache.set(selector, fresh);
+            selectorIndex.set(selector, 0);
+        }
+        const idx = selectorIndex.get(selector);
+        const cached = selectorCache.get(selector);
+        const el = idx < cached.length ? cached[idx] : element;
+        selectorIndex.set(selector, idx + 1);
+        const bcr = await browserInstance.execute(rawDocumentBcr, el);
+        regionsFromElements.push(bcr);
+    }
+    return [...regions, ...regionsFromElements]
+        .map((region) => {
+        const left = Math.floor(region.x * devicePixelRatio);
+        const right = Math.ceil((region.x + region.width) * devicePixelRatio);
+        // On mobile full-page scroll-and-stitch, the canvas crops cropTop (e.g. 6px) from the top
+        // of each tile, so canvas y = (documentY - cropTop) × DPR
+        const topDevice = Math.floor((region.y - cropTop) * devicePixelRatio);
+        const bottomDevice = Math.ceil((region.y + region.height - cropTop) * devicePixelRatio);
+        const top = Math.max(0, topDevice);
+        const bottom = Math.max(top, bottomDevice);
+        let x = left;
+        let y = top;
+        let width = right - left;
+        let height = bottom - top;
+        if (padding > 0) {
+            x = Math.max(0, x - padding);
+            y = Math.max(0, y - padding);
+            width += 2 * padding;
+            height += 2 * padding;
+        }
+        return { x, y, width, height };
+    });
+}
+/**
+ * Translate ignores to regions for web element screenshots.
+ * By default regions are in *element-local* device pixels so they match the cropped element image
+ * (BiDi clip or fallback full-screenshot crop, both at device pixel size).
+ * Exception: when the element screenshot is from the native driver on Android native web
+ * (isWebDriverElementScreenshot && isAndroidNativeWebScreenshot), the driver returns an image at
+ * CSS pixel size (downscaled). We then output regions in CSS pixel coordinates (divide by DPR)
+ * so they align with that image. Fallback (full screenshot + crop) is at device size, so we do
+ * not downscale when fallback was used.
+ */
+export async function determineWebElementIgnoreRegions(options, ignores) {
+    const awaitedIgnores = await Promise.all(ignores);
+    const { elements, regions } = splitIgnores(awaitedIgnores);
+    const { browserInstance, devicePixelRatio, rootElement, ignoreRegionPadding: padding, isAndroidNativeWebScreenshot, isWebDriverElementScreenshot, } = options;
+    // Compute bounding boxes relative to the root element: (childBCR - rootBCR)
+    const rawRelativeBcr = (el, root) => {
+        const elRect = el.getBoundingClientRect();
+        const rootRect = root.getBoundingClientRect();
+        return {
+            x: elRect.x - rootRect.x,
+            y: elRect.y - rootRect.y,
+            width: elRect.width,
+            height: elRect.height,
+        };
+    };
+    const regionsFromElements = [];
+    const selectorCache = new Map();
+    const selectorIndex = new Map();
+    for (const element of elements) {
+        const selector = element.selector;
+        if (!selectorCache.has(selector)) {
+            const fresh = await browserInstance.$$(selector);
+            selectorCache.set(selector, fresh);
+            selectorIndex.set(selector, 0);
+        }
+        const idx = selectorIndex.get(selector);
+        const cached = selectorCache.get(selector);
+        const el = idx < cached.length ? cached[idx] : element;
+        selectorIndex.set(selector, idx + 1);
+        const bcr = await browserInstance.execute(rawRelativeBcr, el, rootElement);
+        regionsFromElements.push(bcr);
+    }
+    // Both literal regions and element-derived regions are currently expected
+    // to be in CSS pixels relative to the element. Scale everything by DPR and
+    // express as device-pixel rectangles using the same floor-based rounding
+    // strategy as the BiDi element clip (x/y/width/height all floored).
+    // Then expand each region by ignoreRegionPadding on each side (configurable, default 1)
+    // to reduce 1px boundary differences on high-DPR / BiDi.
+    let result = [...regions, ...regionsFromElements]
+        .map((region) => {
+        let x = Math.floor(region.x * devicePixelRatio);
+        let y = Math.floor(region.y * devicePixelRatio);
+        let width = Math.floor(region.width * devicePixelRatio);
+        let height = Math.floor(region.height * devicePixelRatio);
+        if (padding > 0) {
+            x = Math.max(0, x - padding);
+            y = Math.max(0, y - padding);
+            width += 2 * padding;
+            height += 2 * padding;
+        }
+        return { x, y, width, height };
+    });
+    // Only downscale when the element image is at CSS pixel size: native driver element screenshot
+    // on Android native web (fallback false). Fallback uses a device-pixel crop, so no downscale.
+    if (isAndroidNativeWebScreenshot === true && isWebDriverElementScreenshot === true && devicePixelRatio > 0) {
+        const dpr = devicePixelRatio;
+        result = result.map((r) => ({
+            x: Math.round(r.x / dpr),
+            y: Math.round(r.y / dpr),
+            width: Math.round(r.width / dpr),
+            height: Math.round(r.height / dpr),
+        }));
+    }
+    return result;
+}
 /**
  * Determine the device block outs
  */
@@ -211,11 +424,55 @@ export async function determineDeviceBlockOuts({ isAndroid, screenCompareOptions
     // }
     return rectangles;
 }
+/**
+ * Return a status bar rectangle for hybrid-app fallback when the overlay reports zero height.
+ * Uses IOS_OFFSETS / ANDROID_OFFSETS so the system status bar is blocked out in webview context.
+ * Android: uses device platformVersion (e.g. "14.0") as API level when present and in list; otherwise latest.
+ * iOS: keyed by screen size only (no OS version in data). When device not in list, uses latest entry.
+ */
+function getHybridAppStatusBarFallback(deviceRectangles, isAndroid, platformVersion) {
+    const { width: screenWidth, height: screenHeight } = deviceRectangles.screenSize;
+    if (screenWidth === 0 || screenHeight === 0) {
+        return null;
+    }
+    if (isAndroid) {
+        const apiLevels = Object.keys(ANDROID_OFFSETS).map(Number);
+        const latestApiLevel = apiLevels.length > 0 ? Math.max(...apiLevels) : 14;
+        const deviceApiLevel = platformVersion !== undefined ? parseInt(platformVersion, 10) : NaN;
+        const useApiLevel = Number.isInteger(deviceApiLevel) && apiLevels.includes(deviceApiLevel)
+            ? deviceApiLevel
+            : latestApiLevel;
+        const statusBarHeight = ANDROID_OFFSETS[useApiLevel]?.STATUS_BAR ?? 24;
+        return {
+            x: 0,
+            y: 0,
+            width: screenWidth,
+            height: statusBarHeight,
+        };
+    }
+    const isIphone = screenWidth < 1024 && screenHeight < 1024;
+    const deviceType = isIphone ? 'IPHONE' : 'IPAD';
+    const portraitHeight = screenWidth > screenHeight ? screenWidth : screenHeight;
+    const keys = Object.keys(IOS_OFFSETS[deviceType]).map(Number);
+    const exactMatch = keys.includes(portraitHeight);
+    const offsetPortraitHeight = exactMatch
+        ? portraitHeight
+        : (keys.length > 0 ? Math.max(...keys) : (isIphone ? 667 : 1024));
+    const orientation = screenWidth > screenHeight ? 'LANDSCAPE' : 'PORTRAIT';
+    const currentOffsets = IOS_OFFSETS[deviceType][offsetPortraitHeight]?.[orientation];
+    const statusBarHeight = currentOffsets?.STATUS_BAR ?? (isIphone ? 44 : 20);
+    return {
+        x: 0,
+        y: 0,
+        width: screenWidth,
+        height: statusBarHeight,
+    };
+}
 /**
  * Prepare all ignore rectangles for image comparison
  */
 export async function prepareIgnoreRectangles(options) {
-    const { blockOut, ignoreRegions, deviceRectangles, devicePixelRatio, isMobile, isNativeContext, isAndroid, isAndroidNativeWebScreenshot, isViewPortScreenshot, imageCompareOptions, actualFilePath } = options;
+    const { blockOut, ignoreRegions, deviceRectangles, devicePixelRatio, isMobile, isNativeContext, isAndroid, isAndroidNativeWebScreenshot, isViewPortScreenshot, imageCompareOptions, isHybridApp, platformVersion, actualFilePath } = options;
     // Get blockOut rectangles
     let webStatusAddressToolBarOptions = [];
     // Handle mobile web status/address/toolbar rectangles
@@ -230,6 +487,16 @@ export async function prepareIgnoreRectangles(options) {
             isViewPortScreenshot,
         };
         webStatusAddressToolBarOptions.push(...(determineStatusAddressToolBarRectangles({ deviceRectangles, options: statusAddressToolBarOptions })) || []);
+        // Hybrid-app fallback: in webview the overlay often reports statusBarAndAddressBar height 0.
+        // Use native offsets (IOS_OFFSETS / ANDROID_OFFSETS) so the system status bar is still blocked out.
+        const needStatusBarFallback = imageCompareOptions.blockOutStatusBar !== false &&
+            (isHybridApp === true || deviceRectangles.statusBarAndAddressBar.height === 0);
+        if (needStatusBarFallback) {
+            const fallback = getHybridAppStatusBarFallback(deviceRectangles, isAndroid, platformVersion);
+            if (fallback && fallback.height > 0) {
+                webStatusAddressToolBarOptions.push(fallback);
+            }
+        }
         if (webStatusAddressToolBarOptions.length > 0) {
             // There's an issue with the resemble lib when all the rectangles are 0,0,0,0, it will see this as a full
             // blockout of the image and the comparison will succeed with 0 % difference.
@@ -268,29 +535,36 @@ export async function prepareIgnoreRectangles(options) {
             }
         }
     }
-    // Combine all ignore regions
-    const ignoredBoxes = [
-        // These come from the method
+    // blockOut and device bar rectangles are in CSS pixels, scale by DPR
+    const dprScaledBoxes = [
         ...blockOut,
-        // @TODO: I'm defaulting ignore regions for devices
-        // Need to check if this is the right thing to do for web and mobile browser tests
-        ...ignoreRegions,
-        // Only get info about the status bars when we are in the web context
         ...webStatusAddressToolBarOptions
     ]
-        .map(
-    // Make sure all the rectangles are equal to the dpr for the screenshot
-    (rectangles) => {
+        .map((rectangles) => {
         return calculateDprData({
-            // Adjust for the ResembleJS API
             bottom: rectangles.y + rectangles.height,
             right: rectangles.x + rectangles.width,
             left: rectangles.x,
             top: rectangles.y,
-        }, 
-        // For Android we don't need to do it times the pixel ratio, for all others we need to
-        isAndroid ? 1 : devicePixelRatio);
+        }, isAndroid ? 1 : devicePixelRatio);
+    });
+    // ignoreRegions: for web they are already in device pixels (pre-scaled by the caller).
+    // For native iOS app they are in logical pixels (getElementRect / statusBar/homeBar),
+    // so we scale by DPR here to match the device-pixel screenshot.
+    const isNativeIos = isNativeContext && isMobile && !isAndroid;
+    const preScaledIgnoreBoxes = ignoreRegions.map((rectangles) => {
+        const box = {
+            left: rectangles.x,
+            top: rectangles.y,
+            right: rectangles.x + rectangles.width,
+            bottom: rectangles.y + rectangles.height,
+        };
+        if (isNativeIos) {
+            return calculateDprData({ ...box }, devicePixelRatio);
+        }
+        return box;
     });
+    const ignoredBoxes = [...dprScaledBoxes, ...preScaledIgnoreBoxes];
     return {
         ignoredBoxes,
         hasIgnoreRectangles: ignoredBoxes.length > 0