@applitools/core 1.0.0

package/dist/ufg/utils/take-vhses.js

@@ -0,0 +1,258 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeVHSes = void 0;
+const utils = __importStar(require("@applitools/utils"));
+async function takeVHSes({ driver, settings, hooks, logger, }) {
+    var _a;
+    logger.log('taking VHS');
+    if (!driver.isAndroid && !driver.isIOS) {
+        throwError('cannot take VHS on mobile device other than iOS or Android');
+    }
+    await ((_a = hooks === null || hooks === void 0 ? void 0 : hooks.beforeSnapshots) === null || _a === void 0 ? void 0 : _a.call(hooks));
+    const trigger = await findElement({
+        driver,
+        selector: 'UFG_TriggerArea',
+        type: 'Button',
+        timeout: 30000,
+    });
+    if (driver.isAndroid) {
+        const apiKeyInput = await findElement({
+            driver,
+            selector: 'UFG_Apikey',
+            type: 'EditText',
+            throwErr: false,
+        });
+        if (apiKeyInput) {
+            // in case 'apiKeyInput' does not exist, it means it was already triggered on previous cycle
+            // this condition is to avoid re-sending 'inputJson' multiple times
+            const inputString = JSON.stringify({
+                serverUrl: settings.serverUrl || undefined,
+                apiKey: settings.apiKey,
+                proxy: settings.proxy ? transformProxy(settings.proxy) : undefined,
+            });
+            log('sending API key to UFG lib', inputString);
+            await apiKeyInput.type(inputString);
+            const ready = await findElement({
+                driver,
+                selector: 'UFG_ApikeyReady',
+                type: 'Button',
+            });
+            await ready.click();
+        }
+        else {
+            log('UFG_Apikey was skipped');
+        }
+    }
+    await trigger.click(); // TODO handle stale element exception and then find the trigger again and click it
+    let label = await findElement({
+        driver,
+        selector: 'UFG_SecondaryLabel',
+        type: 'TextView',
+        timeout: 10000,
+        throwErr: false,
+    });
+    if (!label) {
+        // This might happen if the tap on the trigger area didn't happen due to Appium bug. So we try to find the trigger again and if it's present, we'll tap it.
+        // If the trigger area is not present, then we're probably at the middle of taking the VHS - give it 50 seconds more until we give up
+        log('UFG_SecondaryLabel was not found after 10 seconds, trying to click UFG_TriggerArea again');
+        const triggerRetry = await findElement({
+            driver,
+            selector: 'UFG_TriggerArea',
+            type: 'Button',
+            timeout: 30000,
+            throwErr: false,
+        });
+        if (triggerRetry) {
+            log('UFG_TriggerArea was found on retry. clicking it.');
+            await triggerRetry.click();
+        }
+        else {
+            log('UFG_TriggerArea was NOT found on retry. Probably VHS is being taken.');
+        }
+        label = await findElement({
+            driver,
+            selector: 'UFG_SecondaryLabel',
+            type: 'TextView',
+            timeout: 50000,
+        });
+        if (!label) {
+            log('UFG_SecondaryLabel was not found eventually. Giving up.');
+        }
+    }
+    const info = JSON.parse(await label.getText());
+    log('VHS info', info);
+    if (info.error) {
+        throwError(info.error);
+    }
+    let vhs;
+    if (driver.isIOS) {
+        vhs = await extractVHS();
+    }
+    else if (info.mode === 'labels') {
+        vhs = await collectChunkedVHS({ count: info.partsCount });
+    }
+    else if (info.mode === 'network') {
+        // do nothing
+    }
+    else {
+        throwError(`unknown mode for android: ${info.mode}`);
+    }
+    const clear = await findElement({
+        driver,
+        selector: 'UFG_ClearArea',
+        type: 'Button',
+        timeout: 30000,
+    });
+    await clear.click();
+    let snapshot;
+    if (driver.isAndroid) {
+        snapshot = {
+            platformName: 'android',
+            vhsType: info.flavorName,
+            vhsHash: {
+                hashFormat: 'sha256',
+                hash: info.vhsHash,
+                contentType: `x-applitools-vhs/${info.flavorName}`,
+            },
+        };
+    }
+    else {
+        snapshot = {
+            platformName: 'ios',
+            resourceContents: {
+                vhs: {
+                    value: Buffer.from(vhs, 'base64'),
+                    type: 'x-applitools-vhs/ios',
+                },
+            },
+            vhsCompatibilityParams: {
+                UIKitLinkTimeVersionNumber: info.UIKitLinkTimeVersionNumber,
+                UIKitRunTimeVersionNumber: info.UIKitRunTimeVersionNumber,
+            },
+        };
+    }
+    return Array(settings.renderers.length).fill(snapshot);
+    async function extractVHS() {
+        const label = await findElement({
+            driver,
+            selector: 'UFG_Label',
+            type: 'TextView',
+        });
+        return await label.getText();
+    }
+    async function collectChunkedVHS({ count }) {
+        const labels = [
+            await findElement({
+                driver,
+                selector: 'UFG_Label_0',
+                type: 'TextView',
+            }),
+            await findElement({
+                driver,
+                selector: 'UFG_Label_1',
+                type: 'TextView',
+            }),
+            await findElement({
+                driver,
+                selector: 'UFG_Label_2',
+                type: 'TextView',
+            }),
+        ];
+        let vhs = '';
+        for (let chunk = 0; chunk < count / labels.length; ++chunk) {
+            for (let label = 0; label < Math.min(labels.length, count - chunk * labels.length); ++label) {
+                vhs += await labels[label].getText();
+            }
+            if (chunk * labels.length < count) {
+                await trigger.click();
+            }
+        }
+        return vhs;
+    }
+    function log(...msg) {
+        logger.log('[takeVHSes]', ...msg);
+    }
+}
+exports.takeVHSes = takeVHSes;
+function transformProxy(proxy) {
+    const url = new URL(proxy.url);
+    const transformedProxy = {
+        protocol: url.protocol,
+        host: url.hostname,
+        port: url.port,
+    };
+    if (proxy.username) {
+        transformedProxy.auth = { username: proxy.username, password: proxy.password };
+    }
+    else if (url.username) {
+        transformedProxy.auth = { username: url.username, password: proxy.password };
+    }
+    return transformedProxy;
+}
+function throwError(msg) {
+    throw new Error(`Error while taking VHS - ${msg}`);
+}
+async function findElement(options) {
+    const { selector, timeout = 0, throwErr = true } = options;
+    let element = await findElementBySelector(options);
+    if (!element && timeout)
+        element = await waitFor(options);
+    if (!element && throwErr) {
+        const timeoutError = timeout ? `, (waited for ${timeout} ms)` : '.';
+        throwError(`${selector} element could not be found${timeoutError}`);
+    }
+    return element;
+    async function waitFor(options) {
+        const { timeout } = options;
+        const interval = 500;
+        let waiting = true;
+        const waitTime = setTimeout(() => (waiting = false), timeout);
+        while (waiting) {
+            const element = await findElementBySelector(options);
+            if (element) {
+                clearTimeout(waitTime);
+                return element;
+            }
+            await utils.general.sleep(interval);
+        }
+        return null;
+    }
+    async function findElementBySelector(options) {
+        const { driver, selector, type } = options;
+        const context = driver.currentContext;
+        let element;
+        if (driver.isAndroid) {
+            element = await driver.element({
+                type: 'xpath',
+                selector: `//android.widget.${type}[@content-desc="${selector}"]`,
+            });
+        }
+        else {
+            element = await context.element({ type: 'accessibility id', selector });
+        }
+        return element;
+    }
+}

package/dist/utils/execute-poll-script.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePollScript = void 0;
+const core_base_1 = require("@applitools/core-base");
+const utils = __importStar(require("@applitools/utils"));
+async function executePollScript({ context, scripts, settings, logger, }) {
+    logger.log('Executing poll script');
+    let isExecutionTimedOut = false;
+    const executionTimer = setTimeout(() => (isExecutionTimedOut = true), settings.executionTimeout);
+    try {
+        const { script, args = [] } = scripts.main;
+        let response = deserialize(await context.execute(script, ...args));
+        let chunks = '';
+        while (!isExecutionTimedOut) {
+            if (response.status === 'ERROR') {
+                throw new core_base_1.CoreError(`Error during execute poll script: '${response.error}'`, {
+                    reason: 'poll script',
+                    error: response.error,
+                });
+            }
+            else if (response.status === 'SUCCESS') {
+                return response.value;
+            }
+            else if (response.status === 'SUCCESS_CHUNKED') {
+                chunks += response.value;
+                if (response.done)
+                    return deserialize(chunks);
+            }
+            else if (response.status === 'WIP') {
+                await utils.general.sleep(settings.pollTimeout);
+            }
+            logger.log('Polling...');
+            const { script, args = [] } = scripts.poll;
+            response = deserialize(await context.execute(script, ...args));
+        }
+        throw new core_base_1.CoreError('Poll script execution is timed out', { reason: 'timeout' });
+    }
+    finally {
+        clearTimeout(executionTimer);
+    }
+    function deserialize(json) {
+        try {
+            return JSON.parse(json);
+        }
+        catch (err) {
+            const firstChars = json.slice(0, 100);
+            const lastChars = json.slice(-100);
+            throw new Error(`Response is not a valid JSON string. length: ${json.length}, first 100 chars: "${firstChars}", last 100 chars: "${lastChars}". error: ${err}`);
+        }
+    }
+}
+exports.executePollScript = executePollScript;

package/dist/utils/extract-broker-url.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractBrokerUrl = void 0;
+async function extractBrokerUrl(driver) {
+    if (!driver.isIOS)
+        return null;
+    try {
+        const element = await driver.element({
+            type: 'xpath',
+            selector: '//XCUIElementTypeOther[@name="Applitools_View"]',
+        });
+        const result = JSON.parse(await element.getText());
+        return result.nextPath;
+    }
+    catch (error) {
+        return null;
+    }
+}
+exports.extractBrokerUrl = extractBrokerUrl;

package/dist/utils/format-results.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJsonOutput = exports.toXmlOutput = exports.toFlattenedTAPString = exports.toHierarchicTAPString = exports.toFormatterString = void 0;
+const OK = 'ok';
+const NOT_OK = 'not ok';
+function toFormatterString(results, { includeSubTests = true, markNewAsPassed = false } = {}) {
+    if (results.length === 0) {
+        return 'No results found.';
+    }
+    let formattedString = '[EYES: TEST RESULTS]:\n';
+    for (let i = 0; i < results.length; i += 1) {
+        /** @type {TestResults} */ const currentResult = results[i];
+        const testTitle = `${currentResult.name} [${currentResult.hostDisplaySize.width}x${currentResult.hostDisplaySize.height}]`;
+        let testResult = '';
+        if (currentResult.isNew) {
+            testResult = markNewAsPassed ? 'Passed' : 'New';
+        }
+        else if (!currentResult.isDifferent) {
+            testResult = 'Passed';
+        }
+        else {
+            const stepsFailed = currentResult.mismatches + currentResult.missing;
+            testResult = `Failed ${stepsFailed} of ${currentResult.steps}`;
+        }
+        formattedString += `${testTitle} - ${testResult}\n`;
+        if (includeSubTests) {
+            if (currentResult.stepsInfo.length > 0) {
+                for (let j = 0; j < currentResult.stepsInfo.length; j += 1) {
+                    const currentStep = currentResult.stepsInfo[j];
+                    const subTestTitle = currentStep.name;
+                    const subTestResult = currentStep.isDifferent ? 'Passed' : 'Failed';
+                    formattedString += `\t> ${subTestTitle} - ${subTestResult}\n`;
+                }
+            }
+            else {
+                formattedString += '\tNo steps exist for this test.\n';
+            }
+        }
+    }
+    formattedString += `See details at ${results[0].appUrls.batch}`;
+    return formattedString;
+}
+exports.toFormatterString = toFormatterString;
+function toHierarchicTAPString(results, { includeSubTests = true, markNewAsPassed = false } = {}) {
+    if (results.length === 0) {
+        return '';
+    }
+    let tapString = `1..${results.length}\n`;
+    for (let i = 0; i < results.length; i += 1) {
+        /** @type {TestResults} */ const currentResult = results[i];
+        const tapIndex = i + 1;
+        if (i > 0) {
+            tapString += '#\n';
+        }
+        const name = `Test: '${currentResult.name}', Application: '${currentResult.appName}'`;
+        if (!currentResult.isDifferent) {
+            tapString += `${OK} ${tapIndex} - [PASSED TEST] ${name}\n`;
+        }
+        else if (currentResult.isNew) {
+            // Test did not pass (might also be a new test).
+            // New test
+            const newResult = markNewAsPassed ? OK : NOT_OK;
+            tapString += `${newResult} ${tapIndex} - [NEW TEST] ${name}\n`;
+        }
+        else {
+            // Failed / Aborted test.
+            tapString += `${NOT_OK} ${tapIndex} - `;
+            if (currentResult.isAborted) {
+                tapString += `[ABORTED TEST] ${name}\n`;
+            }
+            else {
+                tapString += `[FAILED TEST] ${name}\n`;
+            }
+            tapString += `#\tMismatches: ${currentResult.mismatches}\n`;
+        }
+        const url = currentResult.appUrls && currentResult.appUrls.session ? currentResult.appUrls.session : "No URL (session didn't start).";
+        tapString += `#\tTest url: ${url}\n`;
+        tapString += `#\tBrowser: ${currentResult.hostApp}, Viewport: ${currentResult.hostDisplaySize}\n`;
+        if (includeSubTests) {
+            if (currentResult.stepsInfo.length > 0) {
+                tapString += `\t1..${currentResult.stepsInfo.length}\n`;
+                for (let j = 0; j < currentResult.stepsInfo.length; j += 1) {
+                    const currentStep = currentResult.stepsInfo[j];
+                    tapString += '\t';
+                    tapString += currentStep.isDifferent ? NOT_OK : OK;
+                    tapString += ` '${currentStep.name}', URL: ${currentStep.appUrls.step}\n`;
+                }
+            }
+            else {
+                tapString += '\tNo steps exist for this test.\n';
+            }
+        }
+    }
+    return tapString;
+}
+exports.toHierarchicTAPString = toHierarchicTAPString;
+function toFlattenedTAPString(results, { markNewAsPassed = false } = {}) {
+    let tapString = '';
+    let stepsCounter = 0;
+    // We'll add the TAP plan at the beginning, after we calculate the total number of steps.
+    for (let i = 0; i < results.length; i += 1) {
+        tapString += '#\n';
+        /** @type {TestResults} */ const currentResult = results[i];
+        const tapIndex = i + 1;
+        const name = `Test: '${currentResult.name}', Application: '${currentResult.appName}'`;
+        if (!currentResult.isDifferent) {
+            tapString += `# ${OK} ${tapIndex} - [PASSED TEST] ${name}\n`;
+        }
+        else if (currentResult.isNew) {
+            // Test did not pass (might also be a new test).
+            // New test
+            const newResult = markNewAsPassed ? OK : NOT_OK;
+            tapString += `# ${newResult} ${tapIndex} - [NEW TEST] ${name}\n`;
+        }
+        else {
+            // Failed / Aborted test.
+            tapString += `# ${NOT_OK} ${tapIndex} - `;
+            if (currentResult.isAborted) {
+                tapString += `[ABORTED TEST] ${name}\n`;
+            }
+            else {
+                tapString += `[FAILED TEST] ${name}\n`;
+            }
+            tapString += `#\tMismatches: ${currentResult.mismatches}\n`;
+        }
+        const url = currentResult.appUrls && currentResult.appUrls.session ? currentResult.appUrls.session : "No URL (session didn't start).";
+        tapString += `#\tTest url: ${url}\n`;
+        if (currentResult.stepsInfo.length > 0) {
+            for (let j = 0; j < currentResult.stepsInfo.length; j += 1) {
+                stepsCounter += 1;
+                const currentStep = currentResult.stepsInfo[j];
+                tapString += currentStep.isDifferent ? NOT_OK : OK;
+                tapString += ` ${stepsCounter} '${currentStep.name}', URL: ${currentStep.appUrls.step}\n`;
+            }
+        }
+        else {
+            tapString += '#\tNo steps exist for this test.\n';
+        }
+    }
+    if (stepsCounter > 0) {
+        tapString = `1..${stepsCounter}\n${tapString}`;
+    }
+    return tapString;
+}
+exports.toFlattenedTAPString = toFlattenedTAPString;
+function toXmlOutput(results, { totalTime } = {}) {
+    const suiteName = 'Eyes Test Suite';
+    let output = `<?xml version="1.0" encoding="UTF-8" ?>`;
+    output += `\n<testsuite name="${suiteName}" tests="${results.length}" time="${totalTime}">`;
+    results.forEach(result => {
+        output += `\n<testcase name="${result.name}"${result.duration ? ` time="${result.duration}"` : ''}>`;
+        const properties = {};
+        if (result.hostOS)
+            properties.hostOS = result.hostOS;
+        if (result.hostApp)
+            properties.hostApp = result.hostApp;
+        if (result.hostDisplaySize)
+            properties.viewportSize = `${result.hostDisplaySize.width}x${result.hostDisplaySize.height}`;
+        if (properties.hostOS || properties.hostApp || properties.viewportSize) {
+            output += `\n<properties>`;
+            for (const [name, value] of Object.entries(properties)) {
+                output += `\n<property name="${name}" value="${value}"/>`;
+            }
+            output += `\n</properties>`;
+        }
+        if (result.isDifferent) {
+            output += `\n<failure>`;
+            output += `\nDifference found. See ${result.appUrls.batch} for details.`;
+            output += `\n</failure>`;
+        }
+        else if (result.isAborted) {
+            output += `\n<failure>`;
+            output += `\nTest aborted.`;
+            output += `\n</failure>`;
+        }
+        output += `\n</testcase>`;
+    });
+    output += `\n</testsuite>`;
+    return output;
+}
+exports.toXmlOutput = toXmlOutput;
+function toJsonOutput(results, space) {
+    return JSON.stringify(results, null, space);
+}
+exports.toJsonOutput = toJsonOutput;

package/dist/utils/to-base-check-settings.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBaseCheckSettings = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function toBaseCheckSettings({ settings, }) {
+    const regionTypes = ['ignore', 'layout', 'strict', 'content', 'floating', 'accessibility'];
+    const elementReferencesToCalculate = regionTypes.flatMap(regionType => {
+        var _a;
+        return ((_a = settings[`${regionType}Regions`]) !== null && _a !== void 0 ? _a : []).reduce((regions, reference) => {
+            const { region } = utils.types.has(reference, 'region') ? reference : { region: reference };
+            return !isRegion(region) ? regions.concat(region) : regions;
+        }, []);
+    });
+    const elementReferenceToTarget = !isRegion(settings.region) ? settings.region : undefined;
+    return { elementReferencesToCalculate, elementReferenceToTarget, getBaseCheckSettings };
+    function getBaseCheckSettings({ calculatedRegions, preserveTransformation, }) {
+        const transformedSettings = { ...settings };
+        if (!preserveTransformation) {
+            delete transformedSettings.region;
+            delete transformedSettings.normalization;
+        }
+        else if (elementReferenceToTarget) {
+            delete transformedSettings.region;
+        }
+        regionTypes.forEach(regionType => {
+            if (!transformedSettings[`${regionType}Regions`])
+                return;
+            transformedSettings[`${regionType}Regions`] = transformedSettings[`${regionType}Regions`].flatMap(reference => {
+                const { region, ...options } = utils.types.has(reference, 'region') ? reference : { region: reference };
+                if (isRegion(region))
+                    return reference;
+                const { selector, regions } = calculatedRegions.shift();
+                return regions.map(region => ({
+                    region,
+                    regionId: utils.types.isString(selector) ? selector : selector === null || selector === void 0 ? void 0 : selector.selector,
+                    ...options,
+                }));
+            });
+        });
+        return transformedSettings;
+    }
+    function isRegion(region) {
+        return utils.types.has(region, ['x', 'y', 'width', 'height']);
+    }
+}
+exports.toBaseCheckSettings = toBaseCheckSettings;

package/dist/utils/wait-for-lazy-load.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForLazyLoad = void 0;
+const snippets_1 = require("@applitools/snippets");
+const execute_poll_script_1 = require("./execute-poll-script");
+async function waitForLazyLoad({ driver, settings, logger, }) {
+    var _a, _b, _c, _d, _e;
+    logger.log('lazy loading the page before capturing a screenshot');
+    const arg = {
+        scrollLength: (_a = settings.scrollLength) !== null && _a !== void 0 ? _a : 300,
+        waitingTime: (_b = settings.waitingTime) !== null && _b !== void 0 ? _b : 2000,
+        maxAmountToScroll: (_c = settings.maxAmountToScroll) !== null && _c !== void 0 ? _c : 15000,
+    };
+    const scripts = {
+        main: { script: snippets_1.lazyLoad, args: [[arg]] },
+        poll: { script: snippets_1.lazyLoad, args: [[]] },
+    };
+    await (0, execute_poll_script_1.executePollScript)({
+        context: driver.currentContext,
+        scripts,
+        settings: { executionTimeout: 5 * 60 * 1000, pollTimeout: (_e = (_d = settings.pollTimeout) !== null && _d !== void 0 ? _d : settings.waitingTime) !== null && _e !== void 0 ? _e : 2000 },
+        logger,
+    });
+}
+exports.waitForLazyLoad = waitForLazyLoad;