@applitools/core 2.5.2 → 2.5.3-legacy

package/dist/abort.js

@@ -0,0 +1,40 @@
+"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.makeAbort = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function makeAbort({ eyes, environments: defaultEnvironments, logger: mainLogger, }) {
+    return async function abort({ settings, logger = mainLogger, } = {}) {
+        var _a;
+        logger = logger.extend(mainLogger, { tags: [`abort-${utils.general.shortid()}`] });
+        const typedEyes = await eyes.getTypedEyes({ logger });
+        settings !== null && settings !== void 0 ? settings : (settings = {});
+        if (typedEyes.type === 'classic' && !utils.types.isEmpty(defaultEnvironments)) {
+            (_a = settings.environments) !== null && _a !== void 0 ? _a : (settings.environments = defaultEnvironments);
+        }
+        await typedEyes.abort({ settings, logger });
+    };
+}
+exports.makeAbort = makeAbort;

package/dist/automation/abort.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAbort = void 0;
+const uniquify_environments_1 = require("./utils/uniquify-environments");
+function makeAbort({ eyes, driver, controller, environments: defaultEnvironments, logger: mainLogger, }) {
+    return async function abort({ settings, logger = mainLogger, } = {}) {
+        var _a;
+        logger = logger.extend(mainLogger);
+        logger.log('Command "abort" is called with settings', settings);
+        if (!eyes.running) {
+            logger.log('Command "abort" will be ignored because eyes were already stopped');
+            return;
+        }
+        else {
+            ;
+            eyes.running = false;
+        }
+        controller.abort();
+        settings !== null && settings !== void 0 ? settings : (settings = {});
+        if (!settings.testMetadata && driver) {
+            try {
+                settings.testMetadata = await driver.getSessionMetadata();
+            }
+            catch (error) {
+                logger.warn('Command "abort" received an error during extracting driver metadata', error);
+            }
+        }
+        (_a = settings.environments) !== null && _a !== void 0 ? _a : (settings.environments = defaultEnvironments);
+        if (eyes.storage.size === 0 && settings.environments && settings.environments.length > 0) {
+            const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments);
+            logger.log('Command "abort" starting filler tests for environments', uniqueEnvironments);
+            await Promise.all(uniqueEnvironments.map(environment => eyes.getBaseEyes({ settings: { environment }, logger })));
+        }
+        eyes.storage.forEach(async (item) => {
+            var _a, _b;
+            try {
+                const eyes = await item.eyes;
+                await eyes.abort({ settings, logger });
+            }
+            catch (error) {
+                logger.warn('Command "abort" received an error during waiting for eyes instances in background', error);
+                await ((_b = (_a = error === null || error === void 0 ? void 0 : error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ settings, logger }));
+            }
+        });
+    };
+}
+exports.makeAbort = makeAbort;

package/dist/automation/close.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeClose = void 0;
+const uniquify_environments_1 = require("./utils/uniquify-environments");
+function makeClose({ eyes, driver, environments: defaultEnvironments, logger: mainLogger, }) {
+    return async function close({ settings, logger = mainLogger, } = {}) {
+        var _a;
+        logger = logger.extend(mainLogger);
+        logger.log('Command "close" is called with settings', settings);
+        if (!eyes.running) {
+            logger.log('Command "close" will be ignored because eyes were already stopped');
+            return;
+        }
+        else {
+            ;
+            eyes.running = false;
+        }
+        settings !== null && settings !== void 0 ? settings : (settings = {});
+        if (!settings.testMetadata && driver) {
+            try {
+                settings.testMetadata = await driver.getSessionMetadata();
+            }
+            catch (error) {
+                logger.warn('Command "close" received an error during extracting driver metadata', error);
+            }
+        }
+        (_a = settings.environments) !== null && _a !== void 0 ? _a : (settings.environments = defaultEnvironments);
+        if (eyes.storage.size === 0 && settings.environments && settings.environments.length > 0) {
+            const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments);
+            logger.log('Command "close" starting filler tests for environments', settings.environments);
+            await Promise.all(uniqueEnvironments.map(environment => eyes.getBaseEyes({ settings: { environment }, logger })));
+        }
+        eyes.storage.forEach(async (item) => {
+            var _a, _b;
+            try {
+                const [eyes] = await Promise.all([item.eyes, ...item.jobs]);
+                try {
+                    await eyes.close({ settings, logger });
+                }
+                catch (error) {
+                    logger.warn('Command "close" received an error during performing, trying to perform abort instead', error);
+                    await eyes.abort({ settings, logger });
+                }
+            }
+            catch (error) {
+                logger.warn('Command "close" received an error during waiting for eyes instances in background', error);
+                await ((_b = (_a = error.info) === null || _a === void 0 ? void 0 : _a.eyes) === null || _b === void 0 ? void 0 : _b.abort({ settings, logger }));
+            }
+        });
+    };
+}
+exports.makeClose = makeClose;

package/dist/automation/extract-text.js

@@ -29,8 +29,9 @@ const take_screenshot_1 = require("./utils/take-screenshot");
 const take_dom_capture_1 = require("../classic/utils/take-dom-capture");
 const utils = __importStar(require("@applitools/utils"));
 const { getText } = require('@applitools/snippets');
-function makeExtractText({ core, spec, logger: defaultLogger }) {
-    return async function extractText({ target, settings, logger = defaultLogger, }) {
+function makeExtractText({ core, spec, logger: mainLogger }) {
+    return async function extractText({ target, settings, logger = mainLogger, }) {
+        logger = logger.extend(mainLogger);
         logger.log('Command "extractText" is called with settings', settings);
         if (!(0, driver_1.isDriver)(target, spec)) {
             return core.base.extractText({ target, settings: settings, logger });

package/dist/automation/get-nml-client.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetNMLClient = void 0;
+const nml_client_1 = require("@applitools/nml-client");
+const clients = new Map();
+function makeGetNMLClient({ client, logger: mainLogger }) {
+    return {
+        getNMLClient,
+        clearNMLClientCache,
+    };
+    async function getNMLClient({ driver, settings, logger, }) {
+        if (client)
+            return client;
+        logger = logger.extend(mainLogger);
+        const { sessionId } = await driver.getDriverInfo();
+        const cacheKey = sessionId !== null && sessionId !== void 0 ? sessionId : driver.guid;
+        const clientFromCache = clients.get(cacheKey);
+        if (clientFromCache) {
+            return clientFromCache;
+        }
+        else {
+            const brokerUrl = await driver.extractBrokerUrl();
+            if (!brokerUrl)
+                throw new Error('Unable to extract broker url from the device');
+            const nmlClient = (0, nml_client_1.makeNMLClient)({ settings: { brokerUrl, ...settings }, logger });
+            clients.set(cacheKey, nmlClient);
+            return nmlClient;
+        }
+    }
+    async function clearNMLClientCache(driver) {
+        const { sessionId } = await driver.getDriverInfo();
+        const cacheKey = sessionId !== null && sessionId !== void 0 ? sessionId : driver.guid;
+        clients.delete(cacheKey);
+    }
+}
+exports.makeGetNMLClient = makeGetNMLClient;

package/dist/automation/get-results.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetResults = void 0;
+function makeGetResults({ eyes, logger: mainLogger }) {
+    return async function getResults({ settings, logger = mainLogger, } = {}) {
+        logger = logger.extend(mainLogger);
+        logger.log('Command "getResults" is called with settings', settings);
+        return Promise.all(Array.from(eyes.storage.values(), async (item) => {
+            try {
+                const [eyes] = await Promise.all([item.eyes, ...item.jobs]);
+                const [result] = await eyes.getResults({ settings, logger });
+                return { ...result, environment: eyes.test.environment };
+            }
+            catch (error) {
+                logger.fatal('Command "getResults" received an error', error, 'during performing with settings', settings);
+                throw error;
+            }
+        }));
+    };
+}
+exports.makeGetResults = makeGetResults;

package/dist/automation/get-viewport-size.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetViewportSize = void 0;
 const driver_1 = require("@applitools/driver");
-function makeGetViewportSize({ spec, logger: defaultLogger }) {
-    return async function getViewportSize({ target, logger = defaultLogger, }) {
+function makeGetViewportSize({ spec, logger: mainLogger }) {
+    return async function getViewportSize({ target, logger = mainLogger }) {
+        logger = logger.extend(mainLogger);
         logger.log(`Command "getViewportSize" is called`);
         const driver = await (0, driver_1.makeDriver)({ driver: target, spec, logger });
         return driver.getViewportSize();

package/dist/automation/locate-text.js

@@ -28,8 +28,9 @@ const driver_1 = require("@applitools/driver");
 const take_screenshot_1 = require("./utils/take-screenshot");
 // import {takeDomCapture} from './utils/take-dom-capture'
 const utils = __importStar(require("@applitools/utils"));
-function makeLocateText({ core, spec, logger: defaultLogger }) {
-    return async function locateText({ target, settings, logger = defaultLogger, }) {
+function makeLocateText({ core, spec, logger: mainLogger }) {
+    return async function locateText({ target, settings, logger = mainLogger, }) {
+        logger = logger.extend(mainLogger);
         logger.log('Command "locateText" is called with settings', settings);
         if (!(0, driver_1.isDriver)(target, spec)) {
             return core.base.locateText({ target, settings: settings, logger });

package/dist/automation/locate.js

@@ -27,8 +27,9 @@ exports.makeLocate = void 0;
 const driver_1 = require("@applitools/driver");
 const take_screenshot_1 = require("./utils/take-screenshot");
 const utils = __importStar(require("@applitools/utils"));
-function makeLocate({ spec, core, logger: defaultLogger }) {
-    return async function locate({ settings, target, logger = defaultLogger, }) {
+function makeLocate({ spec, core, logger: mainLogger }) {
+    return async function locate({ settings, target, logger = mainLogger, }) {
+        logger = logger.extend(mainLogger);
         logger.log(`Command "locate" is called with settings`, settings);
         if (!(0, driver_1.isDriver)(target, spec)) {
             return core.base.locate({ target, settings: settings, logger });

package/dist/automation/set-viewport-size.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSetViewportSize = void 0;
 const driver_1 = require("@applitools/driver");
-function makeSetViewportSize({ spec, logger: defaultLogger }) {
-    return async function setViewportSize({ target, size, logger = defaultLogger, }) {
+function makeSetViewportSize({ spec, logger: mainLogger }) {
+    return async function setViewportSize({ target, size, logger = mainLogger, }) {
+        logger = logger.extend(mainLogger);
         logger.log(`Command "setViewportSize" is called with size`, size);
         const driver = await (0, driver_1.makeDriver)({ driver: target, spec, logger });
         return driver.setViewportSize(size);

package/dist/automation/types.js

@@ -1,17 +1,2 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@applitools/core-base/types"), exports);

package/dist/automation/utils/report-kobiton.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportKobiton = void 0;
+async function reportKobiton({ driver, settings, logger }) {
+    var _a;
+    // At this point, the driver might be closed already. The operation below could fail in this case
+    try {
+        if ((_a = (await (driver === null || driver === void 0 ? void 0 : driver.getEnvironment()))) === null || _a === void 0 ? void 0 : _a.isKobiton) {
+            const kobitonInfo = {
+                batchId: settings.batchId,
+                batchUrl: settings.resultsUrl,
+            };
+            logger.log('sending to kobiton', kobitonInfo);
+            await driver.execute('kobiton:assignApplitoolsInfo', kobitonInfo);
+        }
+    }
+    catch (err) {
+        logger.log('failed to send to kobiton', err);
+    }
+}
+exports.reportKobiton = reportKobiton;

package/dist/automation/utils/take-screenshot.js

@@ -27,7 +27,7 @@ exports.takeScreenshot = void 0;
 const utils = __importStar(require("@applitools/utils"));
 const { takeScreenshot: legacyTakeScreenshot } = require('@applitools/screenshoter');
 async function takeScreenshot({ driver, settings, logger, }) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const environment = await driver.getEnvironment();
     return legacyTakeScreenshot({
         driver,
@@ -41,7 +41,7 @@ async function takeScreenshot({ driver, settings, logger, }) {
         fully: settings.fully,
         hideScrollbars: settings.hideScrollbars,
         hideCaret: settings.hideCaret,
-        scrollingMode: (_b = settings.stitchMode) === null || _b === void 0 ? void 0 : _b.toLowerCase(),
+        scrollingMode: (_c = (_b = settings.stitchMode) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : 'scroll',
         overlap: settings.overlap,
         wait: settings.waitBeforeCapture,
         framed: environment.isNative,
@@ -54,6 +54,8 @@ async function takeScreenshot({ driver, settings, logger, }) {
         debug: settings.debugImages,
         logger,
         regionsToCalculate: settings.regionsToCalculate,
+        captureStatusBar: settings.captureStatusBar,
+        keepNavigationBar: (_d = settings.mobileOptions) === null || _d === void 0 ? void 0 : _d.keepNavigationBar,
     });
 }
 exports.takeScreenshot = takeScreenshot;

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

@@ -23,28 +23,90 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBaseCheckSettings = void 0;
+exports.toBaseCheckSettings = exports.extractMobileElementsIntoCheckSettings = exports.hasCodedRegions = void 0;
 const utils = __importStar(require("@applitools/utils"));
+const regionTypes = ['ignore', 'layout', 'strict', 'content', 'floating', 'accessibility', 'dynamic'];
+function hasCodedRegions(settings) {
+    for (const regionType of regionTypes) {
+        if (settings[`${regionType}Regions`])
+            return true;
+    }
+    return false;
+}
+exports.hasCodedRegions = hasCodedRegions;
+async function extractMobileElementsIntoCheckSettings({ settings, driver, logger, }) {
+    logger = logger.extend({ tags: [`extract-mobile-elements-${utils.general.shortid()}`] });
+    if (settings.region) {
+        logger.log('extract element form region', settings.region);
+        const region = await driver.element(settings.region).catch(error => logger.log(error));
+        if (!region) {
+            throw new Error('region not found');
+        }
+        settings.region = await (region === null || region === void 0 ? void 0 : region.getAttribute('name'));
+    }
+    if (settings.scrollRootElement) {
+        logger.log('extract element form scrollRootElement', settings.scrollRootElement);
+        const scrollRootElement = await driver.element(settings.scrollRootElement).catch(error => logger.log(error));
+        if (!scrollRootElement) {
+            throw new Error('scrollRootElement not found');
+        }
+        settings.scrollRootElement = await scrollRootElement.getAttribute('name');
+    }
+    const codedRegionsAsElement = await regionTypes.reduce(async (promise, regionType) => {
+        var _a, _b;
+        const obj = await promise;
+        if (!settings[`${regionType}Regions`])
+            return obj;
+        obj[`${regionType}Regions`] = (await Promise.all((_b = (_a = settings[`${regionType}Regions`]) === null || _a === void 0 ? void 0 : _a.flatMap(async (reference) => {
+            logger.log('extract element form region', reference);
+            const { region } = utils.types.has(reference, 'region') ? reference : { region: reference };
+            const handleRegion = new Set();
+            const elements = await driver.elements(region).catch(error => logger.log(error));
+            if (!elements)
+                return []; // elements not found
+            return elements === null || elements === void 0 ? void 0 : elements.reduce(async (promise, element) => {
+                const arr = await promise;
+                const name = await element.getAttribute('name');
+                if (handleRegion.has(name))
+                    return arr;
+                handleRegion.add(name);
+                return arr.concat({
+                    region: {
+                        name,
+                        reference: region,
+                    },
+                });
+            }, Promise.resolve([]));
+        })) !== null && _b !== void 0 ? _b : [])).flat();
+        return obj;
+    }, Promise.resolve({}));
+    return {
+        ...settings,
+        ...codedRegionsAsElement,
+    };
+}
+exports.extractMobileElementsIntoCheckSettings = extractMobileElementsIntoCheckSettings;
 function toBaseCheckSettings({ settings }) {
-    const regionTypes = ['ignore', 'layout', 'strict', 'content', 'floating', 'accessibility'];
-    const elementReferencesToCalculate = regionTypes.flatMap(regionType => {
+    const calculate = 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 };
+    const target = !isRegion(settings.region) ? settings.region : undefined;
+    const scrolling = settings.scrollRootElement;
+    return { elementReferences: { target, scrolling, calculate }, getBaseCheckSettings };
     function getBaseCheckSettings({ calculatedRegions, preserveTransformation, }) {
         const transformedSettings = { ...settings };
         if (!preserveTransformation) {
             delete transformedSettings.region;
             delete transformedSettings.normalization;
         }
-        else if (elementReferenceToTarget) {
+        else if (target) {
             delete transformedSettings.region;
         }
+        let currRegion = 0;
         regionTypes.forEach(regionType => {
             var _a;
             if (!transformedSettings[`${regionType}Regions`])
@@ -53,7 +115,7 @@ function toBaseCheckSettings({ settings }) {
                 const { region, ...options } = utils.types.has(reference, 'region') ? reference : { region: reference };
                 if (isRegion(region))
                     return reference;
-                const { selector, regions } = calculatedRegions.shift();
+                const { selector, regions } = calculatedRegions[currRegion++];
                 return regions.map(region => ({
                     region,
                     regionId: utils.types.isString(selector) ? selector : selector === null || selector === void 0 ? void 0 : selector.selector,

package/dist/automation/utils/to-environment-key.js

@@ -0,0 +1,31 @@
+"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.toEnvironmentKey = void 0;
+const utils = __importStar(require("@applitools/utils"));
+function toEnvironmentKey(environment) {
+    return JSON.stringify(utils.types.has(environment, 'requested') ? environment.requested : environment);
+}
+exports.toEnvironmentKey = toEnvironmentKey;

package/dist/automation/utils/uniquify-environments.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniquifyEnvironments = void 0;
+function uniquifyEnvironments(environments) {
+    const duplications = new Map(environments.map(environment => [JSON.stringify(environment), 0]));
+    return environments.reduce((uniqueEnvironments, environment) => {
+        const key = JSON.stringify(environment);
+        let index = duplications.get(key);
+        if (index > 0) {
+            if (!environment.environmentId) {
+                let uniqueEnvironment;
+                do {
+                    uniqueEnvironment = { ...environment, environmentId: `${index}` };
+                    index += 1;
+                } while (duplications.has(JSON.stringify(uniqueEnvironment)));
+                uniqueEnvironments.push(uniqueEnvironment);
+            }
+        }
+        else {
+            index += 1;
+            uniqueEnvironments.push(environment);
+        }
+        duplications.set(key, index);
+        return uniqueEnvironments;
+    }, []);
+}
+exports.uniquifyEnvironments = uniquifyEnvironments;

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

@@ -2,21 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForLazyLoad = void 0;
 const { lazyLoad } = require('@applitools/snippets');
-async function waitForLazyLoad({ context, settings, logger, }) {
-    var _a, _b, _c, _d, _e;
-    logger.log('lazy loading the page before capturing a screenshot');
+async function waitForLazyLoad({ context, settings = {}, logger, }) {
+    var _a;
+    logger.log('Running scrolling sequence to lazy load a view content');
+    const { scrollLength = 300, waitingTime = 2000, maxAmountToScroll = 15000 } = settings;
     await context.executePoll(lazyLoad, {
         main: [
             await context.getScrollingElement(),
             {
-                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,
+                scrollLength: scrollLength,
+                waitingTime: waitingTime,
+                maxAmountToScroll: maxAmountToScroll,
             },
         ],
         poll: [],
-        executionTimeout: 5 * 60 * 1000,
-        pollTimeout: (_e = (_d = settings.pollTimeout) !== null && _d !== void 0 ? _d : settings.waitingTime) !== null && _e !== void 0 ? _e : 2000,
+        executionTimeout: 300000 /* 5min */,
+        pollTimeout: (_a = settings.pollTimeout) !== null && _a !== void 0 ? _a : waitingTime,
     });
 }
 exports.waitForLazyLoad = waitForLazyLoad;

package/dist/autonomous/core.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAutonomousCore = void 0;
+const logger_1 = require("@applitools/logger");
+const core_1 = require("../ufg/core");
+const take_snapshots_1 = require("./take-snapshots");
+const create_render_target_1 = require("./create-render-target");
+const start_renders_1 = require("./start-renders");
+const get_render_results_1 = require("./get-render-results");
+const create_render_results_1 = require("./create-render-results");
+const open_eyes_1 = require("./open-eyes");
+function makeAutonomousCore({ spec, clients, base: defaultBase, asyncCache, agentId = 'core-autonomous', logger: defaultLogger, } = {}) {
+    const logger = (0, logger_1.makeLogger)({ logger: defaultLogger, format: { label: 'core-autonomous' } });
+    const core = (0, core_1.makeCore)({ spec, clients, base: defaultBase, asyncCache, agentId, logger });
+    return {
+        type: 'autonomous',
+        takeSnapshots: spec && (0, take_snapshots_1.makeTakeSnapshots)({ core, spec, logger }),
+        createRenderTarget: (0, create_render_target_1.makeCreateRenderTarget)({ core, logger }),
+        startRenders: (0, start_renders_1.makeStartRenders)({ core, logger }),
+        getRenderResults: (0, get_render_results_1.makeGetRenderResults)({ core, logger }),
+        createRenderResults: (0, create_render_results_1.makeCreateRenderResults)({ logger }),
+        openEyes: (0, open_eyes_1.makeOpenEyes)({ core, logger }),
+    };
+}
+exports.makeAutonomousCore = makeAutonomousCore;

package/dist/autonomous/create-render-results.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCreateRenderResults = void 0;
+const ufg_client_1 = require("@applitools/ufg-client");
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+function makeCreateRenderResults({ logger }) {
+    /**
+     * Autonomous should call this function to create render results after rendering is done.
+     * After the UFG finishes rendering, it creates a new message in azure service bus, containing the raw render results.
+     * This function is responsible for converting the raw render results into a format that can be used by the core.
+     * It assumes that the rendering is finished, and it will throw an error if the rendering failed.
+     */
+    return async function createRenderResults({ renders, rawResults, }) {
+        const results = rawResults.map((rawResult, index) => (0, ufg_client_1.toRenderResult)(rawResult, { renderId: renders[index].render.renderId }));
+        results.forEach((result, index) => {
+            if (result.status === 'error') {
+                logger.error(`Render with id "${renders[index].render.renderId}" failed due to an error - ${result.error}`);
+                throw new Error(`Render with id "${renders[index].render.renderId}" failed due to an error - ${result.error}`);
+            }
+            else if (result.status !== 'rendered') {
+                // most probably rendering is still in progress
+                throw new Error(`Unexpected status ${result.status} in get render results response`);
+            }
+        });
+        return results.map(({ selectorRegions, renderId, status, error, ...baseTarget }, index) => {
+            const { elementReferences: selectors, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({
+                settings: renders[index].settings,
+            });
+            const baseSettings = getBaseCheckSettings({
+                calculatedRegions: selectors.calculate.map((_, index) => {
+                    var _a;
+                    return ({
+                        regions: (_a = selectorRegions === null || selectorRegions === void 0 ? void 0 : selectorRegions[index]) !== null && _a !== void 0 ? _a : [],
+                    });
+                }),
+            });
+            baseSettings.renderId = renderId;
+            return {
+                status,
+                error,
+                target: { ...baseTarget, isTransformed: true },
+                settings: baseSettings,
+                environment: renders[index].environment,
+                account: renders[index].account,
+            };
+        });
+    };
+}
+exports.makeCreateRenderResults = makeCreateRenderResults;

package/dist/autonomous/create-render-target.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCreateRenderTarget = void 0;
+const create_render_target_from_snapshot_1 = require("../ufg/create-render-target-from-snapshot");
+function makeCreateRenderTarget({ core, logger: defaultLogger }) {
+    return async function createRenderTarget({ snapshot, logger = defaultLogger, }) {
+        const ufgClient = await core.getUFGClient({
+            settings: {
+                ...snapshot.account.ufgServer,
+                eyesServerUrl: snapshot.account.eyesServer.eyesServerUrl,
+                apiKey: snapshot.account.eyesServer.apiKey,
+            },
+            logger,
+        });
+        const target = await (0, create_render_target_from_snapshot_1.createRenderTargetFromSnapshot)({ ufgClient, snapshot, logger });
+        return { ...snapshot, target };
+    };
+}
+exports.makeCreateRenderTarget = makeCreateRenderTarget;