@wdio/image-comparison-core 1.0.0

package/dist/methods/takeElementScreenshots.js

@@ -0,0 +1,104 @@
+import logger from '@wdio/logger';
+import { takeBase64BiDiScreenshot, takeWebElementScreenshot } from './screenshots.js';
+import { makeCroppedBase64Image } from './images.js';
+import scrollElementIntoView from '../clientSideScripts/scrollElementIntoView.js';
+import scrollToPosition from '../clientSideScripts/scrollToPosition.js';
+import { getBase64ScreenshotSize, hasResizeDimensions, waitFor } from '../helpers/utils.js';
+const log = logger('@wdio/visual-service:@wdio/image-comparison-core:takeElementScreenshot');
+export async function takeElementScreenshot(browserInstance, options, shouldUseBidi = false) {
+    if (shouldUseBidi) {
+        return await takeBiDiElementScreenshot(browserInstance, options);
+    }
+    return await takeWebDriverElementScreenshot(browserInstance, options);
+}
+async function takeBiDiElementScreenshot(browserInstance, options) {
+    let base64Image;
+    const isWebDriverElementScreenshot = false;
+    // We also need to clip the image to the element size, taking into account the DPR
+    // and also clip it from the document, not the viewport
+    const rect = await browserInstance.getElementRect((await options.element).elementId);
+    const clip = { x: Math.floor(rect.x), y: Math.floor(rect.y), width: Math.floor(rect.width), height: Math.floor(rect.height) };
+    const takeBiDiElementScreenshot = (origin) => takeBase64BiDiScreenshot({ browserInstance, origin, clip });
+    try {
+        // By default we take the screenshot from the viewport
+        base64Image = await takeBiDiElementScreenshot('viewport');
+    }
+    catch (err) {
+        // But when we get a zero dimension error (meaning the element might be bigger than the
+        // viewport or it might not be in the viewport), we need to take the screenshot from the document.
+        const isZeroDimensionError = typeof err?.message === 'string' && err.message.includes('WebDriver Bidi command "browsingContext.captureScreenshot" failed with error: unable to capture screen - Unable to capture screenshot with zero dimensions');
+        if (!isZeroDimensionError) {
+            throw err;
+        }
+        base64Image = await takeBiDiElementScreenshot('document');
+    }
+    return {
+        base64Image,
+        isWebDriverElementScreenshot,
+    };
+}
+async function takeWebDriverElementScreenshot(browserInstance, options) {
+    let base64Image;
+    let isWebDriverElementScreenshot = false;
+    // Scroll the element into top of the viewport and return the current scroll position
+    let currentPosition;
+    if (options.autoElementScroll) {
+        currentPosition = await browserInstance.execute(scrollElementIntoView, options.element, options.addressBarShadowPadding);
+        // We need to wait for the scroll to finish before taking the screenshot
+        await waitFor(100);
+    }
+    // Take the screenshot and determine the rectangles
+    const screenshotResult = await takeWebElementScreenshot({
+        addressBarShadowPadding: options.addressBarShadowPadding,
+        browserInstance,
+        devicePixelRatio: options.devicePixelRatio,
+        deviceRectangles: options.deviceRectangles,
+        element: options.element,
+        initialDevicePixelRatio: options.initialDevicePixelRatio,
+        isEmulated: options.isEmulated,
+        innerHeight: options.innerHeight,
+        isAndroid: options.isAndroid,
+        isAndroidChromeDriverScreenshot: options.isAndroidChromeDriverScreenshot,
+        isAndroidNativeWebScreenshot: options.isAndroidNativeWebScreenshot,
+        isIOS: options.isIOS,
+        isLandscape: options.isLandscape,
+        toolBarShadowPadding: options.toolBarShadowPadding,
+        // When the element needs to be resized, we need to take a screenshot of the whole page
+        // also when it's emulated
+        fallback: (hasResizeDimensions(options.resizeDimensions) || options.isEmulated) || false,
+    });
+    base64Image = screenshotResult.base64Image;
+    const { rectangles } = screenshotResult;
+    isWebDriverElementScreenshot = screenshotResult.isWebDriverElementScreenshot;
+    // When the screenshot has been taken and the element position has been determined,
+    // we can scroll back to the original position
+    // We don't need to wait for the scroll here because we don't take a screenshot after this
+    if (options.autoElementScroll && currentPosition) {
+        await browserInstance.execute(scrollToPosition, currentPosition);
+    }
+    // When the element has no height or width, we default to the viewport screen size
+    if (rectangles.width === 0 || rectangles.height === 0) {
+        const { height, width } = getBase64ScreenshotSize(base64Image);
+        rectangles.width = width;
+        rectangles.height = height;
+        rectangles.x = 0;
+        rectangles.y = 0;
+        log.error(`The element has no width or height. We defaulted to the viewport screen size of width: ${width} and height: ${height}.`);
+    }
+    // Make a cropped base64 image with resizeDimensions
+    base64Image = await makeCroppedBase64Image({
+        addIOSBezelCorners: false,
+        base64Image,
+        deviceName: options.deviceName,
+        devicePixelRatio: options.devicePixelRatio || NaN,
+        isWebDriverElementScreenshot,
+        isIOS: options.isIOS,
+        isLandscape: options.isLandscape,
+        rectangles,
+        resizeDimensions: options.resizeDimensions,
+    });
+    return {
+        base64Image,
+        isWebDriverElementScreenshot,
+    };
+}

package/dist/methods/takeElementScreenshots.test.d.ts

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

package/dist/methods/takeElementScreenshots.test.d.ts.map

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

package/dist/methods/takeElementScreenshots.test.js

@@ -0,0 +1,314 @@
+import { beforeEach, describe, it, expect, vi, afterEach } from 'vitest';
+import { join } from 'node:path';
+import logger from '@wdio/logger';
+import { takeElementScreenshot } from './takeElementScreenshots.js';
+import { takeBase64BiDiScreenshot, takeWebElementScreenshot } from './screenshots.js';
+import { makeCroppedBase64Image } from './images.js';
+import { getBase64ScreenshotSize, waitFor, hasResizeDimensions } from '../helpers/utils.js';
+const log = logger('test');
+vi.mock('./screenshots.js', () => ({
+    takeBase64BiDiScreenshot: vi.fn().mockResolvedValue('bidi-screenshot-data'),
+    takeWebElementScreenshot: vi.fn().mockResolvedValue({
+        base64Image: 'web-element-screenshot-data',
+        rectangles: { x: 0, y: 0, width: 100, height: 100 },
+        isWebDriverElementScreenshot: false
+    })
+}));
+vi.mock('./images.js', () => ({
+    makeCroppedBase64Image: vi.fn().mockResolvedValue('cropped-screenshot-data')
+}));
+vi.mock('../clientSideScripts/scrollElementIntoView.js', () => ({
+    default: vi.fn()
+}));
+vi.mock('../clientSideScripts/scrollToPosition.js', () => ({
+    default: vi.fn()
+}));
+vi.mock('../helpers/utils.js', () => ({
+    getBase64ScreenshotSize: vi.fn().mockReturnValue({ width: 100, height: 100 }),
+    waitFor: vi.fn().mockResolvedValue(undefined),
+    hasResizeDimensions: vi.fn().mockReturnValue(false)
+}));
+vi.mock('@wdio/logger', () => import(join(process.cwd(), '__mocks__', '@wdio/logger')));
+describe('takeElementScreenshot', () => {
+    const takeBase64BiDiScreenshotSpy = vi.mocked(takeBase64BiDiScreenshot);
+    const takeWebElementScreenshotSpy = vi.mocked(takeWebElementScreenshot);
+    const makeCroppedBase64ImageSpy = vi.mocked(makeCroppedBase64Image);
+    const getBase64ScreenshotSizeSpy = vi.mocked(getBase64ScreenshotSize);
+    const waitForSpy = vi.mocked(waitFor);
+    const hasResizeDimensionsSpy = vi.mocked(hasResizeDimensions);
+    const executeMock = vi.fn().mockResolvedValue(undefined);
+    const getElementRectMock = vi.fn().mockResolvedValue({ x: 10, y: 20, width: 100, height: 200 });
+    const browserInstance = {
+        execute: executeMock,
+        getElementRect: getElementRectMock
+    };
+    const baseOptions = {
+        addressBarShadowPadding: 6,
+        autoElementScroll: false,
+        deviceName: 'desktop',
+        devicePixelRatio: 2,
+        deviceRectangles: {
+            bottomBar: { height: 0, width: 390, x: 0, y: 800 },
+            homeBar: { height: 34, width: 390, x: 0, y: 780 },
+            leftSidePadding: { height: 0, width: 0, x: 0, y: 0 },
+            rightSidePadding: { height: 0, width: 0, x: 0, y: 0 },
+            screenSize: { height: 844, width: 390 },
+            statusBar: { height: 47, width: 390, x: 0, y: 0 },
+            statusBarAndAddressBar: { height: 47, width: 390, x: 0, y: 0 },
+            viewport: { height: 733, width: 390, x: 0, y: 47 }
+        },
+        element: { elementId: 'test-element' },
+        isEmulated: false,
+        initialDevicePixelRatio: 2,
+        innerHeight: 900,
+        isAndroid: false,
+        isAndroidChromeDriverScreenshot: false,
+        isAndroidNativeWebScreenshot: false,
+        isIOS: false,
+        isLandscape: false,
+        isMobile: false,
+        resizeDimensions: { top: 0, right: 0, bottom: 0, left: 0 },
+        toolBarShadowPadding: 5
+    };
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('BiDi screenshots', () => {
+        it('should take BiDi screenshot from viewport when shouldUseBidi is true', async () => {
+            const result = await takeElementScreenshot(browserInstance, baseOptions, true);
+            expect(result).toEqual({
+                base64Image: 'bidi-screenshot-data',
+                isWebDriverElementScreenshot: false
+            });
+            expect(getElementRectMock).toHaveBeenCalledWith('test-element');
+            expect(takeBase64BiDiScreenshotSpy).toHaveBeenCalledWith({
+                browserInstance,
+                origin: 'viewport',
+                clip: { x: 10, y: 20, width: 100, height: 200 }
+            });
+            expect(takeWebElementScreenshotSpy).not.toHaveBeenCalled();
+            expect(makeCroppedBase64ImageSpy).not.toHaveBeenCalled();
+        });
+        it('should fallback to document screenshot when viewport fails with zero dimensions error', async () => {
+            takeBase64BiDiScreenshotSpy.mockRejectedValueOnce(new Error('WebDriver Bidi command "browsingContext.captureScreenshot" failed with error: unable to capture screen - Unable to capture screenshot with zero dimensions'));
+            const result = await takeElementScreenshot(browserInstance, baseOptions, true);
+            expect(result).toEqual({
+                base64Image: 'bidi-screenshot-data',
+                isWebDriverElementScreenshot: false
+            });
+            expect(takeBase64BiDiScreenshotSpy).toHaveBeenCalledTimes(2);
+            expect(takeBase64BiDiScreenshotSpy.mock.calls[0][0]).toEqual({
+                browserInstance,
+                origin: 'viewport',
+                clip: { x: 10, y: 20, width: 100, height: 200 }
+            });
+            expect(takeBase64BiDiScreenshotSpy.mock.calls[1][0]).toEqual({
+                browserInstance,
+                origin: 'document',
+                clip: { x: 10, y: 20, width: 100, height: 200 }
+            });
+        });
+        it('should throw error when BiDi screenshot fails with non-zero dimension error', async () => {
+            const error = new Error('Some other BiDi error');
+            takeBase64BiDiScreenshotSpy.mockRejectedValueOnce(error);
+            await expect(takeElementScreenshot(browserInstance, baseOptions, true)).rejects.toThrow(error);
+            expect(takeBase64BiDiScreenshotSpy).toHaveBeenCalledTimes(1);
+            expect(takeWebElementScreenshotSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('Legacy screenshots', () => {
+        let logErrorSpy;
+        beforeEach(() => {
+            logErrorSpy = vi.spyOn(log, 'error').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            vi.clearAllMocks();
+            logErrorSpy.mockRestore();
+        });
+        it('should take legacy screenshot when shouldUseBidi is false', async () => {
+            const result = await takeElementScreenshot(browserInstance, baseOptions, false);
+            expect(result).toEqual({
+                base64Image: 'cropped-screenshot-data',
+                isWebDriverElementScreenshot: false
+            });
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith({
+                addressBarShadowPadding: 6,
+                browserInstance,
+                devicePixelRatio: 2,
+                deviceRectangles: baseOptions.deviceRectangles,
+                element: baseOptions.element,
+                initialDevicePixelRatio: 2,
+                isEmulated: false,
+                innerHeight: 900,
+                isAndroid: false,
+                isAndroidChromeDriverScreenshot: false,
+                isAndroidNativeWebScreenshot: false,
+                isIOS: false,
+                isLandscape: false,
+                toolBarShadowPadding: 5,
+                fallback: false
+            });
+            expect(makeCroppedBase64ImageSpy).toHaveBeenCalledWith({
+                addIOSBezelCorners: false,
+                base64Image: 'web-element-screenshot-data',
+                deviceName: 'desktop',
+                devicePixelRatio: 2,
+                isWebDriverElementScreenshot: false,
+                isIOS: false,
+                isLandscape: false,
+                rectangles: { x: 0, y: 0, width: 100, height: 100 },
+                resizeDimensions: { top: 0, right: 0, bottom: 0, left: 0 }
+            });
+            expect(takeBase64BiDiScreenshotSpy).not.toHaveBeenCalled();
+        });
+        it('should handle auto scroll when enabled', async () => {
+            const optionsWithScroll = { ...baseOptions, autoElementScroll: true };
+            executeMock.mockResolvedValueOnce(100); // scroll position
+            const result = await takeElementScreenshot(browserInstance, optionsWithScroll, false);
+            expect(result).toEqual({
+                base64Image: 'cropped-screenshot-data',
+                isWebDriverElementScreenshot: false
+            });
+            expect(executeMock).toHaveBeenCalledTimes(2);
+            // First call for scrolling element into view
+            expect(executeMock.mock.calls[0]).toMatchSnapshot();
+            // Second call for scrolling back to original position
+            expect(executeMock.mock.calls[1]).toMatchSnapshot();
+            expect(waitForSpy).toHaveBeenCalledWith(100);
+        });
+        it('should not scroll back when autoElementScroll is enabled but no current position', async () => {
+            const optionsWithScroll = { ...baseOptions, autoElementScroll: true };
+            executeMock.mockResolvedValueOnce(undefined); // no scroll position returned
+            const result = await takeElementScreenshot(browserInstance, optionsWithScroll, false);
+            expect(result).toMatchSnapshot();
+            expect(executeMock).toHaveBeenCalledTimes(1); // Only the scroll into view call
+            expect(waitForSpy).toHaveBeenCalledWith(100);
+        });
+        it('should enable fallback when resizeDimensions is provided', async () => {
+            const optionsWithResize = {
+                ...baseOptions,
+                resizeDimensions: { top: 10, right: 10, bottom: 10, left: 10 }
+            };
+            hasResizeDimensionsSpy.mockReturnValueOnce(true);
+            const result = await takeElementScreenshot(browserInstance, optionsWithResize, false);
+            expect(result).toMatchSnapshot();
+            expect(hasResizeDimensionsSpy).toHaveBeenCalledWith(optionsWithResize.resizeDimensions);
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith(expect.objectContaining({
+                fallback: true
+            }));
+        });
+        it('should enable fallback when device is emulated', async () => {
+            const optionsEmulated = { ...baseOptions, isEmulated: true };
+            const result = await takeElementScreenshot(browserInstance, optionsEmulated, false);
+            expect(result).toMatchSnapshot();
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith(expect.objectContaining({
+                fallback: true
+            }));
+        });
+        it('should disable fallback when no resizeDimensions and not emulated', async () => {
+            const optionsNoResize = {
+                ...baseOptions,
+                resizeDimensions: undefined,
+                isEmulated: false
+            };
+            hasResizeDimensionsSpy.mockReturnValueOnce(false);
+            const result = await takeElementScreenshot(browserInstance, optionsNoResize, false);
+            expect(result).toMatchSnapshot();
+            expect(hasResizeDimensionsSpy).toHaveBeenCalledWith(undefined);
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith(expect.objectContaining({
+                fallback: false
+            }));
+        });
+        it('should handle zero dimensions by falling back to viewport size', async () => {
+            takeWebElementScreenshotSpy.mockResolvedValueOnce({
+                base64Image: 'web-element-screenshot-data',
+                rectangles: { x: 0, y: 0, width: 0, height: 0 },
+                isWebDriverElementScreenshot: false
+            });
+            const result = await takeElementScreenshot(browserInstance, baseOptions, false);
+            expect(result).toMatchSnapshot();
+            expect(getBase64ScreenshotSizeSpy).toHaveBeenCalledWith('web-element-screenshot-data');
+            expect(logErrorSpy.mock.calls).toMatchSnapshot();
+            expect(makeCroppedBase64ImageSpy).toHaveBeenCalledWith(expect.objectContaining({
+                rectangles: { x: 0, y: 0, width: 100, height: 100 }
+            }));
+        });
+        it('should handle zero width only', async () => {
+            takeWebElementScreenshotSpy.mockResolvedValueOnce({
+                base64Image: 'web-element-screenshot-data',
+                rectangles: { x: 50, y: 100, width: 0, height: 150 },
+                isWebDriverElementScreenshot: true
+            });
+            const result = await takeElementScreenshot(browserInstance, baseOptions, false);
+            expect(result).toMatchSnapshot();
+            expect(getBase64ScreenshotSizeSpy).toHaveBeenCalledWith('web-element-screenshot-data');
+            expect(logErrorSpy.mock.calls).toMatchSnapshot();
+        });
+        it('should handle zero height only', async () => {
+            takeWebElementScreenshotSpy.mockResolvedValueOnce({
+                base64Image: 'web-element-screenshot-data',
+                rectangles: { x: 50, y: 100, width: 150, height: 0 },
+                isWebDriverElementScreenshot: true
+            });
+            const result = await takeElementScreenshot(browserInstance, baseOptions, false);
+            expect(result).toMatchSnapshot();
+            expect(getBase64ScreenshotSizeSpy).toHaveBeenCalledWith('web-element-screenshot-data');
+            expect(logErrorSpy.mock.calls).toMatchSnapshot();
+        });
+        it('should pass correct WebDriver element screenshot flag', async () => {
+            takeWebElementScreenshotSpy.mockResolvedValueOnce({
+                base64Image: 'web-element-screenshot-data',
+                rectangles: { x: 0, y: 0, width: 100, height: 100 },
+                isWebDriverElementScreenshot: true
+            });
+            const result = await takeElementScreenshot(browserInstance, baseOptions, false);
+            expect(result).toEqual({
+                base64Image: 'cropped-screenshot-data',
+                isWebDriverElementScreenshot: true
+            });
+            expect(makeCroppedBase64ImageSpy).toHaveBeenCalledWith(expect.objectContaining({
+                isWebDriverElementScreenshot: true
+            }));
+        });
+    });
+    describe('Edge cases', () => {
+        it('should handle devicePixelRatio values and fallback to NaN when falsy', async () => {
+            const optionsWithValidDPR = { ...baseOptions, devicePixelRatio: 1 };
+            const result1 = await takeElementScreenshot(browserInstance, optionsWithValidDPR, false);
+            expect(result1).toMatchSnapshot();
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith(expect.objectContaining({
+                devicePixelRatio: 1
+            }));
+            expect(makeCroppedBase64ImageSpy).toHaveBeenCalledWith(expect.objectContaining({
+                devicePixelRatio: 1
+            }));
+            vi.clearAllMocks();
+            const optionsWithZeroDPR = { ...baseOptions, devicePixelRatio: 0 };
+            const result2 = await takeElementScreenshot(browserInstance, optionsWithZeroDPR, false);
+            expect(result2).toMatchSnapshot();
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith(expect.objectContaining({
+                devicePixelRatio: 0
+            }));
+            expect(makeCroppedBase64ImageSpy).toHaveBeenCalledWith(expect.objectContaining({
+                devicePixelRatio: NaN
+            }));
+        });
+        it('should handle undefined innerHeight', async () => {
+            const optionsWithUndefinedHeight = { ...baseOptions, innerHeight: undefined };
+            const result = await takeElementScreenshot(browserInstance, optionsWithUndefinedHeight, false);
+            expect(result).toMatchSnapshot();
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalledWith(expect.objectContaining({
+                innerHeight: undefined
+            }));
+        });
+        it('should default shouldUseBidi to false when not provided', async () => {
+            const result = await takeElementScreenshot(browserInstance, baseOptions);
+            expect(result).toEqual({
+                base64Image: 'cropped-screenshot-data',
+                isWebDriverElementScreenshot: false
+            });
+            expect(takeBase64BiDiScreenshotSpy).not.toHaveBeenCalled();
+            expect(takeWebElementScreenshotSpy).toHaveBeenCalled();
+        });
+    });
+});

package/dist/methods/takeFullPageScreenshots.d.ts

@@ -0,0 +1,3 @@
+import type { FullPageScreenshotsData, FullPageScreenshotDataOptions } from './screenshots.interfaces.js';
+export declare function takeFullPageScreenshots(browserInstance: WebdriverIO.Browser, options: FullPageScreenshotDataOptions, shouldUseBidi?: boolean): Promise<FullPageScreenshotsData>;
+//# sourceMappingURL=takeFullPageScreenshots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"takeFullPageScreenshots.d.ts","sourceRoot":"","sources":["../../src/methods/takeFullPageScreenshots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAA;AAQzG,wBAAsB,uBAAuB,CACzC,eAAe,EAAE,WAAW,CAAC,OAAO,EACpC,OAAO,EAAE,6BAA6B,EACtC,aAAa,GAAE,OAAe,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CA6BlC"}

package/dist/methods/takeFullPageScreenshots.js

@@ -0,0 +1,56 @@
+import { getMobileFullPageNativeWebScreenshotsData, getAndroidChromeDriverFullPageScreenshotsData, getDesktopFullPageScreenshotsData, takeBase64BiDiScreenshot } from './screenshots.js';
+export async function takeFullPageScreenshots(browserInstance, options, shouldUseBidi = false) {
+    if (shouldUseBidi) {
+        const screenshot = await takeBase64BiDiScreenshot({ browserInstance, origin: 'document' });
+        return {
+            fullPageHeight: -1,
+            fullPageWidth: -1,
+            data: [{
+                    canvasWidth: 0,
+                    canvasYPosition: 0,
+                    imageHeight: 0,
+                    imageWidth: 0,
+                    imageXPosition: 0,
+                    imageYPosition: 0,
+                    screenshot,
+                }]
+        };
+    }
+    if (isAndroidNativeWeb(options) || options.isIOS) {
+        return getMobileFullPageNativeWebScreenshotsData(browserInstance, createMobileOptions(options));
+    }
+    if (isAndroidChromeDriver(options)) {
+        return getAndroidChromeDriverFullPageScreenshotsData(browserInstance, createDesktopOptions(options));
+    }
+    // Default to desktop
+    return getDesktopFullPageScreenshotsData(browserInstance, createDesktopOptions(options));
+}
+function isAndroidNativeWeb(options) {
+    return options.isAndroid && options.isAndroidNativeWebScreenshot;
+}
+function isAndroidChromeDriver(options) {
+    return options.isAndroid && options.isAndroidChromeDriverScreenshot;
+}
+function createMobileOptions(options) {
+    return {
+        addressBarShadowPadding: options.addressBarShadowPadding,
+        devicePixelRatio: options.devicePixelRatio,
+        deviceRectangles: options.deviceRectangles,
+        fullPageScrollTimeout: options.fullPageScrollTimeout,
+        hideAfterFirstScroll: options.hideAfterFirstScroll,
+        innerHeight: options.innerHeight,
+        isAndroid: options.isAndroid,
+        isIOS: options.isIOS,
+        isLandscape: options.isLandscape,
+        screenWidth: options.screenWidth,
+        toolBarShadowPadding: options.toolBarShadowPadding,
+    };
+}
+function createDesktopOptions(options) {
+    return {
+        devicePixelRatio: options.devicePixelRatio,
+        fullPageScrollTimeout: options.fullPageScrollTimeout,
+        hideAfterFirstScroll: options.hideAfterFirstScroll,
+        innerHeight: options.innerHeight,
+    };
+}

package/dist/methods/takeFullPageScreenshots.test.d.ts

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

package/dist/methods/takeFullPageScreenshots.test.d.ts.map

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

package/dist/methods/takeFullPageScreenshots.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { takeFullPageScreenshots } from './takeFullPageScreenshots.js';
+vi.mock('./screenshots.js', () => ({
+    getMobileFullPageNativeWebScreenshotsData: vi.fn().mockResolvedValue({ data: ['mobile'] }),
+    getAndroidChromeDriverFullPageScreenshotsData: vi.fn().mockResolvedValue({ data: ['chromedriver'] }),
+    getDesktopFullPageScreenshotsData: vi.fn().mockResolvedValue({ data: ['desktop'] }),
+    takeBase64BiDiScreenshot: vi.fn().mockResolvedValue('bidi-screenshot')
+}));
+vi.mock('../helpers/utils.js', () => ({
+    canUseBidiScreenshot: vi.fn()
+}));
+describe('takeFullPageScreenshots', () => {
+    const mockBrowser = {};
+    const createOptions = (overrides = {}) => ({
+        addressBarShadowPadding: 0,
+        devicePixelRatio: 1,
+        deviceRectangles: {},
+        fullPageScrollTimeout: 1000,
+        hideAfterFirstScroll: [],
+        innerHeight: 800,
+        isAndroid: false,
+        isAndroidNativeWebScreenshot: false,
+        isAndroidChromeDriverScreenshot: false,
+        isIOS: false,
+        isLandscape: false,
+        screenHeight: 1024,
+        screenWidth: 768,
+        toolBarShadowPadding: 0,
+        ...overrides
+    });
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should use BiDi when shouldUseBidi is true and browser supports it', async () => {
+        const { canUseBidiScreenshot } = await import('../helpers/utils.js');
+        vi.mocked(canUseBidiScreenshot).mockReturnValue(true);
+        const options = createOptions();
+        const result = await takeFullPageScreenshots(mockBrowser, options, true);
+        expect(result.data[0].screenshot).toBe('bidi-screenshot');
+    });
+    it('should route to mobile native web for Android native web screenshots', async () => {
+        const { getMobileFullPageNativeWebScreenshotsData } = await import('./screenshots.js');
+        const options = createOptions({
+            isAndroid: true,
+            isAndroidNativeWebScreenshot: true
+        });
+        const result = await takeFullPageScreenshots(mockBrowser, options, false);
+        expect(getMobileFullPageNativeWebScreenshotsData).toHaveBeenCalledWith(mockBrowser, expect.any(Object));
+        expect(result.data).toEqual(['mobile']);
+    });
+    it('should route to mobile native web for iOS devices', async () => {
+        const { getMobileFullPageNativeWebScreenshotsData } = await import('./screenshots.js');
+        const options = createOptions({ isIOS: true });
+        await takeFullPageScreenshots(mockBrowser, options, false);
+        expect(getMobileFullPageNativeWebScreenshotsData).toHaveBeenCalledWith(mockBrowser, expect.any(Object));
+    });
+    it('should route to Android ChromeDriver for Android ChromeDriver screenshots', async () => {
+        const { getAndroidChromeDriverFullPageScreenshotsData } = await import('./screenshots.js');
+        const options = createOptions({
+            isAndroid: true,
+            isAndroidChromeDriverScreenshot: true
+        });
+        await takeFullPageScreenshots(mockBrowser, options, false);
+        expect(getAndroidChromeDriverFullPageScreenshotsData).toHaveBeenCalledWith(mockBrowser, expect.any(Object));
+    });
+    it('should default to desktop for other cases', async () => {
+        const { getDesktopFullPageScreenshotsData } = await import('./screenshots.js');
+        const options = createOptions();
+        await takeFullPageScreenshots(mockBrowser, options, false);
+        expect(getDesktopFullPageScreenshotsData).toHaveBeenCalledWith(mockBrowser, expect.any(Object));
+    });
+});

package/dist/methods/takeWebScreenshots.d.ts

@@ -0,0 +1,3 @@
+import type { WebScreenshotDataOptions, WebScreenshotData } from './screenshots.interfaces.js';
+export declare function takeWebScreenshot(browserInstance: WebdriverIO.Browser, options: WebScreenshotDataOptions, shouldUseBidi?: boolean): Promise<WebScreenshotData>;
+//# sourceMappingURL=takeWebScreenshots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"takeWebScreenshots.d.ts","sourceRoot":"","sources":["../../src/methods/takeWebScreenshots.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAG9F,wBAAsB,iBAAiB,CACnC,eAAe,EAAE,WAAW,CAAC,OAAO,EACpC,OAAO,EAAE,wBAAwB,EACjC,aAAa,GAAE,OAAe,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAwC5B"}

package/dist/methods/takeWebScreenshots.js

@@ -0,0 +1,41 @@
+import { takeBase64BiDiScreenshot, takeBase64Screenshot } from './screenshots.js';
+import { makeCroppedBase64Image } from './images.js';
+import { determineScreenRectangles } from './rectangles.js';
+export async function takeWebScreenshot(browserInstance, options, shouldUseBidi = false) {
+    let base64Image;
+    if (shouldUseBidi) {
+        // Take the screenshot with the BiDi method
+        base64Image = await takeBase64BiDiScreenshot({ browserInstance });
+    }
+    else {
+        // Take the screenshot with the regular method
+        base64Image = await takeBase64Screenshot(browserInstance);
+        // Determine the rectangles
+        const screenRectangleOptions = {
+            devicePixelRatio: options.devicePixelRatio || NaN,
+            enableLegacyScreenshotMethod: options.enableLegacyScreenshotMethod,
+            innerHeight: options.innerHeight || NaN,
+            innerWidth: options.innerWidth || NaN,
+            isAndroidChromeDriverScreenshot: options.isAndroidChromeDriverScreenshot,
+            isAndroidNativeWebScreenshot: options.isAndroidNativeWebScreenshot,
+            isEmulated: options.isEmulated || false,
+            initialDevicePixelRatio: options.initialDevicePixelRatio || NaN,
+            isIOS: options.isIOS,
+            isLandscape: options.isLandscape,
+        };
+        const rectangles = determineScreenRectangles(base64Image, screenRectangleOptions);
+        // Make a cropped base64 image
+        base64Image = await makeCroppedBase64Image({
+            addIOSBezelCorners: options.addIOSBezelCorners,
+            base64Image,
+            deviceName: options.deviceName,
+            devicePixelRatio: options.devicePixelRatio || NaN,
+            isIOS: options.isIOS,
+            isLandscape: options.isLandscape,
+            rectangles,
+        });
+    }
+    return {
+        base64Image,
+    };
+}

package/dist/methods/takeWebScreenshots.test.d.ts

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

package/dist/methods/takeWebScreenshots.test.d.ts.map

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