@wdio/image-comparison-core 1.0.0

package/dist/clientSideScripts/getDocumentScrollHeight.test.d.ts.map

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

package/dist/clientSideScripts/getDocumentScrollHeight.test.js

@@ -0,0 +1,30 @@
+// @vitest-environment jsdom
+import { describe, it, expect } from 'vitest';
+import getDocumentScrollHeight from './getDocumentScrollHeight.js';
+import { CONFIGURABLE } from '../mocks/mocks.js';
+describe('getDocumentScrollHeight', () => {
+    it('should return the bodyScrollHeight', () => {
+        Object.defineProperty(document.documentElement, 'clientHeight', { value: 500, ...CONFIGURABLE });
+        Object.defineProperty(window, 'innerHeight', { value: 500, ...CONFIGURABLE });
+        Object.defineProperty(document.documentElement, 'scrollHeight', { value: 500, ...CONFIGURABLE });
+        Object.defineProperty(document.body, 'scrollHeight', { value: 1500, ...CONFIGURABLE });
+        expect(getDocumentScrollHeight()).toEqual(1500);
+    });
+    it('should return the scrollHeight', () => {
+        Object.defineProperty(document.documentElement, 'clientHeight', { value: 500, ...CONFIGURABLE });
+        Object.defineProperty(window, 'innerHeight', { value: 500, ...CONFIGURABLE });
+        Object.defineProperty(document.documentElement, 'scrollHeight', { value: 2250, ...CONFIGURABLE });
+        Object.defineProperty(document.body, 'scrollHeight', { value: 1500, ...CONFIGURABLE });
+        expect(getDocumentScrollHeight()).toEqual(2250);
+    });
+    it('should return the height of the largest node', () => {
+        Object.defineProperty(document.documentElement, 'clientHeight', { value: 1500, ...CONFIGURABLE });
+        Object.defineProperty(window, 'innerHeight', { value: 1500, ...CONFIGURABLE });
+        Object.defineProperty(document.documentElement, 'scrollHeight', { value: 1500, ...CONFIGURABLE });
+        Object.defineProperty(document.body, 'scrollHeight', { value: 1500, ...CONFIGURABLE });
+        document.body.innerHTML =
+            '<div>' + '  <span style="height: 200px;width: 50px"/>' + '  <div style="height: 500px;width: 50px" />' + '</div>';
+        // Some lines and the outcome can't be tested because we can't mock `scrollHeight` and `clientHeight`
+        getDocumentScrollHeight();
+    });
+});

package/dist/clientSideScripts/getElementPositionTopDom.d.ts

@@ -0,0 +1,6 @@
+import type { ElementPosition } from './elementPosition.interfaces.js';
+/**
+ * Get the position of the element to the top of the DOM
+ */
+export default function getElementPositionTopDom(element: HTMLElement): ElementPosition;
+//# sourceMappingURL=getElementPositionTopDom.d.ts.map

package/dist/clientSideScripts/getElementPositionTopDom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getElementPositionTopDom.d.ts","sourceRoot":"","sources":["../../src/clientSideScripts/getElementPositionTopDom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,eAAe,CAOtF"}

package/dist/clientSideScripts/getElementPositionTopDom.js

@@ -0,0 +1,11 @@
+/**
+ * Get the position of the element to the top of the DOM
+ */
+export default function getElementPositionTopDom(element) {
+    return {
+        height: element.offsetHeight,
+        width: element.offsetWidth,
+        x: element.offsetLeft,
+        y: element.offsetTop,
+    };
+}

package/dist/clientSideScripts/getElementPositionTopDom.test.d.ts

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

package/dist/clientSideScripts/getElementPositionTopDom.test.d.ts.map

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

package/dist/clientSideScripts/getElementPositionTopDom.test.js

@@ -0,0 +1,11 @@
+// @vitest-environment jsdom
+import { describe, it } from 'vitest';
+import getElementPositionTopDom from './getElementPositionTopDom.js';
+describe('getElementPositionTopDom', () => {
+    it('should get the element position to the top of the Dom', () => {
+        document.body.innerHTML = '<div>' + '  <span id="username">Hello</span>' + '</div>';
+        getElementPositionTopDom(document.querySelector('#username'));
+        // I can't mock the offsetHeight, offsetWidth, offsetLeft, offsetTop with Jest, so there is no verification here, sorry :(
+        // If you know a way, please add it here ;-)
+    });
+});

package/dist/clientSideScripts/getElementPositionTopScreenNativeMobile.d.ts

@@ -0,0 +1,14 @@
+import type { ElementPosition } from './elementPosition.interfaces.js';
+/**
+ * Get the element position to the top of the screen of the device, not the top of the webview
+ * This method is used for Android native and iOS screenshots
+ */
+export declare function getElementPositionTopScreenNativeMobile(element: HTMLElement, { isLandscape, safeArea, screenHeight, screenWidth, sideBarWidth, statusBarAddressBarHeight, }: {
+    isLandscape: boolean;
+    safeArea: number;
+    screenHeight: number;
+    screenWidth: number;
+    sideBarWidth: number;
+    statusBarAddressBarHeight: number;
+}): ElementPosition;
+//# sourceMappingURL=getElementPositionTopScreenNativeMobile.d.ts.map

package/dist/clientSideScripts/getElementPositionTopScreenNativeMobile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getElementPositionTopScreenNativeMobile.d.ts","sourceRoot":"","sources":["../../src/clientSideScripts/getElementPositionTopScreenNativeMobile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE;;;GAGG;AACH,wBAAgB,uCAAuC,CACnD,OAAO,EAAE,WAAW,EACpB,EACI,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,yBAAyB,GAC5B,EAAE;IACC,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,yBAAyB,EAAE,MAAM,CAAC;CACrC,GACF,eAAe,CAgBjB"}

package/dist/clientSideScripts/getElementPositionTopScreenNativeMobile.js

@@ -0,0 +1,19 @@
+/**
+ * Get the element position to the top of the screen of the device, not the top of the webview
+ * This method is used for Android native and iOS screenshots
+ */
+export function getElementPositionTopScreenNativeMobile(element, { isLandscape, safeArea, screenHeight, screenWidth, sideBarWidth, statusBarAddressBarHeight, }) {
+    // Get some heights and widths
+    const { innerHeight } = window;
+    // Determine element position
+    const elementPosition = element.getBoundingClientRect();
+    const y = (screenHeight === innerHeight || screenWidth === innerHeight)
+        ? elementPosition.top
+        : statusBarAddressBarHeight + elementPosition.top;
+    return {
+        height: elementPosition.height,
+        width: elementPosition.width,
+        x: elementPosition.left + (isLandscape ? safeArea : 0) + sideBarWidth,
+        y: y,
+    };
+}

package/dist/clientSideScripts/getElementPositionTopScreenNativeMobile.test.d.ts

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

package/dist/clientSideScripts/getElementPositionTopScreenNativeMobile.test.d.ts.map

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

package/dist/clientSideScripts/getElementPositionTopScreenNativeMobile.test.js

@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { IOS_DEVICES, CONFIGURABLE } from '../mocks/mocks.js';
+import { getElementPositionTopScreenNativeMobile } from './getElementPositionTopScreenNativeMobile.js';
+describe('getElementPositionTopScreenNativeMobile', () => {
+    beforeEach(() => {
+        Element.prototype.getBoundingClientRect = vi.fn(() => {
+            return {
+                width: 120,
+                height: 120,
+                top: 10,
+                left: 100,
+                bottom: 5,
+                right: 12,
+            };
+        });
+        document.body.innerHTML = '<div>' + '  <span id="username">Hello</span>' + '</div>';
+    });
+    it('should get the element position to the top of the screen for a mobile browser', () => {
+        Object.defineProperty(window, 'innerHeight', { value: IOS_DEVICES.IPHONE.innerHeight, ...CONFIGURABLE });
+        expect(getElementPositionTopScreenNativeMobile(document.querySelector('#username'), {
+            isLandscape: false,
+            safeArea: 0,
+            screenHeight: IOS_DEVICES.IPHONE.height,
+            screenWidth: IOS_DEVICES.IPHONE.width,
+            sideBarWidth: IOS_DEVICES.IPHONE.sideBar,
+            statusBarAddressBarHeight: 94,
+        })).toMatchSnapshot();
+    });
+    it('should get the element position to the top of the screen for an app in portrait mode', () => {
+        Object.defineProperty(window, 'innerHeight', { value: IOS_DEVICES.IPHONE.height, ...CONFIGURABLE });
+        expect(getElementPositionTopScreenNativeMobile(document.querySelector('#username'), {
+            isLandscape: false,
+            safeArea: 0,
+            screenHeight: IOS_DEVICES.IPHONE.height,
+            screenWidth: IOS_DEVICES.IPHONE.width,
+            sideBarWidth: IOS_DEVICES.IPHONE.sideBar,
+            statusBarAddressBarHeight: 94,
+        })).toMatchSnapshot();
+    });
+    it('should get the element position to the top of the screen for an app in landscape mode', () => {
+        Object.defineProperty(window, 'innerHeight', { value: IOS_DEVICES.IPHONE.width, ...CONFIGURABLE });
+        expect(getElementPositionTopScreenNativeMobile(document.querySelector('#username'), {
+            isLandscape: true,
+            safeArea: 44,
+            screenHeight: IOS_DEVICES.IPHONE.innerHeight,
+            screenWidth: IOS_DEVICES.IPHONE.width,
+            sideBarWidth: IOS_DEVICES.IPHONE.sideBar,
+            statusBarAddressBarHeight: 94,
+        })).toMatchSnapshot();
+    });
+});

package/dist/clientSideScripts/getMobileWebviewClickAndDimensions.d.ts

@@ -0,0 +1,6 @@
+import type { RectanglesOutput } from '../methods/rectangles.interfaces.js';
+/**
+ * Get the click and dimensions of the mobile webview and remove the overlay
+ */
+export declare function getMobileWebviewClickAndDimensions(overlaySelector: string): RectanglesOutput;
+//# sourceMappingURL=getMobileWebviewClickAndDimensions.d.ts.map

package/dist/clientSideScripts/getMobileWebviewClickAndDimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMobileWebviewClickAndDimensions.d.ts","sourceRoot":"","sources":["../../src/clientSideScripts/getMobileWebviewClickAndDimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAA;AAE3E;;GAEG;AACH,wBAAgB,kCAAkC,CAAC,eAAe,EAAE,MAAM,GAAE,gBAAgB,CAe3F"}

package/dist/clientSideScripts/getMobileWebviewClickAndDimensions.js

@@ -0,0 +1,17 @@
+/**
+ * Get the click and dimensions of the mobile webview and remove the overlay
+ */
+export function getMobileWebviewClickAndDimensions(overlaySelector) {
+    const overlay = document.querySelector(overlaySelector);
+    const defaultValue = { y: 0, x: 0, width: 0, height: 0 };
+    if (!overlay || !overlay.dataset.icsWebviewData) {
+        return defaultValue;
+    }
+    overlay.remove();
+    try {
+        return JSON.parse(overlay.dataset.icsWebviewData);
+    }
+    catch {
+        return defaultValue;
+    }
+}

package/dist/clientSideScripts/getMobileWebviewClickAndDimensions.test.d.ts

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

package/dist/clientSideScripts/getMobileWebviewClickAndDimensions.test.d.ts.map

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

package/dist/clientSideScripts/getMobileWebviewClickAndDimensions.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { getMobileWebviewClickAndDimensions } from './getMobileWebviewClickAndDimensions.js';
+describe('getMobileWebviewClickAndDimensions', () => {
+    const selector = '[data-test="ics-overlay"]';
+    beforeEach(() => {
+        const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+        global.document = dom.window.document;
+        global.window = dom.window;
+    });
+    it('should return default values when overlay is not found', () => {
+        expect(getMobileWebviewClickAndDimensions(selector)).toEqual({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+        });
+    });
+    it('should return default values when data attribute is missing', () => {
+        const el = document.createElement('div');
+        el.setAttribute('data-test', 'ics-overlay');
+        document.body.appendChild(el);
+        expect(getMobileWebviewClickAndDimensions(selector)).toEqual({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+        });
+    });
+    it('should return parsed data from data attribute and remove element', () => {
+        const el = document.createElement('div');
+        el.setAttribute('data-test', 'ics-overlay');
+        el.dataset.icsWebviewData = JSON.stringify({ x: 10, y: 20, width: 100, height: 200 });
+        document.body.appendChild(el);
+        const result = getMobileWebviewClickAndDimensions(selector);
+        expect(result).toEqual({ x: 10, y: 20, width: 100, height: 200 });
+        expect(document.querySelector(selector)).toBeNull();
+    });
+    it('should return default values if JSON parsing fails', () => {
+        const el = document.createElement('div');
+        el.setAttribute('data-test', 'ics-overlay');
+        el.dataset.icsWebviewData = '{not:valid:json';
+        document.body.appendChild(el);
+        const result = getMobileWebviewClickAndDimensions(selector);
+        expect(result).toEqual({ x: 0, y: 0, width: 0, height: 0 });
+    });
+});

package/dist/clientSideScripts/getScreenDimensions.d.ts

@@ -0,0 +1,6 @@
+import type { ScreenDimensions } from './screenDimensions.interfaces.js';
+/**
+ * Get all the screen dimensions
+ */
+export default function getScreenDimensions(isMobile: boolean): ScreenDimensions;
+//# sourceMappingURL=getScreenDimensions.d.ts.map

package/dist/clientSideScripts/getScreenDimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getScreenDimensions.d.ts","sourceRoot":"","sources":["../../src/clientSideScripts/getScreenDimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAExE;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,gBAAgB,CAwG/E"}

package/dist/clientSideScripts/getScreenDimensions.js

@@ -0,0 +1,104 @@
+/**
+ * Get all the screen dimensions
+ */
+export default function getScreenDimensions(isMobile) {
+    // We need to determine if the screen is emulated, because that would return different values
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    const dpr = window.devicePixelRatio || 1;
+    const minEdge = Math.min(width, height);
+    const maxEdge = Math.max(width, height);
+    const isLikelyEmulated = !isMobile && // Only check for emulated on desktop
+        dpr >= 2 && // High-DPI signal
+        minEdge <= 800 && // Catch phones/tablets in portrait/landscape
+        maxEdge <= 1280 && // Conservative max for emulated tablet sizes
+        width > 0 && height > 0; // Sanity check
+    // Other checks
+    const body = document.body;
+    const html = document.documentElement;
+    const bodyDimensions = {
+        // On mobile & desktop: Total scrollable height of the body element, including content not visible on screen
+        scrollHeight: !body ? 0 : body.scrollHeight,
+        // On mobile & desktop: Height of body element including padding but not margin
+        offsetHeight: !body ? 0 : body.offsetHeight,
+    };
+    const htmlDimensions = {
+        /** On mobile & desktop: Viewport height excluding scrollbars */
+        clientHeight: !html ? 0 : html.clientHeight,
+        /** On mobile & desktop: Viewport width excluding scrollbars */
+        clientWidth: !html ? 0 : html.clientWidth,
+        /** On mobile & desktop: Total scrollable height including overflow */
+        scrollHeight: !html ? 0 : html.scrollHeight,
+        /** On mobile & desktop: Total scrollable width including overflow */
+        scrollWidth: !html ? 0 : html.scrollWidth,
+        /** On mobile & desktop: Height including padding and border */
+        offsetHeight: !html ? 0 : html.offsetHeight,
+    };
+    const windowDimensions = {
+        /**
+         * Mobile: Viewport width (changes with zoom)
+         * Desktop: Viewport width including scrollbars
+         */
+        innerWidth: window.innerWidth,
+        /**
+         * Mobile: Viewport height (changes with zoom)
+         * Desktop: Viewport height including scrollbars
+         */
+        innerHeight: window.innerHeight,
+        /**
+         * Mobile: True if device is in landscape orientation
+         * Desktop: Based on viewport aspect ratio
+         */
+        isLandscape: window.matchMedia('(orientation: landscape)').matches,
+        /**
+         * Mobile: Full browser height including UI elements
+         * Desktop: Browser window height including toolbars/status bar
+         * Emulated: It will be the same as window.innerHeight
+         */
+        outerHeight: isLikelyEmulated && window.outerHeight > 0 ?
+            window.innerHeight :
+            window.outerHeight === 0 ?
+                htmlDimensions.clientHeight :
+                window.outerHeight,
+        /**
+         * Mobile: Full browser width
+         * Desktop: Browser window width
+         * Emulated: It will be the same as window.innerWidth
+         */
+        outerWidth: isLikelyEmulated && window.outerWidth > 0 ?
+            window.innerWidth :
+            window.outerWidth === 0 ?
+                htmlDimensions.clientWidth :
+                window.outerWidth,
+        /**
+         * Mobile: Physical pixel ratio (typically >1 for high DPI)
+         * Desktop: Usually 1, or 2 for high DPI displays
+         */
+        devicePixelRatio: dpr,
+        /**
+         * Mobile: Always false
+         * Desktop: Always false
+         * Emulated: Always true
+         */
+        isEmulated: isLikelyEmulated,
+        /**
+         * Mobile: Physical screen width in CSS pixels
+         * Desktop: Monitor width in pixels
+         * Emulated: It will be the same as window.innerWidth
+         */
+        screenWidth: isLikelyEmulated ? window.innerWidth : window.screen.width,
+        /**
+         * Mobile: Physical screen height in CSS pixels
+         * Desktop: Monitor height in pixels
+         * Emulated: It will be the same as window.innerHeight
+         */
+        screenHeight: isLikelyEmulated ? window.innerHeight : window.screen.height,
+    };
+    return {
+        dimensions: {
+            body: bodyDimensions,
+            html: htmlDimensions,
+            window: windowDimensions,
+        },
+    };
+}

package/dist/clientSideScripts/getScreenDimensions.test.d.ts

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

package/dist/clientSideScripts/getScreenDimensions.test.d.ts.map

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

package/dist/clientSideScripts/getScreenDimensions.test.js

@@ -0,0 +1,161 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from 'vitest';
+import { CONFIGURABLE } from '../mocks/mocks.js';
+import getScreenDimensions from './getScreenDimensions.js';
+describe('getScreenDimensions', () => {
+    it('should get the needed screen dimensions for a real device', () => {
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: true,
+            })),
+            ...CONFIGURABLE,
+        });
+        expect(getScreenDimensions(true)).toMatchSnapshot();
+    });
+    it('should get the needed screen dimensions', () => {
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: true,
+            })),
+            ...CONFIGURABLE,
+        });
+        expect(getScreenDimensions(false)).toMatchSnapshot();
+    });
+    it('should get the needed screen dimensions if the outerHeight and outerWidth are set to 0', () => {
+        Object.defineProperty(window, 'outerHeight', { value: 0 });
+        Object.defineProperty(window, 'outerWidth', { value: 0 });
+        Object.defineProperty(document.documentElement, 'clientHeight', { value: 1234 });
+        Object.defineProperty(document.documentElement, 'clientWidth', { value: 4321 });
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: false,
+            })),
+            ...CONFIGURABLE,
+        });
+        expect(getScreenDimensions(false)).toMatchSnapshot();
+    });
+    it('should return zeroed dimensions if the document attributes are null', () => {
+        Object.defineProperty(document, 'body', { value: null });
+        Object.defineProperty(document, 'documentElement', { value: null });
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: false,
+            })),
+            ...CONFIGURABLE,
+        });
+        expect(getScreenDimensions(false)).toMatchSnapshot();
+    });
+    it('should detect mobile emulation and return emulated dimensions', () => {
+        const mockScreen = {
+            width: 375,
+            height: 667
+        };
+        const originalScreen = window.screen;
+        Object.defineProperty(window, 'screen', {
+            value: mockScreen,
+            configurable: true,
+            writable: true
+        });
+        Object.defineProperty(window, 'devicePixelRatio', { value: 3, configurable: true });
+        Object.defineProperty(window, 'innerWidth', { value: 375, configurable: true });
+        Object.defineProperty(window, 'innerHeight', { value: 667, configurable: true });
+        Object.defineProperty(window, 'outerWidth', { value: 375, configurable: true });
+        Object.defineProperty(window, 'outerHeight', { value: 667, configurable: true });
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: false,
+            })),
+            ...CONFIGURABLE,
+        });
+        const dimensions = getScreenDimensions(false);
+        Object.defineProperty(window, 'screen', {
+            value: originalScreen,
+            configurable: true,
+            writable: true
+        });
+        expect(dimensions.dimensions.window.screenWidth).toBe(375);
+        expect(dimensions.dimensions.window.screenHeight).toBe(667);
+        expect(dimensions.dimensions.window.outerWidth).toBe(375);
+        expect(dimensions.dimensions.window.outerHeight).toBe(667);
+        expect(dimensions.dimensions.window.devicePixelRatio).toBe(3);
+    });
+    it('should handle desktop (non-emulated) dimensions correctly', () => {
+        const mockScreen = {
+            width: 1920,
+            height: 1080
+        };
+        const originalScreen = window.screen;
+        Object.defineProperty(window, 'screen', {
+            value: mockScreen,
+            configurable: true,
+            writable: true
+        });
+        Object.defineProperty(window, 'devicePixelRatio', { value: 1, configurable: true });
+        Object.defineProperty(window, 'innerWidth', { value: 1440, configurable: true });
+        Object.defineProperty(window, 'innerHeight', { value: 900, configurable: true });
+        Object.defineProperty(window, 'outerWidth', { value: 1440, configurable: true });
+        Object.defineProperty(window, 'outerHeight', { value: 900, configurable: true });
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: true,
+            })),
+            ...CONFIGURABLE,
+        });
+        const dimensions = getScreenDimensions(false);
+        Object.defineProperty(window, 'screen', {
+            value: originalScreen,
+            configurable: true,
+            writable: true
+        });
+        expect(dimensions.dimensions.window.screenWidth).toBe(1920);
+        expect(dimensions.dimensions.window.screenHeight).toBe(1080);
+        expect(dimensions.dimensions.window.outerWidth).toBe(1440);
+        expect(dimensions.dimensions.window.outerHeight).toBe(900);
+        expect(dimensions.dimensions.window.devicePixelRatio).toBe(1);
+    });
+    it('should handle high DPI desktop displays', () => {
+        const mockScreen = {
+            width: 2880,
+            height: 1800
+        };
+        const originalScreen = window.screen;
+        Object.defineProperty(window, 'screen', {
+            value: mockScreen,
+            configurable: true,
+            writable: true
+        });
+        Object.defineProperty(window, 'devicePixelRatio', { value: 2, configurable: true });
+        Object.defineProperty(window, 'innerWidth', { value: 1440, configurable: true });
+        Object.defineProperty(window, 'innerHeight', { value: 900, configurable: true });
+        Object.defineProperty(window, 'outerWidth', { value: 1440, configurable: true });
+        Object.defineProperty(window, 'outerHeight', { value: 900, configurable: true });
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: true,
+            })),
+            ...CONFIGURABLE,
+        });
+        const dimensions = getScreenDimensions(false);
+        Object.defineProperty(window, 'screen', {
+            value: originalScreen,
+            configurable: true,
+            writable: true
+        });
+        expect(dimensions.dimensions.window.devicePixelRatio).toBe(2);
+        expect(dimensions.dimensions.window.screenWidth).toBe(2880);
+        expect(dimensions.dimensions.window.screenHeight).toBe(1800);
+    });
+    it('should handle zero devicePixelRatio', () => {
+        Object.defineProperty(window, 'devicePixelRatio', { value: 0, configurable: true });
+        Object.defineProperty(window, 'innerWidth', { value: 1920, configurable: true });
+        Object.defineProperty(window, 'innerHeight', { value: 1080, configurable: true });
+        Object.defineProperty(window, 'matchMedia', {
+            value: vi.fn().mockImplementation(() => ({
+                matches: true,
+            })),
+            ...CONFIGURABLE,
+        });
+        const dimensions = getScreenDimensions(false);
+        expect(dimensions.dimensions.window.devicePixelRatio).toBe(1);
+    });
+});

package/dist/clientSideScripts/hideRemoveElements.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hide or remove elements on the page
+ */
+export default function hideRemoveElements(hideRemoveElements: {
+    hide: (HTMLElement | HTMLElement[])[];
+    remove: (HTMLElement | HTMLElement[])[];
+}, hideRemove: boolean): void;
+//# sourceMappingURL=hideRemoveElements.d.ts.map

package/dist/clientSideScripts/hideRemoveElements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hideRemoveElements.d.ts","sourceRoot":"","sources":["../../src/clientSideScripts/hideRemoveElements.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACtC,kBAAkB,EAAE;IAChB,IAAI,EAAE,CAAC,WAAW,GAAG,WAAW,EAAE,CAAC,EAAE,CAAC;IACtC,MAAM,EAAE,CAAC,WAAW,GAAG,WAAW,EAAE,CAAC,EAAE,CAAC;CAC3C,EACD,UAAU,EAAE,OAAO,QAgEtB"}

package/dist/clientSideScripts/hideRemoveElements.js

@@ -0,0 +1,60 @@
+/**
+ * Hide or remove elements on the page
+ */
+export default function hideRemoveElements(hideRemoveElements, hideRemove) {
+    const visitedSelectors = {};
+    hideRemoveElements.hide.forEach((element) => {
+        if (Array.isArray(element)) {
+            return element.forEach((singleElement) => hideRemoveEl(singleElement, 'visibility', hideRemove));
+        }
+        hideRemoveEl(element, 'visibility', hideRemove);
+    });
+    hideRemoveElements.remove.forEach((element) => {
+        if (Array.isArray(element)) {
+            return element.forEach((singleElement) => hideRemoveEl(singleElement, 'display', hideRemove));
+        }
+        hideRemoveEl(element, 'display', hideRemove);
+    });
+    function hideRemoveEl(el, prop, hideRemove) {
+        // @ts-ignore
+        if (el.style) {
+            // Here we get the HTMLElement
+            // @ts-ignore
+            setPropertyToElement(el, prop, hideRemove);
+        }
+        else {
+            // Here we have the WebElement, with the web element we can have 2 types of selectors
+            // css and xpath, transform them into HTML
+            // This is an anti pattern, but I don't know how to do this better with XPATH selection
+            try {
+                // @ts-ignore
+                const selector = el.selector;
+                if (!visitedSelectors[selector]) {
+                    visitedSelectors[selector] = true;
+                    const elems = document.querySelectorAll(selector);
+                    elems.forEach((singleEl) => setPropertyToElement(singleEl, prop, hideRemove));
+                }
+            }
+            catch (_e) {
+                // 99.99% sure that we have XPATH here
+                // @ts-ignore
+                return getElementsByXpath(el.selector).forEach((singleEl) => setPropertyToElement(singleEl, prop, hideRemove));
+            }
+        }
+    }
+    function setPropertyToElement(el, prop, hideRemove) {
+        const value = prop === 'visibility' ? 'hidden' : 'none';
+        // @ts-ignore
+        el.style[prop] = hideRemove ? value : '';
+        hideRemove ? el.style.setProperty(prop, value, 'important') : el.style.removeProperty(prop);
+    }
+    // Stupid TypeScript =)
+    function getElementsByXpath(xpathToExecute) {
+        const result = [];
+        const nodesSnapshot = document.evaluate(xpathToExecute, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+        for (let i = 0; i < nodesSnapshot.snapshotLength; i++) {
+            result.push(nodesSnapshot.snapshotItem(i));
+        }
+        return result;
+    }
+}

package/dist/clientSideScripts/hideRemoveElements.test.d.ts

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

package/dist/clientSideScripts/hideRemoveElements.test.d.ts.map

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