@cloudscape-design/browser-test-tools 3.0.0

package/dist/image-utils/compare.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cropAndCompare = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const pngjs_1 = require("pngjs");
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const utils_1 = require("./utils");
+function compareImages(firstImage, secondImage, { width, height }) {
+    // fast path when two image files are identical
+    if (firstImage.data.equals(secondImage.data)) {
+        return { diffPixels: 0, diffImage: null };
+    }
+    const diffImage = new pngjs_1.PNG({ width, height });
+    const diffPixels = (0, pixelmatch_1.default)(firstImage.data, secondImage.data, diffImage.data, width, height, { threshold: 0.01 });
+    return { diffPixels, diffImage };
+}
+function normalizeSize(firstScreenshot, secondScreenshot) {
+    return {
+        height: Math.round(Math.max(firstScreenshot.height, secondScreenshot.height)),
+        width: Math.round(Math.max(firstScreenshot.width, secondScreenshot.width)),
+    };
+}
+function scaleSize(size, pixelRatio) {
+    return {
+        width: Math.ceil(size.width * pixelRatio),
+        height: Math.ceil(size.height * pixelRatio),
+    };
+}
+async function cropAndCompare(firstScreenshot, secondScreenshot) {
+    const pixelRatio = firstScreenshot.pixelRatio || 1;
+    const size = normalizeSize(firstScreenshot, secondScreenshot);
+    const firstImageCropRect = {
+        height: size.height,
+        width: size.width,
+        bottom: firstScreenshot.offset.top + size.height,
+        right: firstScreenshot.offset.left + size.width,
+        top: firstScreenshot.offset.top,
+        left: firstScreenshot.offset.left,
+    };
+    const secondImageCropRect = {
+        height: size.height,
+        width: size.width,
+        bottom: secondScreenshot.offset.top + size.height,
+        right: secondScreenshot.offset.left + size.width,
+        top: secondScreenshot.offset.top,
+        left: secondScreenshot.offset.left,
+    };
+    const firstImage = (0, utils_1.cropImage)(firstScreenshot.image, firstImageCropRect, pixelRatio);
+    const secondImage = (0, utils_1.cropImage)(secondScreenshot.image, secondImageCropRect, pixelRatio);
+    const { diffImage, diffPixels } = compareImages(firstImage, secondImage, scaleSize(size, pixelRatio));
+    const [firstPacked, secondPacked, diffPacked] = await Promise.all([
+        (0, utils_1.packPng)(firstImage),
+        (0, utils_1.packPng)(secondImage),
+        diffImage && (0, utils_1.packPng)(diffImage),
+    ]);
+    return {
+        firstImage: firstPacked,
+        secondImage: secondPacked,
+        diffImage: diffPacked,
+        isEqual: diffPixels <= 1,
+        diffPixels,
+    };
+}
+exports.cropAndCompare = cropAndCompare;

package/dist/image-utils/crop.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { PNG } from 'pngjs';
+import { ElementOffset, ElementRect } from '../page-objects/types';
+export declare function cropByOffset(encodedImage: PNG, offset: ElementOffset): Promise<Buffer>;
+export declare function cropByRect(encodedImage: PNG, rect: ElementRect): Promise<Buffer>;

package/dist/image-utils/crop.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cropByRect = exports.cropByOffset = void 0;
+const utils_1 = require("./utils");
+async function cropByOffset(encodedImage, offset) {
+    const rect = {
+        top: offset.top,
+        left: offset.left,
+        bottom: encodedImage.height,
+        right: encodedImage.width,
+        height: encodedImage.height - offset.top,
+        width: encodedImage.width - offset.left,
+    };
+    return cropByRect(encodedImage, rect);
+}
+exports.cropByOffset = cropByOffset;
+async function cropByRect(encodedImage, rect) {
+    const image = await (0, utils_1.cropImage)(encodedImage, rect);
+    return (0, utils_1.packPng)(image);
+}
+exports.cropByRect = cropByRect;

package/dist/image-utils/index.d.ts

@@ -0,0 +1,3 @@
+export { cropAndCompare } from './compare';
+export { cropByOffset } from './crop';
+export { parsePng } from './utils';

package/dist/image-utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePng = exports.cropByOffset = exports.cropAndCompare = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var compare_1 = require("./compare");
+Object.defineProperty(exports, "cropAndCompare", { enumerable: true, get: function () { return compare_1.cropAndCompare; } });
+var crop_1 = require("./crop");
+Object.defineProperty(exports, "cropByOffset", { enumerable: true, get: function () { return crop_1.cropByOffset; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "parsePng", { enumerable: true, get: function () { return utils_1.parsePng; } });

package/dist/image-utils/merge.d.ts

@@ -0,0 +1 @@
+export default function mergeImages(images: string[], width: number, height: number, lastImageOffset: number, offsetTop: number): Promise<string>;

package/dist/image-utils/merge.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const pngjs_1 = require("pngjs");
+const utils_1 = require("./utils");
+async function mergeImages(images, width, height, lastImageOffset, offsetTop) {
+    const outImage = new pngjs_1.PNG({ width, height: height * images.length - lastImageOffset });
+    if (images.length === 1) {
+        const png = await (0, utils_1.parsePng)(images[0]);
+        png.bitblt(outImage, 0, offsetTop, width, height - lastImageOffset, 0, 0);
+    }
+    else {
+        for (let index = 0; index < images.length; index++) {
+            const png = await (0, utils_1.parsePng)(images[index]);
+            const verticalOffset = index < images.length - 1 ? index * height : index * height - lastImageOffset;
+            png.bitblt(outImage, 0, offsetTop, Math.min(width, png.width), Math.min(height, png.height), 0, verticalOffset);
+        }
+    }
+    const encoded = await (0, utils_1.packPng)(outImage);
+    return encoded.toString('base64');
+}
+exports.default = mergeImages;

package/dist/image-utils/utils.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { PNG } from 'pngjs';
+import { ElementRect } from '../page-objects/types';
+export declare function parsePng(encodedImage: string): Promise<PNG>;
+export declare function packPng(png: PNG): Promise<Buffer>;
+export declare function isValidImage(pixels: Buffer): boolean;
+export declare function cropImage(inImage: PNG, rect: ElementRect, pixelRatio?: number): PNG;

package/dist/image-utils/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cropImage = exports.isValidImage = exports.packPng = exports.parsePng = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const pngjs_1 = require("pngjs");
+const util_1 = require("util");
+const get_stream_1 = __importDefault(require("get-stream"));
+const exceptions_1 = require("../exceptions");
+function roundDimensions(rect) {
+    const result = {};
+    Object.keys(rect).forEach(key => {
+        result[key] = Math.round(rect[key]);
+    });
+    return result;
+}
+async function parsePng(encodedImage) {
+    const png = new pngjs_1.PNG();
+    await (0, util_1.promisify)(png.parse.bind(png))(Buffer.from(encodedImage, 'base64'));
+    return png;
+}
+exports.parsePng = parsePng;
+function packPng(png) {
+    return get_stream_1.default.buffer(png.pack());
+}
+exports.packPng = packPng;
+function isValidImage(pixels) {
+    let lastColor;
+    for (let i = 0; i < pixels.length; i += 4) {
+        const color = (pixels[i] << 24) + (pixels[i + 1] << 16) + (pixels[i + 2] << 8) + pixels[i + 3];
+        if (!lastColor) {
+            lastColor = color;
+        }
+        else if (color !== lastColor) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isValidImage = isValidImage;
+function cropImage(inImage, rect, pixelRatio = 1) {
+    const roundedRect = roundDimensions(rect);
+    const imageWidth = Math.ceil(roundedRect.width * pixelRatio || inImage.width);
+    const imageHeight = Math.ceil(roundedRect.height * pixelRatio || inImage.height);
+    const outImage = new pngjs_1.PNG({ width: imageWidth, height: imageHeight });
+    const safeLeft = Math.max(roundedRect.left, 0) * pixelRatio;
+    const safeTop = Math.max(roundedRect.top, 0) * pixelRatio;
+    const safeWidth = Math.min(imageWidth, inImage.width - safeLeft);
+    const safeHeight = Math.min(imageHeight, inImage.height - safeTop);
+    inImage.bitblt(outImage, safeLeft, safeTop, safeWidth, safeHeight, 0, 0);
+    if (!isValidImage(outImage.data)) {
+        throw new exceptions_1.ScreenshotTakeError('Image does not contain enough colors');
+    }
+    return outImage;
+}
+exports.cropImage = cropImage;

package/dist/page-objects/base.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="webdriverio/async" />
+import { ScrollPosition } from '../browser-scripts';
+import EventsSpy from './events-spy';
+import { ElementRect } from './types';
+export default class BasePageObject {
+    protected browser: WebdriverIO.Browser;
+    constructor(browser: WebdriverIO.Browser);
+    pause(milliseconds: number): Promise<void>;
+    keys(keys: string | string[]): Promise<void>;
+    setWindowSize({ width, height }: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    spyOnEvents(selector: string, events: string[]): Promise<EventsSpy>;
+    click(selector: string): Promise<void>;
+    hoverElement(selector: string, xOffset?: number, yOffset?: number): Promise<void>;
+    buttonDownOnElement(selector: string): Promise<void>;
+    buttonUp(): Promise<void>;
+    dragAndDrop(sourceSelector: string, xOffset?: number, yOffset?: number): Promise<void>;
+    getValue(selector: string): Promise<string>;
+    setValue(selector: string, value: number | string | string[]): Promise<void>;
+    getViewportSize(): Promise<import("./types").ViewportSize>;
+    getWindowScroll(): Promise<ScrollPosition>;
+    windowScrollTo({ top, left }: Partial<ScrollPosition>): Promise<void>;
+    getElementScroll(selector: string): Promise<ScrollPosition>;
+    elementScrollTo(selector: string, { top, left }: Partial<ScrollPosition>): Promise<void>;
+    waitForVisible(selector: string, shouldDisplay?: boolean, timeout?: number): Promise<void>;
+    waitForAssertion(expression: () => Promise<void>): Promise<void>;
+    waitForJsTimers(timeout?: number): Promise<void>;
+    isFocused(selector: string): Promise<boolean>;
+    isSelected(selector: string): Promise<boolean>;
+    isExisting(selector: string): Promise<boolean>;
+    isDisplayed(selector: string): Promise<boolean>;
+    getElementAttribute(selector: string, attributeName: string): Promise<string>;
+    getElementProperty(selector: string, propertyName: string): Promise<string | number | boolean | Element | ChildNode | ParentNode | Document | HTMLElement | CSSStyleDeclaration | DOMStringMap | DOMTokenList | HTMLCollection | HTMLSlotElement | NamedNodeMap | ShadowRoot | OnErrorEventHandler | NodeListOf<ChildNode> | {
+        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    } | {
+        <K_1 extends keyof HTMLElementEventMap>(type: K_1, listener: (this: HTMLElement, ev: HTMLElementEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    } | {
+        <K_2 extends keyof HTMLElementTagNameMap>(selector: K_2): HTMLElementTagNameMap[K_2] | null;
+        <K_3 extends keyof SVGElementTagNameMap>(selector: K_3): SVGElementTagNameMap[K_3] | null;
+        <E extends Element = Element>(selectors: string): E | null;
+    } | {
+        <K_4 extends keyof HTMLElementTagNameMap>(qualifiedName: K_4): HTMLCollectionOf<HTMLElementTagNameMap[K_4]>;
+        <K_5 extends keyof SVGElementTagNameMap>(qualifiedName: K_5): HTMLCollectionOf<SVGElementTagNameMap[K_5]>;
+        (qualifiedName: string): HTMLCollectionOf<Element>;
+    } | {
+        (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+        (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+        (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+    } | {
+        (options?: ScrollToOptions | undefined): void;
+        (x: number, y: number): void;
+    } | {
+        (options?: ScrollToOptions | undefined): void;
+        (x: number, y: number): void;
+    } | {
+        (options?: ScrollToOptions | undefined): void;
+        (x: number, y: number): void;
+    } | {
+        <K_6 extends keyof HTMLElementTagNameMap>(selectors: K_6): HTMLElementTagNameMap[K_6] | null;
+        <K_7 extends keyof SVGElementTagNameMap>(selectors: K_7): SVGElementTagNameMap[K_7] | null;
+        <E_1 extends Element = Element>(selectors: string): E_1 | null;
+    } | {
+        <K_8 extends keyof HTMLElementTagNameMap>(selectors: K_8): NodeListOf<HTMLElementTagNameMap[K_8]>;
+        <K_9 extends keyof SVGElementTagNameMap>(selectors: K_9): NodeListOf<SVGElementTagNameMap[K_9]>;
+        <E_2 extends Element = Element>(selectors: string): NodeListOf<E_2>;
+    } | (() => DOMRect) | ((event: Event) => boolean) | ((this: GlobalEventHandlers, ev: UIEvent) => any) | ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: FocusEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: DragEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: FocusEvent) => any) | ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: MouseEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: PointerEvent) => any) | ((this: GlobalEventHandlers, ev: ProgressEvent<EventTarget>) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: UIEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: TouchEvent) => any) | ((this: GlobalEventHandlers, ev: TouchEvent) => any) | ((this: GlobalEventHandlers, ev: TouchEvent) => any) | ((this: GlobalEventHandlers, ev: TouchEvent) => any) | ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: Event) => any) | ((this: GlobalEventHandlers, ev: WheelEvent) => any) | (() => ElementInternals) | (() => void) | ((this: Element, ev: Event) => any) | ((this: Element, ev: Event) => any) | ((init: ShadowRootInit) => ShadowRoot) | ((qualifiedName: string) => string | null) | ((namespace: string | null, localName: string) => string | null) | (() => string[]) | ((qualifiedName: string) => Attr | null) | ((namespace: string | null, localName: string) => Attr | null) | (() => DOMRectList) | ((classNames: string) => HTMLCollectionOf<Element>) | ((qualifiedName: string) => boolean) | ((namespace: string | null, localName: string) => boolean) | (() => boolean) | ((pointerId: number) => boolean) | ((where: InsertPosition, element: Element) => Element | null) | ((position: InsertPosition, text: string) => void) | ((where: InsertPosition, data: string) => void) | ((selectors: string) => boolean) | ((pointerId: number) => void) | ((qualifiedName: string) => void) | ((namespace: string | null, localName: string) => void) | ((attr: Attr) => Attr) | ((options?: FullscreenOptions | undefined) => Promise<void>) | (() => void) | ((arg?: boolean | ScrollIntoViewOptions | undefined) => void) | ((qualifiedName: string, value: string) => void) | ((namespace: string | null, qualifiedName: string, value: string) => void) | ((attr: Attr) => Attr | null) | ((attr: Attr) => Attr | null) | ((pointerId: number) => void) | ((qualifiedName: string, force?: boolean | undefined) => boolean) | ((selectors: string) => boolean) | (<T extends Node>(node: T) => T) | ((deep?: boolean | undefined) => Node) | ((other: Node) => number) | ((other: Node | null) => boolean) | ((options?: GetRootNodeOptions | undefined) => Node) | (() => boolean) | (<T_1 extends Node>(node: T_1, child: Node | null) => T_1) | ((namespace: string | null) => boolean) | ((otherNode: Node | null) => boolean) | ((otherNode: Node | null) => boolean) | ((prefix: string | null) => string | null) | ((namespace: string | null) => string | null) | (() => void) | (<T_2 extends Node>(child: T_2) => T_2) | (<T_3 extends Node>(node: Node, child: T_3) => T_3) | ((keyframes: PropertyIndexedKeyframes | Keyframe[] | null, options?: number | KeyframeAnimationOptions | undefined) => Animation) | ((options?: GetAnimationsOptions | undefined) => Animation[]) | ((...nodes: (string | Node)[]) => void) | ((...nodes: (string | Node)[]) => void) | (() => void) | ((...nodes: (string | Node)[]) => void) | ((...nodes: (string | Node)[]) => void) | ((...nodes: (string | Node)[]) => void) | ((...nodes: (string | Node)[]) => void) | ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | ((this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any) | (() => void) | ((options?: FocusOptions | undefined) => void) | undefined>;
+    getElementsCount(selector: string): Promise<number>;
+    getFocusedElementText(): Promise<string>;
+    getBoundingBox(selector: string): Promise<ElementRect>;
+    getText(selector: string): Promise<string>;
+    getElementsText(selector: string): Promise<string[]>;
+}

package/dist/page-objects/base.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const p_retry_1 = __importDefault(require("p-retry"));
+const browser_scripts_1 = require("../browser-scripts");
+const events_spy_1 = __importDefault(require("./events-spy"));
+const utils_1 = require("./utils");
+const browser_scripts_2 = require("./browser-scripts");
+class BasePageObject {
+    constructor(browser) {
+        this.browser = browser;
+    }
+    async pause(milliseconds) {
+        await this.browser.pause(milliseconds);
+    }
+    async keys(keys) {
+        await this.browser.keys(keys);
+    }
+    async setWindowSize({ width, height }) {
+        await this.browser.setWindowSize(width, height);
+    }
+    async spyOnEvents(selector, events) {
+        const spy = new events_spy_1.default(this.browser, selector, events);
+        await spy.init();
+        return spy;
+    }
+    async click(selector) {
+        const element = await this.browser.$(selector);
+        await element.click();
+    }
+    async hoverElement(selector, xOffset, yOffset) {
+        const element = await this.browser.$(selector);
+        await element.moveTo({ xOffset, yOffset });
+    }
+    async buttonDownOnElement(selector) {
+        // buttonDown exists only in JSON Wire protocol
+        if (this.browser.buttonDown) {
+            await this.hoverElement(selector);
+            await this.browser.buttonDown();
+        }
+        else {
+            // Clean up all previous actions before stating a new batch. Without this line Safari emits extra "mouseup" events
+            await this.browser.releaseActions();
+            const box = await this.getBoundingBox(selector);
+            const center = (0, utils_1.getElementCenter)(box);
+            // W3C alternative is `performActions`. All consecutive actions have to be a part of a single call
+            await this.browser.performActions([
+                {
+                    type: 'pointer',
+                    id: 'mouse',
+                    parameters: { pointerType: 'mouse' },
+                    actions: [
+                        { type: 'pointerMove', duration: 0, x: center.x, y: center.y },
+                        { type: 'pointerDown', button: 0 },
+                        // extra delay to let event listeners to be fired
+                        { type: 'pause', duration: 10 },
+                    ],
+                },
+            ]);
+        }
+    }
+    async buttonUp() {
+        // buttonUp exists only in JSON Wire protocol
+        if (this.browser.buttonUp) {
+            await this.browser.buttonUp();
+        }
+        else {
+            // W3C alternative is `performActions`
+            await this.browser.performActions([
+                {
+                    type: 'pointer',
+                    id: 'mouse',
+                    parameters: { pointerType: 'mouse' },
+                    actions: [
+                        { type: 'pointerUp', button: 0 },
+                        // extra delay for Safari to process the event before moving the cursor away
+                        { type: 'pause', duration: 10 },
+                        // return cursor back to the corner to avoid hover effects on screenshots
+                        { type: 'pointerMove', duration: 0, x: 0, y: 0 },
+                    ],
+                },
+            ]);
+            // make sure all controls are properly released to avoid conflicts with further actions
+            await this.browser.releaseActions();
+        }
+    }
+    async dragAndDrop(sourceSelector, xOffset = 0, yOffset = 0) {
+        const element = await this.browser.$(sourceSelector);
+        await element.dragAndDrop({ x: xOffset, y: yOffset });
+    }
+    async getValue(selector) {
+        const element = await this.browser.$(selector);
+        return element.getValue();
+    }
+    async setValue(selector, value) {
+        const element = await this.browser.$(selector);
+        await element.setValue(value);
+    }
+    async getViewportSize() {
+        return this.browser.execute(browser_scripts_1.getViewportSize);
+    }
+    async getWindowScroll() {
+        return this.browser.execute(browser_scripts_1.getWindowScrollPosition);
+    }
+    async windowScrollTo({ top = 0, left = 0 }) {
+        await this.browser.execute(browser_scripts_1.windowScrollTo, top, left);
+    }
+    async getElementScroll(selector) {
+        return this.browser.execute(browser_scripts_1.getElementScrollPosition, selector);
+    }
+    async elementScrollTo(selector, { top = 0, left = 0 }) {
+        await this.browser.execute(browser_scripts_1.elementScrollTo, selector, top, left);
+    }
+    async waitForVisible(selector, shouldDisplay = true, timeout) {
+        await this.browser.waitUntil(async () => {
+            const isDisplayed = await this.isDisplayed(selector);
+            return isDisplayed === shouldDisplay;
+        }, {
+            timeout,
+            timeoutMsg: shouldDisplay
+                ? `Element "${selector}" is not visible upon waiting`
+                : `Element "${selector}" is still visible after waiting`,
+        });
+    }
+    async waitForAssertion(expression) {
+        const retryOptions = { minTimeout: 100, retries: 5 };
+        await (0, p_retry_1.default)(expression, retryOptions);
+    }
+    // setTimeout and requestAnimationFrame on the page
+    async waitForJsTimers(timeout = 0) {
+        await this.browser.executeAsync(browser_scripts_2.waitForTimerAndAnimationFrame, timeout);
+    }
+    async isFocused(selector) {
+        const element = await this.browser.$(selector);
+        return element.isFocused();
+    }
+    async isSelected(selector) {
+        const element = await this.browser.$(selector);
+        return element.isSelected();
+    }
+    async isExisting(selector) {
+        const elements = await this.browser.$$(selector);
+        return elements.length > 0;
+    }
+    async isDisplayed(selector) {
+        // browser.$ throws an error if element is not found, so we use this method to avoid try/catch
+        const elements = await this.browser.$$(selector);
+        if (elements.length === 0) {
+            return false;
+        }
+        return elements[0].isDisplayed();
+    }
+    async getElementAttribute(selector, attributeName) {
+        const element = await this.browser.$(selector);
+        return element.getAttribute(attributeName);
+    }
+    async getElementProperty(selector, propertyName) {
+        const element = await this.browser.$(selector);
+        return element.getProperty(propertyName);
+    }
+    async getElementsCount(selector) {
+        const elements = await this.browser.$$(selector);
+        return elements.length;
+    }
+    async getFocusedElementText() {
+        const activeNode = await this.browser.getActiveElement();
+        const element = await this.browser.$(activeNode);
+        return element.getText();
+    }
+    async getBoundingBox(selector) {
+        return this.browser.execute(browser_scripts_1.getBoundingClientRect, selector);
+    }
+    async getText(selector) {
+        const element = await this.browser.$(selector);
+        return element.getText();
+    }
+    async getElementsText(selector) {
+        const elements = await this.browser.$$(selector);
+        return Promise.all(elements.map(async (element) => element.getText()));
+    }
+}
+exports.default = BasePageObject;

package/dist/page-objects/browser-scripts.d.ts

@@ -0,0 +1 @@
+export declare function waitForTimerAndAnimationFrame(timeout: number, done: () => void): void;

package/dist/page-objects/browser-scripts.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForTimerAndAnimationFrame = void 0;
+function waitForTimerAndAnimationFrame(timeout, done) {
+    setTimeout(function () {
+        requestAnimationFrame(function () {
+            done();
+        });
+    }, timeout);
+}
+exports.waitForTimerAndAnimationFrame = waitForTimerAndAnimationFrame;

package/dist/page-objects/events-spy.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="webdriverio/async" />
+export default class EventsSpy {
+    private browser;
+    private selector;
+    private events;
+    constructor(browser: WebdriverIO.Browser, selector: string, events: string[]);
+    init(): Promise<void>;
+    getEvents(): Promise<string[]>;
+    reset(): Promise<void>;
+}

package/dist/page-objects/events-spy.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const browser_scripts_1 = require("../browser-scripts");
+class EventsSpy {
+    constructor(browser, selector, events) {
+        this.browser = browser;
+        this.selector = selector;
+        this.events = events;
+    }
+    async init() {
+        await this.browser.execute(browser_scripts_1.initEventsSpy, this.selector, this.events);
+    }
+    async getEvents() {
+        return this.browser.execute(browser_scripts_1.getEvents);
+    }
+    async reset() {
+        await this.browser.execute(browser_scripts_1.resetEventsSpy);
+    }
+}
+exports.default = EventsSpy;

package/dist/page-objects/full-page-screenshot.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="webdriverio/async" />
+export default function fullPageScreenshot(browser: WebdriverIO.Browser): Promise<string>;

package/dist/page-objects/full-page-screenshot.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const browser_scripts_1 = require("../browser-scripts");
+const merge_1 = __importDefault(require("../image-utils/merge"));
+const browser_scripts_2 = require("./browser-scripts");
+const utils_1 = require("./utils");
+const MAX_SCREENSHOT_HEIGHT = 20000;
+async function scroll(browser, topOffset) {
+    await browser.execute(browser_scripts_1.windowScrollTo, topOffset, 0);
+}
+async function checkDocumentSize(browser) {
+    const viewPortSize = await browser.execute(browser_scripts_1.getViewportSize);
+    if (viewPortSize.pageHeight > MAX_SCREENSHOT_HEIGHT) {
+        console.warn(`The permutation page is higher than ${MAX_SCREENSHOT_HEIGHT}. Taking a screenshot might cause problems.`);
+    }
+    return viewPortSize;
+}
+async function scrollAndMergeStrategy(browser) {
+    const { width, height, pageHeight, screenWidth, screenHeight, pixelRatio } = await checkDocumentSize(browser);
+    let offset = 0;
+    const screenshots = [];
+    while (offset < pageHeight) {
+        await scroll(browser, offset);
+        // Wait for scroll effects to settle.
+        await browser.executeAsync(browser_scripts_2.waitForTimerAndAnimationFrame, 200);
+        const value = await browser.takeScreenshot();
+        screenshots.push(value);
+        offset += height;
+    }
+    // skip images merge when there is only one screenshot
+    if (screenshots.length === 1 && !browser.isIOS) {
+        return screenshots[0];
+    }
+    const lastImageOffset = offset - pageHeight;
+    let offsetTop = 0;
+    if (browser.isIOS) {
+        offsetTop = (0, utils_1.calculateIosTopOffset)({ screenWidth, screenHeight, pixelRatio });
+    }
+    return (0, merge_1.default)(screenshots, width * pixelRatio, height * pixelRatio, lastImageOffset * pixelRatio, offsetTop);
+}
+async function fullPageScreenshot(browser) {
+    const puppeteer = await (0, utils_1.getPuppeteer)(browser);
+    if (puppeteer) {
+        // casting due to mismatch in NodeJS types of EventEmitter
+        return puppeteerStrategy(browser, puppeteer);
+    }
+    console.warn('Falling back to scroll-and-merge strategy');
+    return scrollAndMergeStrategy(browser);
+}
+exports.default = fullPageScreenshot;
+async function puppeteerStrategy(browser, puppeteer) {
+    const image = await browser.call(async () => {
+        // Assuming only one page open
+        const [current] = await puppeteer.pages();
+        return current.screenshot({
+            fullPage: true,
+            encoding: 'base64',
+        });
+    });
+    // encoding=base64 returns a string
+    // See: https://pptr.dev/#?product=Puppeteer&version=v13.2.0&show=api-pagescreenshotoptions
+    return image;
+}

package/dist/page-objects/index.d.ts

@@ -0,0 +1,4 @@
+export { default as BasePageObject } from './base';
+export { default as ScreenshotPageObject } from './screenshot';
+export { default as EventsSpy } from './events-spy';
+export { ScreenshotWithOffset, ElementSize, ElementRect, ElementOffset } from './types';

package/dist/page-objects/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsSpy = exports.ScreenshotPageObject = exports.BasePageObject = void 0;
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var base_1 = require("./base");
+Object.defineProperty(exports, "BasePageObject", { enumerable: true, get: function () { return __importDefault(base_1).default; } });
+var screenshot_1 = require("./screenshot");
+Object.defineProperty(exports, "ScreenshotPageObject", { enumerable: true, get: function () { return __importDefault(screenshot_1).default; } });
+var events_spy_1 = require("./events-spy");
+Object.defineProperty(exports, "EventsSpy", { enumerable: true, get: function () { return __importDefault(events_spy_1).default; } });

package/dist/page-objects/screenshot.d.ts

@@ -0,0 +1,10 @@
+import BasePageObject from './base';
+import { ScreenshotCapturingOptions, ScreenshotWithOffset } from './types';
+export default class ScreenshotPageObject extends BasePageObject {
+    focusNextElement(): Promise<void>;
+    scrollToBottom(selector: string): Promise<void>;
+    scrollToRight(selector: string): Promise<void>;
+    fullPageScreenshot(): Promise<string>;
+    captureBySelector(selector: string, options?: ScreenshotCapturingOptions): Promise<ScreenshotWithOffset>;
+    captureViewport(): Promise<ScreenshotWithOffset>;
+}