@wdio/image-comparison-core 1.0.0

package/dist/methods/screenshots.d.ts

@@ -0,0 +1,37 @@
+import type { FullPageScreenshotOptions, FullPageScreenshotNativeMobileOptions, FullPageScreenshotsData, TakeWebElementScreenshot, TakeWebElementScreenshotData } from './screenshots.interfaces.js';
+import type { RectanglesOutput } from './rectangles.interfaces.js';
+/**
+ * Take a full page screenshots for desktop / iOS / Android
+ */
+export declare function getMobileFullPageNativeWebScreenshotsData(browserInstance: WebdriverIO.Browser, options: FullPageScreenshotNativeMobileOptions): Promise<FullPageScreenshotsData>;
+/**
+ * Take a full page screenshot for Android with Chromedriver
+ */
+export declare function getAndroidChromeDriverFullPageScreenshotsData(browserInstance: WebdriverIO.Browser, options: FullPageScreenshotOptions): Promise<FullPageScreenshotsData>;
+/**
+ * Take a full page screenshots
+ */
+export declare function getDesktopFullPageScreenshotsData(browserInstance: WebdriverIO.Browser, options: FullPageScreenshotOptions): Promise<FullPageScreenshotsData>;
+/**
+ * Take a screenshot
+ */
+export declare function takeBase64Screenshot(browserInstance: WebdriverIO.Browser): Promise<string>;
+/**
+ * Take a bidi screenshot
+ */
+export declare function takeBase64BiDiScreenshot({ browserInstance, origin, clip, }: {
+    browserInstance: WebdriverIO.Browser;
+    origin?: 'viewport' | 'document';
+    clip?: RectanglesOutput;
+}): Promise<string>;
+/**
+ * Log an error for not being able to hide remove elements
+ *
+ * @TODO: remove the any
+ */
+export declare function logHiddenRemovedError(error: any): void;
+/**
+ * Take an element screenshot on the web
+ */
+export declare function takeWebElementScreenshot({ addressBarShadowPadding, browserInstance, devicePixelRatio, deviceRectangles, element, fallback, initialDevicePixelRatio, isEmulated, innerHeight, isAndroid, isAndroidChromeDriverScreenshot, isAndroidNativeWebScreenshot, isIOS, isLandscape, toolBarShadowPadding, }: TakeWebElementScreenshot): Promise<TakeWebElementScreenshotData>;
+//# sourceMappingURL=screenshots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"screenshots.d.ts","sourceRoot":"","sources":["../../src/methods/screenshots.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACR,yBAAyB,EACzB,qCAAqC,EACrC,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC/B,MAAM,6BAA6B,CAAA;AAGpC,OAAO,KAAK,EAA4B,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAK5F;;GAEG;AACH,wBAAsB,yCAAyC,CAAC,eAAe,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,qCAAqC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAwJtL;AAED;;GAEG;AACH,wBAAsB,6CAA6C,CAAC,eAAe,EAAC,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA2F7K;AAED;;GAEG;AACH,wBAAsB,iCAAiC,CAAC,eAAe,EAAC,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAmGjK;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,eAAe,EAAE,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAEhG;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,EAC3C,eAAe,EACf,MAAmB,EACnB,IAAI,GACP,EAAE;IACC,eAAe,EAAE,WAAW,CAAC,OAAO,CAAC;IACrC,MAAM,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACjC,IAAI,CAAC,EAAE,gBAAgB,CAAC;CAC3B,GAAG,OAAO,CAAC,MAAM,CAAC,CASlB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,GAAG,QAa/C;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAAC,EAC3C,uBAAuB,EACvB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,QAAgB,EAChB,uBAAuB,EACvB,UAAU,EACV,WAAW,EACX,SAAS,EACT,+BAA+B,EAC/B,4BAA4B,EAC5B,KAAK,EACL,WAAW,EACX,oBAAoB,GACvB,EAAE,wBAAwB,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAgElE"}

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

@@ -0,0 +1,203 @@
+import type { DeviceRectangles } from './rectangles.interfaces.js';
+import type { RectanglesOutput } from './rectangles.interfaces.js';
+/**
+ * Universal screenshot information that applies to ALL screenshot scenarios.
+ * This includes desktop browsers on high-DPI displays, mobile browsers, and native apps.
+ */
+export interface ScreenshotInfo {
+    /** The device pixel ratio. */
+    devicePixelRatio: number;
+    /** The initial device pixel ratio. */
+    initialDevicePixelRatio?: number;
+}
+/**
+ * Base device information shared across screenshot operations.
+ */
+export interface DeviceInfo {
+    /** Whether the instance is an Android device. */
+    isAndroid: boolean;
+    /** Whether the instance is an iOS device. */
+    isIOS: boolean;
+    /** Whether it's landscape or not. */
+    isLandscape: boolean;
+}
+/**
+ * Viewport information.
+ */
+export interface ViewportInfo {
+    /** The inner height. */
+    innerHeight: number;
+    /** The inner width. */
+    innerWidth?: number;
+    /** Height of the screen. */
+    screenHeight?: number;
+    /** Width of the screen. */
+    screenWidth?: number;
+}
+/**
+ * Android-specific screenshot options.
+ */
+export interface AndroidScreenshotOptions {
+    /** Whether this is an Android native web screenshot. */
+    isAndroidNativeWebScreenshot: boolean;
+    /** Whether this is an Android ChromeDriver screenshot. */
+    isAndroidChromeDriverScreenshot: boolean;
+}
+/**
+ * iOS-specific screenshot options.
+ */
+export interface IOSScreenshotOptions {
+    /** Whether to add iOS bezel corners. */
+    addIOSBezelCorners: boolean;
+}
+/**
+ * Mobile device information.
+ */
+export interface MobileDeviceInfo extends DeviceInfo {
+    /** The device name. */
+    deviceName: string;
+    /** Whether this is a mobile device. */
+    isMobile: boolean;
+    /** Whether the device is emulated. */
+    isEmulated: boolean;
+}
+/**
+ * Mobile cropping options for converting full screen to viewport screenshots.
+ */
+export interface MobileCroppingOptions {
+    /** The address bar padding for iOS or Android. */
+    addressBarShadowPadding: number;
+    /** The toolbar padding for iOS or Android. */
+    toolBarShadowPadding: number;
+    /** The rectangles of the device. */
+    deviceRectangles: DeviceRectangles;
+}
+/**
+ * Scroll options for full page screenshots.
+ */
+export interface ScrollOptions {
+    /** The amount of milliseconds to wait for a new scroll. */
+    fullPageScrollTimeout: number;
+    /** Elements that need to be hidden after the first scroll for a fullpage scroll. */
+    hideAfterFirstScroll: (HTMLElement | HTMLElement[])[];
+}
+/**
+ * Interface representing data for full page screenshots.
+ */
+export interface FullPageScreenshotsData {
+    /** The height of the full page. */
+    fullPageHeight: number;
+    /** The width of the full page. */
+    fullPageWidth: number;
+    /** Array of screenshot data. */
+    data: ScreenshotData[];
+}
+/**
+ * Interface representing individual screenshot data.
+ */
+interface ScreenshotData {
+    /** The width of the canvas. */
+    canvasWidth: number;
+    /** The y position on the canvas. */
+    canvasYPosition: number;
+    /** The height of the image. */
+    imageHeight: number;
+    /** The width of the image. */
+    imageWidth: number;
+    /** The x position in the image to start from. */
+    imageXPosition: number;
+    /** The y position in the image to start from. */
+    imageYPosition: number;
+    /** The screenshot itself. */
+    screenshot: string;
+}
+/**
+ * Base interface for screenshot data results.
+ */
+export interface BaseScreenshotData {
+    /** The base64 encoded image. */
+    base64Image: string;
+}
+/**
+ * Interface representing data for web screen screenshot result.
+ */
+export interface WebScreenshotData extends BaseScreenshotData {
+}
+/**
+ * Interface representing data for element screenshot result.
+ */
+export interface ElementScreenshotData extends BaseScreenshotData {
+    /** Whether this is a web driver element screenshot. */
+    isWebDriverElementScreenshot: boolean;
+}
+/**
+ * Interface representing data for taking a web element screenshot.
+ */
+export interface TakeWebElementScreenshotData extends BaseScreenshotData {
+    /** Whether this is a web driver element screenshot. */
+    isWebDriverElementScreenshot: boolean;
+    /** The rectangles output. */
+    rectangles: RectanglesOutput;
+}
+/**
+ * Interface representing options for full page screenshot data.
+ */
+export interface FullPageScreenshotDataOptions extends ScreenshotInfo, DeviceInfo, AndroidScreenshotOptions, ViewportInfo, MobileCroppingOptions, ScrollOptions {
+    /** Height of the screen. */
+    screenHeight: number;
+    /** Width of the screen. */
+    screenWidth: number;
+}
+/**
+ * Interface representing options for full page screenshot on native mobile.
+ */
+export interface FullPageScreenshotNativeMobileOptions extends ScreenshotInfo, DeviceInfo, ViewportInfo, MobileCroppingOptions, ScrollOptions {
+    /** Width of the screen. */
+    screenWidth: number;
+}
+/**
+ * Interface representing options for full page screenshot.
+ */
+export interface FullPageScreenshotOptions extends ScreenshotInfo, ViewportInfo, ScrollOptions {
+}
+/**
+ * Interface representing options for taking a web element screenshot.
+ */
+export interface TakeWebElementScreenshot extends ScreenshotInfo, DeviceInfo, AndroidScreenshotOptions, MobileCroppingOptions {
+    /** The browser instance. */
+    browserInstance: WebdriverIO.Browser;
+    /** The element to take a screenshot of. */
+    element: any;
+    /** Whether to use a fallback method. */
+    fallback?: boolean;
+    /** Whether the device is emulated. */
+    isEmulated: boolean;
+    /** The inner height. */
+    innerHeight?: number;
+}
+/**
+ * Interface representing options for web screen screenshot data.
+ */
+export interface WebScreenshotDataOptions extends ScreenshotInfo, MobileDeviceInfo, AndroidScreenshotOptions, IOSScreenshotOptions {
+    /** Whether to enable legacy screenshot method. */
+    enableLegacyScreenshotMethod: boolean;
+    /** The inner height. */
+    innerHeight?: number;
+    /** The inner width. */
+    innerWidth?: number;
+}
+/**
+ * Interface representing options for element screenshot data.
+ */
+export interface ElementScreenshotDataOptions extends ScreenshotInfo, MobileDeviceInfo, AndroidScreenshotOptions, MobileCroppingOptions {
+    /** Whether to automatically scroll the element into view. */
+    autoElementScroll: boolean;
+    /** The element to take a screenshot of. */
+    element: any;
+    /** The inner height. */
+    innerHeight?: number;
+    /** Resize dimensions for the screenshot. */
+    resizeDimensions: any;
+}
+export {};
+//# sourceMappingURL=screenshots.interfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"screenshots.interfaces.d.ts","sourceRoot":"","sources":["../../src/methods/screenshots.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAIlE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC3B,8BAA8B;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sCAAsC;IACtC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,iDAAiD;IACjD,SAAS,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,KAAK,EAAE,OAAO,CAAC;IACf,qCAAqC;IACrC,WAAW,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,wBAAwB;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAID;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACrC,wDAAwD;IACxD,4BAA4B,EAAE,OAAO,CAAC;IACtC,0DAA0D;IAC1D,+BAA+B,EAAE,OAAO,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,wCAAwC;IACxC,kBAAkB,EAAE,OAAO,CAAC;CAC/B;AAID;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAChD,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,sCAAsC;IACtC,UAAU,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,kDAAkD;IAClD,uBAAuB,EAAE,MAAM,CAAC;IAChC,8CAA8C;IAC9C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,oCAAoC;IACpC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,2DAA2D;IAC3D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oFAAoF;IACpF,oBAAoB,EAAE,CAAC,WAAW,GAAG,WAAW,EAAE,CAAC,EAAE,CAAC;CACzD;AAID;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,mCAAmC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,kCAAkC;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,IAAI,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,UAAU,cAAc;IACpB,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAE5D;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC7D,uDAAuD;IACvD,4BAA4B,EAAE,OAAO,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,kBAAkB;IACpE,uDAAuD;IACvD,4BAA4B,EAAE,OAAO,CAAC;IACtC,6BAA6B;IAC7B,UAAU,EAAE,gBAAgB,CAAC;CAChC;AAID;;GAEG;AACH,MAAM,WAAW,6BAA8B,SAC3C,cAAc,EACd,UAAU,EACV,wBAAwB,EACxB,YAAY,EACZ,qBAAqB,EACrB,aAAa;IACb,4BAA4B;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,2BAA2B;IAC3B,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,qCAAsC,SACnD,cAAc,EACd,UAAU,EACV,YAAY,EACZ,qBAAqB,EACrB,aAAa;IACb,2BAA2B;IAC3B,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,yBAA0B,SACvC,cAAc,EACd,YAAY,EACZ,aAAa;CAEhB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SACtC,cAAc,EACd,UAAU,EACV,wBAAwB,EACxB,qBAAqB;IACrB,4BAA4B;IAC5B,eAAe,EAAE,WAAW,CAAC,OAAO,CAAC;IACrC,2CAA2C;IAC3C,OAAO,EAAE,GAAG,CAAC;IACb,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,UAAU,EAAE,OAAO,CAAC;IACpB,wBAAwB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SACtC,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB;IACpB,kDAAkD;IAClD,4BAA4B,EAAE,OAAO,CAAC;IACtC,wBAAwB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uBAAuB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAC1C,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,qBAAqB;IACrB,6DAA6D;IAC7D,iBAAiB,EAAE,OAAO,CAAC;IAC3B,2CAA2C;IAC3C,OAAO,EAAE,GAAG,CAAC;IACb,wBAAwB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,gBAAgB,EAAE,GAAG,CAAC;CACzB"}

package/dist/methods/screenshots.interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/methods/screenshots.js

@@ -0,0 +1,394 @@
+import logger from '@wdio/logger';
+import scrollToPosition from '../clientSideScripts/scrollToPosition.js';
+import getDocumentScrollHeight from '../clientSideScripts/getDocumentScrollHeight.js';
+import { calculateDprData, getBase64ScreenshotSize, waitFor } from '../helpers/utils.js';
+import hideRemoveElements from '../clientSideScripts/hideRemoveElements.js';
+import hideScrollBars from '../clientSideScripts/hideScrollbars.js';
+import { determineElementRectangles } from './rectangles.js';
+const log = logger('@wdio/visual-service:@wdio/image-comparison-core:screenshots');
+/**
+ * Take a full page screenshots for desktop / iOS / Android
+ */
+export async function getMobileFullPageNativeWebScreenshotsData(browserInstance, options) {
+    const viewportScreenshots = [];
+    // The addressBarShadowPadding and toolBarShadowPadding is used because the viewport might have a shadow on the address and the tool bar
+    // so the cutout of the viewport needs to be a little bit smaller
+    const { addressBarShadowPadding, devicePixelRatio, deviceRectangles: { viewport, bottomBar, homeBar }, fullPageScrollTimeout, hideAfterFirstScroll, isAndroid, isLandscape, toolBarShadowPadding, } = options;
+    // The returned data from the deviceRectangles is in real pixels, not CSS pixels, so we need to divide it by the devicePixelRatio
+    // but only for Android, because the deviceRectangles are already in CSS pixels for iOS
+    const viewportHeight = Math.round(viewport.height / (isAndroid ? devicePixelRatio : 1)) - addressBarShadowPadding - toolBarShadowPadding;
+    const hasNoBottomBar = bottomBar.height === 0;
+    const hasHomeBar = homeBar.height > 0;
+    const effectiveViewportHeight = hasNoBottomBar && hasHomeBar
+        ? viewportHeight - Math.round(homeBar.height / (isAndroid ? devicePixelRatio : 1))
+        : viewportHeight;
+    const viewportWidth = Math.round(viewport.width / (isAndroid ? devicePixelRatio : 1));
+    const viewportX = Math.round(viewport.x / (isAndroid ? devicePixelRatio : 1));
+    const viewportY = Math.round(viewport.y / (isAndroid ? devicePixelRatio : 1));
+    // Start with an empty array, during the scroll it will be filled because a page could also have a lazy loading
+    const amountOfScrollsArray = [];
+    let scrollHeight;
+    let isRotated = false;
+    for (let i = 0; i <= amountOfScrollsArray.length; i++) {
+        // Determine and start scrolling
+        const scrollY = effectiveViewportHeight * i;
+        if (scrollY < 0) {
+            const currentBrowserScrollPosition = await browserInstance.execute(() => window.pageYOffset || document.documentElement.scrollTop);
+            log.error('Negative scrollY detected during full page screenshot', {
+                iteration: i,
+                scrollY,
+                effectiveViewportHeight,
+                originalViewportHeight: viewportHeight,
+                calculatedScrollY: effectiveViewportHeight * i,
+                deviceInfo: {
+                    isAndroid,
+                    isLandscape,
+                    devicePixelRatio,
+                    addressBarShadowPadding,
+                    toolBarShadowPadding
+                },
+                deviceRectangles: {
+                    viewport: options.deviceRectangles.viewport,
+                    bottomBar: options.deviceRectangles.bottomBar,
+                    homeBar: options.deviceRectangles.homeBar,
+                    screenSize: options.deviceRectangles.screenSize
+                },
+                homeBarAdjustment: {
+                    hasNoBottomBar,
+                    hasHomeBar,
+                    homeBarHeightAdjustment: hasNoBottomBar && hasHomeBar ? Math.round(homeBar.height / (isAndroid ? devicePixelRatio : 1)) : 0
+                },
+                scrollHeight,
+                currentBrowserScrollPosition
+            });
+            throw new Error(`Negative scroll position detected (scrollY: ${scrollY}) during full page screenshot at iteration ${i}. This indicates an issue with viewport calculations or browser scroll state. Check logs for detailed debug information.`);
+        }
+        await browserInstance.execute(scrollToPosition, scrollY);
+        // Hide scrollbars before taking a screenshot, we don't want them, on the screenshot
+        await browserInstance.execute(hideScrollBars, true);
+        // Simply wait the amount of time specified for lazy-loading
+        await waitFor(fullPageScrollTimeout);
+        // Elements that need to be hidden after the first scroll for a fullpage scroll
+        if (i === 1 && hideAfterFirstScroll.length > 0) {
+            try {
+                await browserInstance.execute(hideRemoveElements, { hide: hideAfterFirstScroll, remove: [] }, true);
+            }
+            catch (e) {
+                logHiddenRemovedError(e);
+            }
+        }
+        // Take the screenshot and determine if it's rotated
+        const screenshot = await takeBase64Screenshot(browserInstance);
+        isRotated = Boolean(isLandscape && effectiveViewportHeight > viewportWidth);
+        // Determine scroll height and check if we need to scroll again
+        scrollHeight = await browserInstance.execute(getDocumentScrollHeight);
+        if (scrollHeight && (scrollY + effectiveViewportHeight < scrollHeight)) {
+            amountOfScrollsArray.push(amountOfScrollsArray.length);
+        }
+        const remainingContent = scrollHeight ? scrollHeight - scrollY : 0;
+        const imageHeight = amountOfScrollsArray.length === i && scrollHeight && remainingContent > 0
+            ? remainingContent
+            : effectiveViewportHeight;
+        if (amountOfScrollsArray.length === i && remainingContent <= 0) {
+            break;
+        }
+        // The starting position for cropping could be different for the last image
+        // The cropping always needs to start at status and address bar height and the address bar shadow padding
+        const imageYPosition = (amountOfScrollsArray.length === i ? effectiveViewportHeight - imageHeight : 0) + viewportY + addressBarShadowPadding;
+        // Store all the screenshot data in the screenshot object
+        viewportScreenshots.push({
+            ...calculateDprData({
+                canvasWidth: isRotated ? effectiveViewportHeight : viewportWidth,
+                canvasYPosition: scrollY,
+                imageHeight: imageHeight,
+                imageWidth: isRotated ? effectiveViewportHeight : viewportWidth,
+                imageXPosition: viewportX,
+                imageYPosition: imageYPosition,
+            }, devicePixelRatio),
+            screenshot,
+        });
+        // Show scrollbars again
+        await browserInstance.execute(hideScrollBars, false);
+    }
+    // Put back the hidden elements to visible
+    if (hideAfterFirstScroll.length > 0) {
+        try {
+            await browserInstance.execute(hideRemoveElements, { hide: hideAfterFirstScroll, remove: [] }, false);
+        }
+        catch (e) {
+            logHiddenRemovedError(e);
+        }
+    }
+    if (!scrollHeight) {
+        throw new Error('Couldn\'t determine scroll height or screenshot size');
+    }
+    return {
+        ...calculateDprData({
+            fullPageHeight: scrollHeight - addressBarShadowPadding - toolBarShadowPadding,
+            fullPageWidth: isRotated ? effectiveViewportHeight : viewportWidth,
+        }, devicePixelRatio),
+        data: viewportScreenshots,
+    };
+}
+/**
+ * Take a full page screenshot for Android with Chromedriver
+ */
+export async function getAndroidChromeDriverFullPageScreenshotsData(browserInstance, options) {
+    const viewportScreenshots = [];
+    const { devicePixelRatio, fullPageScrollTimeout, hideAfterFirstScroll, innerHeight } = options;
+    // Start with an empty array, during the scroll it will be filled because a page could also have a lazy loading
+    const amountOfScrollsArray = [];
+    let scrollHeight;
+    let screenshotSize;
+    for (let i = 0; i <= amountOfScrollsArray.length; i++) {
+        // Determine and start scrolling
+        const scrollY = innerHeight * i;
+        await browserInstance.execute(scrollToPosition, scrollY);
+        // Hide scrollbars before taking a screenshot, we don't want them, on the screenshot
+        await browserInstance.execute(hideScrollBars, true);
+        // Simply wait the amount of time specified for lazy-loading
+        await waitFor(fullPageScrollTimeout);
+        // Elements that need to be hidden after the first scroll for a fullpage scroll
+        if (i === 1 && hideAfterFirstScroll.length > 0) {
+            try {
+                await browserInstance.execute(hideRemoveElements, { hide: hideAfterFirstScroll, remove: [] }, true);
+            }
+            catch (e) {
+                logHiddenRemovedError(e);
+            }
+        }
+        // Take the screenshot
+        const screenshot = await takeBase64Screenshot(browserInstance);
+        screenshotSize = getBase64ScreenshotSize(screenshot, devicePixelRatio);
+        // Determine scroll height and check if we need to scroll again
+        scrollHeight = await browserInstance.execute(getDocumentScrollHeight);
+        if (scrollHeight && (scrollY + innerHeight < scrollHeight)) {
+            amountOfScrollsArray.push(amountOfScrollsArray.length);
+        }
+        // There is no else
+        // The height of the image of the last 1 could be different
+        const imageHeight = amountOfScrollsArray.length === i && scrollHeight
+            ? scrollHeight - innerHeight * viewportScreenshots.length
+            : innerHeight;
+        // The starting position for cropping could be different for the last image (0 means no cropping)
+        const imageYPosition = amountOfScrollsArray.length === i && amountOfScrollsArray.length !== 0 ? innerHeight - imageHeight : 0;
+        // Store all the screenshot data in the screenshot object
+        viewportScreenshots.push({
+            ...calculateDprData({
+                canvasWidth: screenshotSize.width,
+                canvasYPosition: scrollY,
+                imageHeight: imageHeight,
+                imageWidth: screenshotSize.width,
+                imageXPosition: 0,
+                imageYPosition: imageYPosition,
+            }, devicePixelRatio),
+            screenshot,
+        });
+        // Show the scrollbars again
+        await browserInstance.execute(hideScrollBars, false);
+    }
+    // Put back the hidden elements to visible
+    if (hideAfterFirstScroll.length > 0) {
+        try {
+            await browserInstance.execute(hideRemoveElements, { hide: hideAfterFirstScroll, remove: [] }, false);
+        }
+        catch (e) {
+            logHiddenRemovedError(e);
+        }
+    }
+    if (!scrollHeight || !screenshotSize) {
+        throw new Error('Couldn\'t determine scroll height or screenshot size');
+    }
+    return {
+        ...calculateDprData({
+            fullPageHeight: scrollHeight,
+            fullPageWidth: screenshotSize.width,
+        }, devicePixelRatio),
+        data: viewportScreenshots,
+    };
+}
+/**
+ * Take a full page screenshots
+ */
+export async function getDesktopFullPageScreenshotsData(browserInstance, options) {
+    const viewportScreenshots = [];
+    const { devicePixelRatio, fullPageScrollTimeout, hideAfterFirstScroll, innerHeight } = options;
+    let actualInnerHeight = innerHeight;
+    // Start with an empty array, during the scroll it will be filled because a page could also have a lazy loading
+    const amountOfScrollsArray = [];
+    let scrollHeight;
+    let screenshotSize;
+    for (let i = 0; i <= amountOfScrollsArray.length; i++) {
+        // Determine and start scrolling
+        const scrollY = actualInnerHeight * i;
+        await browserInstance.execute(scrollToPosition, scrollY);
+        // Simply wait the amount of time specified for lazy-loading
+        await waitFor(fullPageScrollTimeout);
+        // Elements that need to be hidden after the first scroll for a fullpage scroll
+        if (i === 1 && hideAfterFirstScroll.length > 0) {
+            try {
+                await browserInstance.execute(hideRemoveElements, { hide: hideAfterFirstScroll, remove: [] }, true);
+            }
+            catch (e) {
+                logHiddenRemovedError(e);
+            }
+        }
+        // Take the screenshot
+        const screenshot = await takeBase64Screenshot(browserInstance);
+        screenshotSize = getBase64ScreenshotSize(screenshot, devicePixelRatio);
+        // The actual screenshot size might be slightly different than the inner height
+        // In that case, use the screenshot size instead of the innerHeight
+        if (i === 0 && screenshotSize.height !== actualInnerHeight) {
+            if (Math.round(screenshotSize.height) === actualInnerHeight) {
+                actualInnerHeight = screenshotSize.height;
+            }
+            // No else, because some drivers take a full page screenshot, e.g. some versions of FireFox,
+            // and SafariDriver for Safari 11
+        }
+        // Determine scroll height and check if we need to scroll again
+        scrollHeight = await browserInstance.execute(getDocumentScrollHeight);
+        if (scrollHeight && (scrollY + actualInnerHeight < scrollHeight) && screenshotSize.height === actualInnerHeight) {
+            amountOfScrollsArray.push(amountOfScrollsArray.length);
+        }
+        // There is no else, Lazy load and large screenshots,
+        // like with older drivers such as FF <= 47 and IE11, will not work
+        // The height of the image of the last 1 could be different
+        const imageHeight = scrollHeight && amountOfScrollsArray.length === i
+            ? scrollHeight - actualInnerHeight * viewportScreenshots.length
+            : screenshotSize.height;
+        // The starting position for cropping could be different for the last image (0 means no cropping)
+        const imageYPosition = amountOfScrollsArray.length === i && amountOfScrollsArray.length !== 0
+            ? actualInnerHeight - imageHeight
+            : 0;
+        // Store all the screenshot data in the screenshot object
+        viewportScreenshots.push({
+            ...calculateDprData({
+                canvasWidth: screenshotSize.width,
+                canvasYPosition: scrollY,
+                imageHeight: imageHeight,
+                imageWidth: screenshotSize.width,
+                imageXPosition: 0,
+                imageYPosition: imageYPosition,
+            }, devicePixelRatio),
+            screenshot,
+        });
+    }
+    // Put back the hidden elements to visible
+    if (hideAfterFirstScroll.length > 0) {
+        try {
+            await browserInstance.execute(hideRemoveElements, { hide: hideAfterFirstScroll, remove: [] }, false);
+        }
+        catch (e) {
+            logHiddenRemovedError(e);
+        }
+    }
+    if (!scrollHeight || !screenshotSize) {
+        throw new Error('Couldn\'t determine scroll height or screenshot size');
+    }
+    return {
+        ...calculateDprData({
+            fullPageHeight: scrollHeight,
+            fullPageWidth: screenshotSize.width,
+        }, devicePixelRatio),
+        data: viewportScreenshots,
+    };
+}
+/**
+ * Take a screenshot
+ */
+export async function takeBase64Screenshot(browserInstance) {
+    return browserInstance.takeScreenshot();
+}
+/**
+ * Take a bidi screenshot
+ */
+export async function takeBase64BiDiScreenshot({ browserInstance, origin = 'viewport', clip, }) {
+    log.info('Taking a BiDi screenshot');
+    const contextID = await browserInstance.getWindowHandle();
+    return (await browserInstance.browsingContextCaptureScreenshot({
+        context: contextID,
+        origin,
+        ...(clip ? { clip: { ...clip, type: 'box' } } : {})
+    })).data;
+}
+/**
+ * Log an error for not being able to hide remove elements
+ *
+ * @TODO: remove the any
+ */
+export function logHiddenRemovedError(error) {
+    log.warn('\x1b[33m%s\x1b[0m', `
+#####################################################################################
+ WARNING:
+ (One of) the elements that needed to be hidden or removed could not be found on the
+ page and caused this error
+ Error: ${error}
+ We made sure the test didn't break.
+#####################################################################################
+`);
+}
+/**
+ * Take an element screenshot on the web
+ */
+export async function takeWebElementScreenshot({ addressBarShadowPadding, browserInstance, devicePixelRatio, deviceRectangles, element, fallback = false, initialDevicePixelRatio, isEmulated, innerHeight, isAndroid, isAndroidChromeDriverScreenshot, isAndroidNativeWebScreenshot, isIOS, isLandscape, toolBarShadowPadding, }) {
+    if (fallback) {
+        const base64Image = await takeBase64Screenshot(browserInstance);
+        const elementRectangleOptions = {
+            /**
+             * ToDo: handle NaA case
+             */
+            devicePixelRatio: devicePixelRatio,
+            deviceRectangles,
+            initialDevicePixelRatio: initialDevicePixelRatio || 1,
+            innerHeight: innerHeight || NaN,
+            isEmulated,
+            isAndroidNativeWebScreenshot,
+            isAndroid,
+            isIOS,
+        };
+        const rectangles = await determineElementRectangles({
+            browserInstance,
+            base64Image,
+            element,
+            options: elementRectangleOptions,
+        });
+        return {
+            base64Image,
+            isWebDriverElementScreenshot: false,
+            rectangles,
+        };
+    }
+    try {
+        const base64Image = await browserInstance.takeElementScreenshot((await element).elementId);
+        const { height, width } = getBase64ScreenshotSize(base64Image);
+        const rectangles = { x: 0, y: 0, width, height };
+        if (rectangles.width === 0 || rectangles.height === 0) {
+            throw new Error('The element has no width or height.');
+        }
+        return {
+            base64Image,
+            isWebDriverElementScreenshot: true,
+            rectangles,
+        };
+    }
+    catch (_e) {
+        log.warn('The element screenshot failed, falling back to cutting the full device/viewport screenshot:', _e);
+        return takeWebElementScreenshot({
+            addressBarShadowPadding,
+            browserInstance,
+            devicePixelRatio,
+            deviceRectangles,
+            element,
+            fallback: true,
+            initialDevicePixelRatio,
+            isEmulated,
+            innerHeight,
+            isAndroid,
+            isAndroidChromeDriverScreenshot,
+            isAndroidNativeWebScreenshot,
+            isIOS,
+            isLandscape,
+            toolBarShadowPadding,
+        });
+    }
+}

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

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

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

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