@wdio/image-comparison-core 1.0.0

package/dist/commands/saveFullPageScreen.test.js

@@ -0,0 +1,293 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import saveFullPageScreen from './saveFullPageScreen.js';
+import { createBeforeScreenshotOptions, buildAfterScreenshotOptions } from '../helpers/options.js';
+import { takeFullPageScreenshots } from '../methods/takeFullPageScreenshots.js';
+import { makeFullPageBase64Image } from '../methods/images.js';
+import afterScreenshot from '../helpers/afterScreenshot.js';
+import beforeScreenshot from '../helpers/beforeScreenshot.js';
+import { BASE_CHECK_OPTIONS, createMethodOptions } from '../mocks/mocks.js';
+import { canUseBidiScreenshot } from '../helpers/utils.js';
+vi.mock('../helpers/beforeScreenshot.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        browserName: 'chrome',
+        browserVersion: '120.0.0',
+        deviceName: 'desktop',
+        dimensions: {
+            window: {
+                devicePixelRatio: 2,
+                innerHeight: 900,
+                isEmulated: false,
+                isLandscape: false,
+                outerHeight: 1000,
+                outerWidth: 1200,
+                screenHeight: 1080,
+                screenWidth: 1920,
+            },
+        },
+        isAndroid: false,
+        isAndroidChromeDriverScreenshot: false,
+        isAndroidNativeWebScreenshot: false,
+        isIOS: false,
+        isMobile: false,
+        isTestInBrowser: true,
+        logName: 'chrome',
+        name: 'chrome',
+        platformName: 'desktop',
+        platformVersion: '120.0.0',
+    })
+}));
+vi.mock('../methods/takeFullPageScreenshots.js', () => ({
+    takeFullPageScreenshots: vi.fn().mockResolvedValue({
+        fullPageHeight: 2000,
+        fullPageWidth: 1200,
+        data: [{
+                canvasWidth: 1200,
+                canvasYPosition: 0,
+                imageHeight: 2000,
+                imageWidth: 1200,
+                imageXPosition: 0,
+                imageYPosition: 0,
+                screenshot: 'test-screenshot-data',
+            }]
+    })
+}));
+vi.mock('../methods/images.js', () => ({
+    makeFullPageBase64Image: vi.fn().mockResolvedValue('fullpage-screenshot-data')
+}));
+vi.mock('../helpers/afterScreenshot.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-fullpage.png'
+    })
+}));
+vi.mock('../helpers/utils.js', () => ({
+    canUseBidiScreenshot: vi.fn().mockReturnValue(false),
+    getMethodOrWicOption: vi.fn().mockImplementation((method, wic, option) => {
+        return method[option] ?? wic[option];
+    })
+}));
+vi.mock('../helpers/options.js', () => ({
+    createBeforeScreenshotOptions: vi.fn().mockReturnValue({
+        instanceData: { test: 'data' },
+        addressBarShadowPadding: 6,
+        toolBarShadowPadding: 6,
+        disableBlinkingCursor: false,
+        disableCSSAnimation: false,
+        enableLayoutTesting: false,
+        hideElements: [],
+        noScrollBars: false,
+        removeElements: [],
+        waitForFontsLoaded: false,
+    }),
+    buildAfterScreenshotOptions: vi.fn().mockReturnValue({
+        actualFolder: '/test/actual',
+        base64Image: 'fullpage-screenshot-data',
+        disableBlinkingCursor: false,
+        disableCSSAnimation: false,
+        enableLayoutTesting: false,
+        filePath: {
+            browserName: 'chrome',
+            deviceName: 'desktop',
+            isMobile: false,
+            savePerInstance: false,
+        },
+        fileName: {
+            browserName: 'chrome',
+            browserVersion: '120.0.0',
+            deviceName: 'desktop',
+            devicePixelRatio: 2,
+            formatImageName: '{tag}-{browserName}-{width}x{height}',
+            isMobile: false,
+            isTestInBrowser: true,
+            logName: 'chrome',
+            name: 'chrome',
+            outerHeight: 1000,
+            outerWidth: 1200,
+            platformName: 'desktop',
+            platformVersion: '120.0.0',
+            screenHeight: 1080,
+            screenWidth: 1920,
+            tag: 'test-fullpage'
+        },
+        hideElements: [],
+        hideScrollBars: false,
+        isLandscape: false,
+        isNativeContext: false,
+        platformName: 'desktop',
+        removeElements: [],
+    })
+}));
+describe('saveFullPageScreen', () => {
+    let createBeforeScreenshotOptionsSpy;
+    let buildAfterScreenshotOptionsSpy;
+    let takeFullPageScreenshotsSpy;
+    let makeFullPageBase64ImageSpy;
+    let afterScreenshotSpy;
+    let canUseBidiScreenshotSpy;
+    let beforeScreenshotSpy;
+    const createBidiMockData = (screenshot) => ({
+        fullPageHeight: -1,
+        fullPageWidth: -1,
+        data: [{
+                canvasWidth: 0,
+                canvasYPosition: 0,
+                imageHeight: 0,
+                imageWidth: 0,
+                imageXPosition: 0,
+                imageYPosition: 0,
+                screenshot,
+            }]
+    });
+    const baseOptions = {
+        browserInstance: { isAndroid: false, isMobile: false },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: false,
+        saveFullPageOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: createMethodOptions({
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                enableLegacyScreenshotMethod: false,
+                hideScrollBars: true,
+                hideElements: [],
+                removeElements: [],
+                waitForFontsLoaded: true,
+            })
+        },
+        tag: 'test-fullpage'
+    };
+    beforeEach(async () => {
+        createBeforeScreenshotOptionsSpy = vi.mocked(createBeforeScreenshotOptions);
+        buildAfterScreenshotOptionsSpy = vi.mocked(buildAfterScreenshotOptions);
+        takeFullPageScreenshotsSpy = vi.mocked(takeFullPageScreenshots);
+        makeFullPageBase64ImageSpy = vi.mocked(makeFullPageBase64Image);
+        afterScreenshotSpy = vi.mocked(afterScreenshot);
+        canUseBidiScreenshotSpy = vi.mocked(canUseBidiScreenshot);
+        beforeScreenshotSpy = vi.mocked(beforeScreenshot);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should throw an error when in native context', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: true
+        };
+        await expect(saveFullPageScreen(options)).rejects.toThrow('The method saveFullPageScreen is not supported in native context for native mobile apps!');
+    });
+    it('should use BiDi when conditions are met', async () => {
+        canUseBidiScreenshotSpy.mockReturnValueOnce(true);
+        takeFullPageScreenshotsSpy.mockResolvedValueOnce(createBidiMockData('test-bidi-screenshot-data'));
+        const options = {
+            ...baseOptions,
+            saveFullPageOptions: {
+                ...baseOptions.saveFullPageOptions,
+                method: createMethodOptions({
+                    userBasedFullPageScreenshot: false,
+                    enableLegacyScreenshotMethod: false
+                })
+            }
+        };
+        await saveFullPageScreen(options);
+        expect(takeFullPageScreenshotsSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should use BiDi when canUseBidiScreenshot=true, userBasedFullPageScreenshot=true, enableLegacyScreenshotMethod=false', async () => {
+        canUseBidiScreenshotSpy.mockReturnValueOnce(true);
+        takeFullPageScreenshotsSpy.mockResolvedValueOnce(createBidiMockData('test-bidi-screenshot-data-2'));
+        const options = {
+            ...baseOptions,
+            saveFullPageOptions: {
+                ...baseOptions.saveFullPageOptions,
+                method: createMethodOptions({
+                    userBasedFullPageScreenshot: true,
+                    enableLegacyScreenshotMethod: false
+                })
+            }
+        };
+        await saveFullPageScreen(options);
+        expect(takeFullPageScreenshotsSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should not use BiDi when canUseBidiScreenshot=true, userBasedFullPageScreenshot=false, enableLegacyScreenshotMethod=true', async () => {
+        canUseBidiScreenshotSpy.mockReturnValueOnce(true);
+        const options = {
+            ...baseOptions,
+            saveFullPageOptions: {
+                ...baseOptions.saveFullPageOptions,
+                method: createMethodOptions({
+                    userBasedFullPageScreenshot: false,
+                    enableLegacyScreenshotMethod: true
+                })
+            }
+        };
+        await saveFullPageScreen(options);
+        expect(takeFullPageScreenshotsSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should take full page screenshots and return result', async () => {
+        const result = await saveFullPageScreen(baseOptions);
+        expect(createBeforeScreenshotOptionsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(takeFullPageScreenshotsSpy.mock.calls[0]).toMatchSnapshot();
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(makeFullPageBase64ImageSpy.mock.calls[0]).toMatchSnapshot();
+        expect(afterScreenshotSpy.mock.calls[0][1]).toMatchSnapshot();
+        expect(result).toEqual({
+            devicePixelRatio: 2,
+            fileName: 'test-fullpage.png'
+        });
+    });
+    it('should handle missing dimension values with NaN fallbacks', async () => {
+        beforeScreenshotSpy.mockResolvedValueOnce({
+            browserName: 'chrome',
+            browserVersion: '120.0.0',
+            deviceName: 'desktop',
+            dimensions: {
+                body: {
+                    scrollHeight: 2000,
+                    offsetHeight: 1000,
+                },
+                html: {
+                    clientWidth: 1200,
+                    scrollWidth: 1200,
+                    clientHeight: 1000,
+                    scrollHeight: 2000,
+                    offsetHeight: 1000,
+                },
+                window: {
+                    devicePixelRatio: undefined,
+                    innerHeight: undefined,
+                    isEmulated: false,
+                    isLandscape: false,
+                    outerHeight: undefined,
+                    outerWidth: undefined,
+                    screenHeight: undefined,
+                    screenWidth: undefined,
+                },
+            },
+            isAndroid: false,
+            isAndroidChromeDriverScreenshot: false,
+            isAndroidNativeWebScreenshot: false,
+            isIOS: false,
+            isMobile: false,
+            isTestInBrowser: true,
+            logName: 'chrome',
+            name: 'chrome',
+            platformName: 'desktop',
+            platformVersion: '120.0.0',
+            isTestInMobileBrowser: false,
+            addressBarShadowPadding: 6,
+            toolBarShadowPadding: 6,
+            appName: 'test-app',
+            elementAddressBarPadding: 0,
+            elementToolBarPadding: 0,
+            pixelDensity: 1,
+        });
+        const result = await saveFullPageScreen(baseOptions);
+        expect(buildAfterScreenshotOptionsSpy.mock.calls[0][0]).toMatchSnapshot();
+        expect(makeFullPageBase64ImageSpy.mock.calls[0]).toMatchSnapshot();
+        expect(result).toEqual({
+            devicePixelRatio: 2,
+            fileName: 'test-fullpage.png'
+        });
+    });
+});

package/dist/commands/saveScreen.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenshotOutput } from '../helpers/afterScreenshot.interfaces.js';
+import type { InternalSaveScreenMethodOptions } from './save.interfaces.js';
+/**
+ * Saves an image of the viewport of the desktop browser or the screen of a mobile device
+ */
+export default function saveScreen({ browserInstance, folders, instanceData, isNativeContext, tag, saveScreenOptions, }: InternalSaveScreenMethodOptions): Promise<ScreenshotOutput>;
+//# sourceMappingURL=saveScreen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"saveScreen.d.ts","sourceRoot":"","sources":["../../src/commands/saveScreen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAGhF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAA;AAE3E;;GAEG;AACH,wBAA8B,UAAU,CACpC,EACI,eAAe,EACf,OAAO,EACP,YAAY,EACZ,eAAe,EACf,GAAG,EACH,iBAAiB,GACpB,EAAE,+BAA+B,GACnC,OAAO,CAAC,gBAAgB,CAAC,CAI3B"}

package/dist/commands/saveScreen.js

@@ -0,0 +1,10 @@
+import saveAppScreen from './saveAppScreen.js';
+import saveWebScreen from './saveWebScreen.js';
+/**
+ * Saves an image of the viewport of the desktop browser or the screen of a mobile device
+ */
+export default async function saveScreen({ browserInstance, folders, instanceData, isNativeContext, tag, saveScreenOptions, }) {
+    return isNativeContext
+        ? saveAppScreen({ browserInstance, folders, instanceData, isNativeContext, saveScreenOptions, tag })
+        : saveWebScreen({ browserInstance, folders, instanceData, isNativeContext, saveScreenOptions, tag });
+}

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

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

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

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

package/dist/commands/saveScreen.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import saveScreen from './saveScreen.js';
+import { createBaseOptions } from '../mocks/mocks.js';
+vi.mock('./saveAppScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-app-screen.png'
+    })
+}));
+vi.mock('./saveWebScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-web-screen.png'
+    })
+}));
+describe('saveScreen', () => {
+    let saveAppScreen;
+    let saveWebScreen;
+    const baseOptions = createBaseOptions('screen');
+    beforeEach(async () => {
+        saveAppScreen = (await import('./saveAppScreen.js')).default;
+        saveWebScreen = (await import('./saveWebScreen.js')).default;
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should call saveAppScreen when in native context', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: true
+        };
+        const result = await saveScreen(options);
+        expect(result).toMatchSnapshot();
+        expect(saveAppScreen).toHaveBeenCalledWith(options);
+        expect(saveWebScreen).not.toHaveBeenCalled();
+    });
+    it('should call saveWebScreen when not in native context', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: false
+        };
+        const result = await saveScreen(options);
+        expect(result).toMatchSnapshot();
+        expect(saveWebScreen).toHaveBeenCalledWith(options);
+        expect(saveAppScreen).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/saveTabbablePage.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenshotOutput } from '../helpers/afterScreenshot.interfaces.js';
+import type { InternalSaveTabbablePageMethodOptions } from './save.interfaces.js';
+/**
+ * Saves an image of all tab executions
+ */
+export default function saveTabbablePage({ browserInstance, instanceData, isNativeContext, folders, tag, saveTabbableOptions, }: InternalSaveTabbablePageMethodOptions): Promise<ScreenshotOutput>;
+//# sourceMappingURL=saveTabbablePage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"saveTabbablePage.d.ts","sourceRoot":"","sources":["../../src/commands/saveTabbablePage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAIhF,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,sBAAsB,CAAA;AAEjF;;GAEG;AACH,wBAA8B,gBAAgB,CAC1C,EACI,eAAe,EACf,YAAY,EACZ,eAAuB,EACvB,OAAO,EACP,GAAG,EACH,mBAAmB,GACtB,EAAE,qCAAqC,GACzC,OAAO,CAAC,gBAAgB,CAAC,CAiB3B"}

package/dist/commands/saveTabbablePage.js

@@ -0,0 +1,20 @@
+import drawTabbableOnCanvas from '../clientSideScripts/drawTabbableOnCanvas.js';
+import saveFullPageScreen from './saveFullPageScreen.js';
+import removeElementFromDom from '../clientSideScripts/removeElementFromDom.js';
+/**
+ * Saves an image of all tab executions
+ */
+export default async function saveTabbablePage({ browserInstance, instanceData, isNativeContext = false, folders, tag, saveTabbableOptions, }) {
+    // 1a. Check if the method is supported in native context
+    if (isNativeContext) {
+        throw new Error('The method saveTabbablePage is not supported in native context for native mobile apps!');
+    }
+    // 1b. Inject drawing the tabbables
+    await browserInstance.execute(drawTabbableOnCanvas, saveTabbableOptions.wic.tabbableOptions);
+    // 2. Create the screenshot
+    const fullPageData = await saveFullPageScreen({ browserInstance, folders, instanceData, isNativeContext, saveFullPageOptions: saveTabbableOptions, tag });
+    // 3. Remove the canvas
+    await browserInstance.execute(removeElementFromDom, 'wic-tabbable-canvas');
+    // 4. Return the data
+    return fullPageData;
+}

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

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

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

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

package/dist/commands/saveTabbablePage.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import saveTabbablePage from './saveTabbablePage.js';
+import { BASE_CHECK_OPTIONS, createMethodOptions } from '../mocks/mocks.js';
+vi.mock('./saveFullPageScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-tabbable-page.png'
+    })
+}));
+vi.mock('../clientSideScripts/drawTabbableOnCanvas.js', () => ({
+    default: vi.fn()
+}));
+vi.mock('../clientSideScripts/removeElementFromDom.js', () => ({
+    default: vi.fn()
+}));
+describe('saveTabbablePage', () => {
+    let saveFullPageScreen;
+    const executeMock = vi.fn().mockResolvedValue(undefined);
+    const baseOptions = {
+        browserInstance: {
+            execute: executeMock,
+            isAndroid: false,
+            isMobile: false
+        },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: false,
+        saveTabbableOptions: {
+            wic: {
+                ...BASE_CHECK_OPTIONS.wic,
+                tabbableOptions: {
+                    circle: {
+                        backgroundColor: 'red',
+                        borderColor: 'blue',
+                        borderWidth: 2,
+                        fontColor: 'white',
+                        fontFamily: 'Arial',
+                        fontSize: 10,
+                        size: 10,
+                        showNumber: true
+                    },
+                    line: {
+                        color: 'blue',
+                        width: 1
+                    }
+                }
+            },
+            method: createMethodOptions()
+        },
+        tag: 'test-tabbable-page'
+    };
+    beforeEach(async () => {
+        saveFullPageScreen = (await vi.importMock('./saveFullPageScreen.js')).default;
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should throw an error when in native context', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: true
+        };
+        await expect(saveTabbablePage(options)).rejects.toThrow('The method saveTabbablePage is not supported in native context for native mobile apps!');
+        expect(executeMock).not.toHaveBeenCalled();
+        expect(saveFullPageScreen).not.toHaveBeenCalled();
+    });
+    it('should save a tabbable page screenshot', async () => {
+        const result = await saveTabbablePage(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(executeMock).toHaveBeenCalledTimes(2);
+        expect(executeMock.mock.calls).toMatchSnapshot();
+        expect(saveFullPageScreen.mock.calls).toMatchSnapshot();
+    });
+});

package/dist/commands/saveWebElement.d.ts

@@ -0,0 +1,7 @@
+import type { ScreenshotOutput } from '../helpers/afterScreenshot.interfaces.js';
+import type { InternalSaveElementMethodOptions } from './save.interfaces.js';
+/**
+ * Saves an image of an element
+ */
+export default function saveWebElement({ browserInstance, instanceData, folders, element, tag, saveElementOptions, }: InternalSaveElementMethodOptions): Promise<ScreenshotOutput>;
+//# sourceMappingURL=saveWebElement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"saveWebElement.d.ts","sourceRoot":"","sources":["../../src/commands/saveWebElement.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAOhF,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAA;AAE5E;;GAEG;AACH,wBAA8B,cAAc,CACxC,EACI,eAAe,EACf,YAAY,EACZ,OAAO,EACP,OAAO,EACP,GAAG,EACH,kBAAkB,GACrB,EAAE,gCAAgC,GACpC,OAAO,CAAC,gBAAgB,CAAC,CA+D3B"}

package/dist/commands/saveWebElement.js

@@ -0,0 +1,53 @@
+import { takeElementScreenshot } from '../methods/takeElementScreenshots.js';
+import beforeScreenshot from '../helpers/beforeScreenshot.js';
+import afterScreenshot from '../helpers/afterScreenshot.js';
+import { DEFAULT_RESIZE_DIMENSIONS } from '../helpers/constants.js';
+import { canUseBidiScreenshot, getMethodOrWicOption } from '../helpers/utils.js';
+import { createBeforeScreenshotOptions, buildAfterScreenshotOptions } from '../helpers/options.js';
+/**
+ * Saves an image of an element
+ */
+export default async function saveWebElement({ browserInstance, instanceData, folders, element, tag, saveElementOptions, }) {
+    // 1. Set some variables
+    const { addressBarShadowPadding, autoElementScroll, formatImageName, savePerInstance } = saveElementOptions.wic;
+    const enableLegacyScreenshotMethod = getMethodOrWicOption(saveElementOptions.method, saveElementOptions.wic, 'enableLegacyScreenshotMethod');
+    const resizeDimensions = saveElementOptions.method.resizeDimensions || DEFAULT_RESIZE_DIMENSIONS;
+    // 2.  Prepare the screenshot
+    const beforeOptions = createBeforeScreenshotOptions(instanceData, saveElementOptions.method, saveElementOptions.wic);
+    const enrichedInstanceData = await beforeScreenshot(browserInstance, beforeOptions, true);
+    const { deviceName, dimensions: { window: { devicePixelRatio, innerHeight, isEmulated, isLandscape, }, }, initialDevicePixelRatio, isAndroid, isAndroidChromeDriverScreenshot, isAndroidNativeWebScreenshot, isIOS, isMobile, } = enrichedInstanceData;
+    // 3. Take the screenshot
+    const elementScreenshotOptions = {
+        addressBarShadowPadding,
+        autoElementScroll,
+        deviceName,
+        devicePixelRatio: devicePixelRatio || 1,
+        deviceRectangles: instanceData.deviceRectangles,
+        element,
+        isEmulated,
+        initialDevicePixelRatio: initialDevicePixelRatio || 1,
+        innerHeight,
+        isAndroidNativeWebScreenshot,
+        isAndroidChromeDriverScreenshot,
+        isAndroid,
+        isIOS,
+        isLandscape,
+        isMobile,
+        resizeDimensions,
+        toolBarShadowPadding: beforeOptions.toolBarShadowPadding,
+    };
+    const shouldUseBidi = canUseBidiScreenshot(browserInstance) && !isMobile && !enableLegacyScreenshotMethod;
+    const screenshotData = await takeElementScreenshot(browserInstance, elementScreenshotOptions, shouldUseBidi);
+    // 4. Return the data
+    const afterOptions = buildAfterScreenshotOptions({
+        base64Image: screenshotData.base64Image,
+        folders,
+        tag,
+        isNativeContext: false,
+        instanceData,
+        enrichedInstanceData,
+        beforeOptions,
+        wicOptions: { formatImageName, savePerInstance }
+    });
+    return afterScreenshot(browserInstance, afterOptions);
+}

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

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

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

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