@wdio/image-comparison-core 1.0.0

package/dist/commands/checkAppElement.test.js

@@ -0,0 +1,241 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkAppElement from './checkAppElement.js';
+vi.mock('../helpers/options.js', () => ({
+    methodCompareOptions: vi.fn().mockReturnValue({
+        ignoreAlpha: false,
+        ignoreAntialiasing: false,
+        ignoreColors: false,
+        ignoreLess: false,
+        ignoreNothing: false,
+        rawMisMatchPercentage: false,
+        returnAllCompareData: false,
+        saveAboveTolerance: 0,
+        scaleImagesToSameSize: false,
+    })
+}));
+vi.mock('../methods/images.js', () => ({
+    executeImageCompare: vi.fn().mockResolvedValue({
+        fileName: 'test-result.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+vi.mock('./saveAppElement.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-element.png'
+    })
+}));
+vi.mock('../helpers/utils.js', () => ({
+    extractCommonCheckVariables: vi.fn().mockImplementation((params) => ({
+        actualFolder: params.folders.actualFolder,
+        baselineFolder: params.folders.baselineFolder,
+        diffFolder: params.folders.diffFolder,
+        browserName: params.instanceData.browserName,
+        deviceName: params.instanceData.deviceName,
+        deviceRectangles: params.instanceData.deviceRectangles,
+        isAndroid: params.instanceData.isAndroid,
+        isMobile: params.instanceData.isMobile,
+        isAndroidNativeWebScreenshot: params.instanceData.nativeWebScreenshot,
+        autoSaveBaseline: params.wicOptions.autoSaveBaseline,
+        savePerInstance: params.wicOptions.savePerInstance,
+    })),
+    buildBaseExecuteCompareOptions: vi.fn().mockImplementation((params) => ({
+        compareOptions: {
+            wic: params.isElementScreenshot ? {
+                ...params.wicCompareOptions,
+                blockOutSideBar: false,
+                blockOutStatusBar: false,
+                blockOutToolBar: false,
+            } : params.wicCompareOptions,
+            method: params.methodCompareOptions,
+        },
+        devicePixelRatio: params.devicePixelRatio,
+        deviceRectangles: params.commonCheckVariables.deviceRectangles,
+        fileName: params.fileName,
+        folderOptions: {
+            autoSaveBaseline: params.commonCheckVariables.autoSaveBaseline,
+            actualFolder: params.commonCheckVariables.actualFolder,
+            baselineFolder: params.commonCheckVariables.baselineFolder,
+            diffFolder: params.commonCheckVariables.diffFolder,
+            browserName: params.commonCheckVariables.browserName,
+            deviceName: params.commonCheckVariables.deviceName,
+            isMobile: params.commonCheckVariables.isMobile,
+            savePerInstance: params.commonCheckVariables.savePerInstance,
+        },
+        isAndroid: params.commonCheckVariables.isAndroid,
+        isAndroidNativeWebScreenshot: params.commonCheckVariables.isAndroidNativeWebScreenshot,
+        ...params.additionalProperties,
+    })),
+}));
+describe('checkAppElement', () => {
+    let executeImageCompareSpy;
+    let saveAppElementSpy;
+    const baseOptions = {
+        checkElementOptions: {
+            wic: {
+                addressBarShadowPadding: 6,
+                autoElementScroll: true,
+                addIOSBezelCorners: false,
+                autoSaveBaseline: false,
+                clearFolder: false,
+                userBasedFullPageScreenshot: false,
+                enableLegacyScreenshotMethod: false,
+                formatImageName: '{tag}-{logName}-{width}x{height}-dpr-{dpr}',
+                isHybridApp: false,
+                savePerInstance: true,
+                toolBarShadowPadding: 6,
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                fullPageScrollTimeout: 1500,
+                hideScrollBars: true,
+                waitForFontsLoaded: true,
+                compareOptions: {
+                    ignoreAlpha: false,
+                    ignoreAntialiasing: false,
+                    ignoreColors: false,
+                    ignoreLess: false,
+                    ignoreNothing: false,
+                    rawMisMatchPercentage: false,
+                    returnAllCompareData: false,
+                    saveAboveTolerance: 0,
+                    scaleImagesToSameSize: false,
+                    blockOutSideBar: false,
+                    blockOutStatusBar: false,
+                    blockOutToolBar: false,
+                    createJsonReportFiles: false,
+                    diffPixelBoundingBoxProximity: 5,
+                },
+                tabbableOptions: {
+                    circle: {
+                        backgroundColor: 'rgba(255, 0, 0, 0.4)',
+                        borderColor: 'rgba(255, 0, 0, 1)',
+                        borderWidth: 1,
+                        fontColor: 'rgba(0, 0, 0, 1)',
+                        fontFamily: 'Arial',
+                        fontSize: 10,
+                        size: 10,
+                    },
+                    line: {
+                        color: 'rgba(255, 0, 0, 1)',
+                        width: 1,
+                    },
+                }
+            },
+            method: {}
+        },
+        browserInstance: { isAndroid: false },
+        element: { selector: '#test-element' },
+        folders: {
+            actualFolder: '/test/actual',
+            baselineFolder: '/test/baseline',
+            diffFolder: '/test/diff'
+        },
+        instanceData: {
+            appName: 'TestApp',
+            browserName: 'Chrome',
+            browserVersion: '118.0.0.0',
+            deviceName: 'iPhone 14',
+            devicePixelRatio: 2,
+            deviceRectangles: {
+                bottomBar: { y: 800, x: 0, width: 390, height: 0 },
+                homeBar: { x: 0, y: 780, width: 390, height: 34 },
+                leftSidePadding: { y: 0, x: 0, width: 0, height: 0 },
+                rightSidePadding: { y: 0, x: 0, width: 0, height: 0 },
+                screenSize: { height: 844, width: 390 },
+                statusBar: { x: 0, y: 0, width: 390, height: 47 },
+                statusBarAndAddressBar: { y: 0, x: 0, width: 390, height: 47 },
+                viewport: { y: 47, x: 0, width: 390, height: 733 }
+            },
+            initialDevicePixelRatio: 2,
+            isAndroid: false,
+            isIOS: true,
+            isMobile: true,
+            logName: 'test-log',
+            name: 'test-device',
+            nativeWebScreenshot: false,
+            platformName: 'iOS',
+            platformVersion: '17.0'
+        },
+        isNativeContext: true,
+        tag: 'test-element',
+        testContext: {
+            commandName: 'checkElement',
+            framework: 'vitest',
+            parent: 'test suite',
+            title: 'test title',
+            tag: 'test-tag',
+            instanceData: {
+                browser: { name: 'Chrome', version: '118.0.0.0' },
+                deviceName: 'iPhone 14',
+                platform: { name: 'iOS', version: '17.0' },
+                app: 'TestApp',
+                isMobile: true,
+                isAndroid: false,
+                isIOS: true
+            }
+        }
+    };
+    beforeEach(async () => {
+        const { executeImageCompare } = await import('../methods/images.js');
+        const saveAppElement = (await import('./saveAppElement.js')).default;
+        executeImageCompareSpy = vi.mocked(executeImageCompare);
+        saveAppElementSpy = vi.mocked(saveAppElement);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should execute checkAppElement with basic options', async () => {
+        const result = await checkAppElement(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(saveAppElementSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle Android device correctly', async () => {
+        const options = {
+            ...baseOptions,
+            browserInstance: { isAndroid: true },
+            instanceData: {
+                ...baseOptions.instanceData,
+                deviceName: 'Pixel 4',
+                isAndroid: true,
+                isIOS: false,
+                platformName: 'Android',
+                platformVersion: '11.0'
+            },
+            testContext: {
+                ...baseOptions.testContext,
+                instanceData: {
+                    ...baseOptions.testContext.instanceData,
+                    deviceName: 'Pixel 4',
+                    platform: { name: 'Android', version: '11.0' },
+                    isAndroid: true,
+                    isIOS: false
+                }
+            }
+        };
+        await checkAppElement(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should always disable block out options for element screenshots', async () => {
+        const options = {
+            ...baseOptions,
+            checkElementOptions: {
+                ...baseOptions.checkElementOptions,
+                wic: {
+                    ...baseOptions.checkElementOptions.wic,
+                    compareOptions: {
+                        ...baseOptions.checkElementOptions.wic.compareOptions,
+                        blockOutSideBar: true,
+                        blockOutStatusBar: true,
+                        blockOutToolBar: true,
+                    }
+                }
+            }
+        };
+        await checkAppElement(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+});

package/dist/commands/checkAppScreen.d.ts

@@ -0,0 +1,7 @@
+import type { ImageCompareResult } from '../methods/images.interfaces.js';
+import type { InternalCheckScreenMethodOptions } from './check.interfaces.js';
+/**
+ * Compare an image of the viewport of the screen
+ */
+export default function checkAppScreen({ browserInstance, checkScreenOptions, folders, instanceData, isNativeContext, tag, testContext, }: InternalCheckScreenMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkAppScreen.d.ts.map

package/dist/commands/checkAppScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAppScreen.d.ts","sourceRoot":"","sources":["../../src/commands/checkAppScreen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAIzE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAA;AAI7E;;GAEG;AACH,wBAA8B,cAAc,CACxC,EACI,eAAe,EACf,kBAAkB,EAClB,OAAO,EACP,YAAY,EACZ,eAAsB,EACtB,GAAG,EACH,WAAW,GACd,EAAE,gCAAgC,GACpC,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,CAqEtC"}

package/dist/commands/checkAppScreen.js

@@ -0,0 +1,73 @@
+import { screenMethodCompareOptions } from '../helpers/options.js';
+import { executeImageCompare } from '../methods/images.js';
+import { determineDeviceBlockOuts, determineIgnoreRegions } from '../methods/rectangles.js';
+import { extractCommonCheckVariables, buildBaseExecuteCompareOptions } from '../helpers/utils.js';
+import saveAppScreen from './saveAppScreen.js';
+/**
+ * Compare an image of the viewport of the screen
+ */
+export default async function checkAppScreen({ browserInstance, checkScreenOptions, folders, instanceData, isNativeContext = true, tag, testContext, }) {
+    // 1. Set some variables
+    const commonCheckVariables = extractCommonCheckVariables({ folders, instanceData, wicOptions: checkScreenOptions.wic });
+    const saveAppScreenOptions = {
+        wic: checkScreenOptions.wic,
+        method: {
+            ...{ hideElements: [] },
+            ...{ removeElements: [] },
+        }
+    };
+    const screenCompareOptions = {
+        ...checkScreenOptions.wic.compareOptions,
+        ...checkScreenOptions.method,
+        // Use the hide and remove elements from the checkScreenOptions and add them to the ignore array
+        ignore: [
+            ...checkScreenOptions.method.ignore || [],
+            ...checkScreenOptions.method.hideElements || [],
+            ...checkScreenOptions.method.removeElements || [],
+        ]
+    };
+    // 2. Take the actual screenshot and retrieve the needed data
+    const { devicePixelRatio, fileName } = await saveAppScreen({
+        browserInstance,
+        folders,
+        instanceData,
+        isNativeContext,
+        saveScreenOptions: saveAppScreenOptions,
+        tag,
+    });
+    // 3. Determine the ignore regions and compare options
+    const ignoreRegions = await determineIgnoreRegions(browserInstance, screenCompareOptions.ignore || []);
+    const deviceIgnoreRegions = await determineDeviceBlockOuts({
+        isAndroid: commonCheckVariables.isAndroid,
+        screenCompareOptions,
+        instanceData,
+    });
+    const methodCompareOptions = screenMethodCompareOptions(checkScreenOptions.method);
+    const baseExecuteCompareOptions = buildBaseExecuteCompareOptions({
+        commonCheckVariables,
+        wicCompareOptions: checkScreenOptions.wic.compareOptions,
+        methodCompareOptions,
+        devicePixelRatio,
+        fileName,
+        additionalProperties: {
+            ignoreRegions: [...ignoreRegions, ...deviceIgnoreRegions],
+        }
+    });
+    // 4. Now execute the compare and return the data
+    const executeCompareOptions = {
+        compareOptions: baseExecuteCompareOptions.compareOptions,
+        devicePixelRatio: baseExecuteCompareOptions.devicePixelRatio,
+        deviceRectangles: baseExecuteCompareOptions.deviceRectangles,
+        fileName: baseExecuteCompareOptions.fileName,
+        folderOptions: baseExecuteCompareOptions.folderOptions,
+        ignoreRegions: baseExecuteCompareOptions.ignoreRegions,
+        isAndroid: baseExecuteCompareOptions.isAndroid,
+        isAndroidNativeWebScreenshot: baseExecuteCompareOptions.isAndroidNativeWebScreenshot,
+    };
+    return executeImageCompare({
+        isViewPortScreenshot: true,
+        isNativeContext,
+        options: executeCompareOptions,
+        testContext,
+    });
+}

package/dist/commands/checkAppScreen.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkAppScreen.test.d.ts.map

package/dist/commands/checkAppScreen.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAppScreen.test.d.ts","sourceRoot":"","sources":["../../src/commands/checkAppScreen.test.ts"],"names":[],"mappings":""}

package/dist/commands/checkAppScreen.test.js

@@ -0,0 +1,295 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkAppScreen from './checkAppScreen.js';
+import { BASE_CHECK_OPTIONS } from '../mocks/mocks.js';
+vi.mock('../helpers/options.js', () => ({
+    screenMethodCompareOptions: vi.fn().mockReturnValue({
+        ignoreAlpha: false,
+        ignoreAntialiasing: false,
+        ignoreColors: false,
+        ignoreLess: false,
+        ignoreNothing: false,
+        rawMisMatchPercentage: false,
+        returnAllCompareData: false,
+        saveAboveTolerance: 0,
+        scaleImagesToSameSize: false,
+    })
+}));
+vi.mock('../methods/images.js', () => ({
+    executeImageCompare: vi.fn().mockResolvedValue({
+        fileName: 'test-result.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+vi.mock('../methods/rectangles.js', () => ({
+    determineIgnoreRegions: vi.fn().mockResolvedValue([
+        { x: 0, y: 0, width: 100, height: 100 }
+    ]),
+    determineDeviceBlockOuts: vi.fn().mockResolvedValue([
+        { x: 0, y: 0, width: 50, height: 50 }
+    ])
+}));
+vi.mock('./saveAppScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-screen.png'
+    })
+}));
+vi.mock('../helpers/utils.js', () => ({
+    extractCommonCheckVariables: vi.fn().mockImplementation((params) => ({
+        actualFolder: params.folders.actualFolder,
+        baselineFolder: params.folders.baselineFolder,
+        diffFolder: params.folders.diffFolder,
+        browserName: params.instanceData.browserName,
+        deviceName: params.instanceData.deviceName,
+        deviceRectangles: params.instanceData.deviceRectangles,
+        isAndroid: params.instanceData.isAndroid,
+        isMobile: params.instanceData.isMobile,
+        isAndroidNativeWebScreenshot: params.instanceData.nativeWebScreenshot,
+        autoSaveBaseline: params.wicOptions.autoSaveBaseline,
+        savePerInstance: params.wicOptions.savePerInstance,
+    })),
+    buildBaseExecuteCompareOptions: vi.fn().mockImplementation((params) => ({
+        compareOptions: {
+            wic: params.wicCompareOptions,
+            method: params.methodCompareOptions,
+        },
+        devicePixelRatio: params.devicePixelRatio,
+        deviceRectangles: params.commonCheckVariables.deviceRectangles,
+        fileName: params.fileName,
+        folderOptions: {
+            autoSaveBaseline: params.commonCheckVariables.autoSaveBaseline,
+            actualFolder: params.commonCheckVariables.actualFolder,
+            baselineFolder: params.commonCheckVariables.baselineFolder,
+            diffFolder: params.commonCheckVariables.diffFolder,
+            browserName: params.commonCheckVariables.browserName,
+            deviceName: params.commonCheckVariables.deviceName,
+            isMobile: params.commonCheckVariables.isMobile,
+            savePerInstance: params.commonCheckVariables.savePerInstance,
+        },
+        isAndroid: params.commonCheckVariables.isAndroid,
+        isAndroidNativeWebScreenshot: params.commonCheckVariables.isAndroidNativeWebScreenshot,
+        ignoreRegions: params.additionalProperties?.ignoreRegions || [],
+    })),
+}));
+describe('checkAppScreen', () => {
+    let executeImageCompareSpy;
+    let saveAppScreenSpy;
+    let determineIgnoreRegionsSpy;
+    let determineDeviceBlockOutsSpy;
+    const baseOptions = {
+        checkScreenOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: {
+                hideElements: [],
+                removeElements: [],
+                ignore: [],
+                blockOut: [],
+                blockOutSideBar: false,
+                blockOutStatusBar: false,
+                blockOutToolBar: false,
+                ignoreAlpha: false,
+                ignoreAntialiasing: false,
+                ignoreColors: false,
+                ignoreLess: false,
+                ignoreNothing: false,
+                rawMisMatchPercentage: false,
+                returnAllCompareData: false,
+                saveAboveTolerance: 0,
+                scaleImagesToSameSize: false,
+            }
+        },
+        browserInstance: { isAndroid: false },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: true,
+        tag: 'test-screen',
+        testContext: BASE_CHECK_OPTIONS.testContext
+    };
+    beforeEach(async () => {
+        const { executeImageCompare } = await import('../methods/images.js');
+        const { determineIgnoreRegions, determineDeviceBlockOuts } = await import('../methods/rectangles.js');
+        const saveAppScreen = (await import('./saveAppScreen.js')).default;
+        executeImageCompareSpy = vi.mocked(executeImageCompare);
+        determineIgnoreRegionsSpy = vi.mocked(determineIgnoreRegions);
+        determineDeviceBlockOutsSpy = vi.mocked(determineDeviceBlockOuts);
+        saveAppScreenSpy = vi.mocked(saveAppScreen);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should execute checkAppScreen with basic options', async () => {
+        const result = await checkAppScreen(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(saveAppScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle ignore regions and device blockouts', async () => {
+        const mockElement = { elementId: 'test-element', selector: '#test' };
+        const options = {
+            ...baseOptions,
+            checkScreenOptions: {
+                ...baseOptions.checkScreenOptions,
+                method: {
+                    ...baseOptions.checkScreenOptions.method,
+                    hideElements: [mockElement],
+                    removeElements: [mockElement],
+                    ignore: [mockElement]
+                }
+            }
+        };
+        await checkAppScreen(options);
+        expect(determineIgnoreRegionsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(determineDeviceBlockOutsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle Android device correctly', async () => {
+        const options = {
+            ...baseOptions,
+            browserInstance: { isAndroid: true },
+            instanceData: {
+                ...baseOptions.instanceData,
+                deviceName: 'Pixel 4',
+                isAndroid: true,
+                isIOS: false,
+                platformName: 'Android',
+                platformVersion: '11.0'
+            },
+            testContext: {
+                ...baseOptions.testContext,
+                instanceData: {
+                    ...baseOptions.testContext.instanceData,
+                    deviceName: 'Pixel 4',
+                    platform: { name: 'Android', version: '11.0' },
+                    isAndroid: true,
+                    isIOS: false
+                }
+            }
+        };
+        await checkAppScreen(options);
+        expect(determineDeviceBlockOutsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should merge compare options correctly', async () => {
+        const options = {
+            ...baseOptions,
+            checkScreenOptions: {
+                ...baseOptions.checkScreenOptions,
+                wic: {
+                    ...baseOptions.checkScreenOptions.wic,
+                    compareOptions: {
+                        ...baseOptions.checkScreenOptions.wic.compareOptions,
+                        ignoreAlpha: true,
+                        ignoreAntialiasing: true,
+                        ignoreColors: true,
+                    }
+                },
+                method: {
+                    ...baseOptions.checkScreenOptions.method,
+                    ignoreAlpha: false,
+                    ignoreAntialiasing: false,
+                    ignoreColors: false,
+                }
+            }
+        };
+        await checkAppScreen(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should spread hideElements and removeElements into ignore array', async () => {
+        const mockElement1 = { elementId: 'hide-element', selector: '#hide' };
+        const mockElement2 = { elementId: 'remove-element', selector: '#remove' };
+        const mockElement3 = { elementId: 'ignore-element', selector: '#ignore' };
+        const options = {
+            ...baseOptions,
+            checkScreenOptions: {
+                ...baseOptions.checkScreenOptions,
+                method: {
+                    ...baseOptions.checkScreenOptions.method,
+                    hideElements: [mockElement1],
+                    removeElements: [mockElement2],
+                    ignore: [mockElement3]
+                }
+            }
+        };
+        await checkAppScreen(options);
+        expect(determineIgnoreRegionsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should create screenCompareOptions with correct structure', async () => {
+        const mockElement1 = { elementId: 'hide-element', selector: '#hide' };
+        const mockElement2 = { elementId: 'remove-element', selector: '#remove' };
+        const mockElement3 = { elementId: 'ignore-element', selector: '#ignore' };
+        const options = {
+            ...baseOptions,
+            checkScreenOptions: {
+                ...baseOptions.checkScreenOptions,
+                wic: {
+                    ...baseOptions.checkScreenOptions.wic,
+                    compareOptions: {
+                        ...baseOptions.checkScreenOptions.wic.compareOptions,
+                        ignoreAlpha: true,
+                        ignoreAntialiasing: true,
+                        ignoreColors: true,
+                    }
+                },
+                method: {
+                    hideElements: [mockElement1],
+                    removeElements: [mockElement2],
+                    ignore: [mockElement3],
+                    ignoreAlpha: false,
+                    ignoreAntialiasing: false,
+                    ignoreColors: false,
+                }
+            }
+        };
+        await checkAppScreen(options);
+        expect(determineIgnoreRegionsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(determineDeviceBlockOutsSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should spread wic.compareOptions and method options into screenCompareOptions', async () => {
+        const options = {
+            ...baseOptions,
+            checkScreenOptions: {
+                ...baseOptions.checkScreenOptions,
+                wic: {
+                    ...baseOptions.checkScreenOptions.wic,
+                    compareOptions: {
+                        ignoreAlpha: true,
+                        ignoreAntialiasing: true,
+                        ignoreColors: true,
+                        blockOutSideBar: true,
+                        blockOutStatusBar: true,
+                        blockOutToolBar: true,
+                        createJsonReportFiles: true,
+                        diffPixelBoundingBoxProximity: 10,
+                        ignoreLess: true,
+                        ignoreNothing: true,
+                        rawMisMatchPercentage: true,
+                        returnAllCompareData: true,
+                        saveAboveTolerance: 1,
+                        scaleImagesToSameSize: true,
+                    }
+                },
+                method: {
+                    ignoreAlpha: false,
+                    ignoreAntialiasing: false,
+                    ignoreColors: false,
+                    blockOutSideBar: false,
+                    blockOutStatusBar: false,
+                    blockOutToolBar: false,
+                    createJsonReportFiles: false,
+                    diffPixelBoundingBoxProximity: 5,
+                    ignoreLess: false,
+                    ignoreNothing: false,
+                    rawMisMatchPercentage: false,
+                    returnAllCompareData: false,
+                    saveAboveTolerance: 0,
+                    scaleImagesToSameSize: false,
+                }
+            }
+        };
+        await checkAppScreen(options);
+        expect(determineDeviceBlockOutsSpy.mock.calls[0]).toMatchSnapshot();
+    });
+});

package/dist/commands/checkElement.d.ts

@@ -0,0 +1,7 @@
+import type { ImageCompareResult } from '../methods/images.interfaces.js';
+import type { InternalCheckElementMethodOptions } from './check.interfaces.js';
+/**
+ * Compare  an image of the element
+ */
+export default function checkElement({ browserInstance, instanceData, folders, element, tag, checkElementOptions, isNativeContext, testContext, }: InternalCheckElementMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkElement.d.ts.map

package/dist/commands/checkElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkElement.d.ts","sourceRoot":"","sources":["../../src/commands/checkElement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAGzE,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,uBAAuB,CAAA;AAE9E;;GAEG;AACH,wBAA8B,YAAY,CACtC,EACI,eAAe,EACf,YAAY,EACZ,OAAO,EACP,OAAO,EACP,GAAG,EACH,mBAAmB,EACnB,eAAe,EACf,WAAW,GACd,EAAE,iCAAiC,GACrC,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,CAItC"}

package/dist/commands/checkElement.js

@@ -0,0 +1,10 @@
+import checkAppElement from './checkAppElement.js';
+import checkWebElement from './checkWebElement.js';
+/**
+ * Compare  an image of the element
+ */
+export default async function checkElement({ browserInstance, instanceData, folders, element, tag, checkElementOptions, isNativeContext, testContext, }) {
+    return isNativeContext
+        ? checkAppElement({ browserInstance, element, folders, instanceData, checkElementOptions, isNativeContext, tag, testContext })
+        : checkWebElement({ browserInstance, element, folders, instanceData, checkElementOptions, tag, testContext });
+}

package/dist/commands/checkElement.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkElement.test.d.ts.map

package/dist/commands/checkElement.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkElement.test.d.ts","sourceRoot":"","sources":["../../src/commands/checkElement.test.ts"],"names":[],"mappings":""}