@applitools/core 2.5.2 → 2.5.3-legacy

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetRenderResults = void 0;
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+function makeGetRenderResults({ core, logger: defaultLogger }) {
+    return async function getRenderResults({ renders, logger = defaultLogger, }) {
+        const clients = await renders.reduce(async (promise, render) => {
+            const ufgClient = await core.getUFGClient({
+                settings: {
+                    ...render.account.ufgServer,
+                    eyesServerUrl: render.account.eyesServer.eyesServerUrl,
+                    apiKey: render.account.eyesServer.apiKey,
+                },
+                logger,
+            });
+            return promise.then(clients => {
+                const targets = clients.get(ufgClient);
+                if (targets) {
+                    targets.push(render);
+                }
+                else {
+                    clients.set(ufgClient, [render]);
+                }
+                return clients;
+            });
+        }, Promise.resolve(new Map()));
+        const results = await Promise.all(Array.from(clients.entries(), async ([ufgClient, renders]) => {
+            const results = await ufgClient.getRenderResults({ renders: renders.map(render => render.render), logger });
+            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,
+                };
+            });
+        }));
+        return results.flat();
+    };
+}
+exports.makeGetRenderResults = makeGetRenderResults;

package/dist/autonomous/open-eyes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOpenEyes = void 0;
+const populate_eyes_server_settings_1 = require("../utils/populate-eyes-server-settings");
+function makeOpenEyes({ core, logger: defaultLogger }) {
+    return async function openEyes({ settings, logger = defaultLogger, }) {
+        (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
+        logger.mask(settings.apiKey);
+        logger.mask(settings.eyesServerUrl);
+        return core.base.openEyes({ settings, logger });
+    };
+}
+exports.makeOpenEyes = makeOpenEyes;

package/dist/autonomous/start-renders.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStartRenders = void 0;
+const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
+function makeStartRenders({ core, logger: defaultLogger }) {
+    return async function startRenders({ targets, logger = defaultLogger, }) {
+        const clients = await targets.reduce(async (promise, target) => {
+            const ufgClient = await core.getUFGClient({
+                settings: {
+                    ...target.account.ufgServer,
+                    eyesServerUrl: target.account.eyesServer.eyesServerUrl,
+                    apiKey: target.account.eyesServer.apiKey,
+                },
+                logger,
+            });
+            return promise.then(clients => {
+                const targets = clients.get(ufgClient);
+                if (targets) {
+                    targets.push(target);
+                }
+                else {
+                    clients.set(ufgClient, [target]);
+                }
+                return clients;
+            });
+        }, Promise.resolve(new Map()));
+        const renders = await Promise.all(Array.from(clients.entries(), async ([ufgClient, targets]) => {
+            const [renders, ...environments] = await Promise.all([
+                ufgClient.startRenders({
+                    renders: targets.map(target => {
+                        var _a;
+                        const { elementReferences: selectors } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings: target.settings });
+                        return {
+                            target: target.target,
+                            settings: {
+                                ...target.settings,
+                                region: (_a = selectors.target) !== null && _a !== void 0 ? _a : target.settings.region,
+                                scrollRootElement: selectors.scrolling,
+                                selectorsToCalculate: selectors.calculate,
+                                includeFullPageSize: Boolean(target.settings.pageId),
+                                environment: target.environment,
+                                uploadUrl: target.account.uploadUrl,
+                                stitchingServiceUrl: target.account.stitchingServiceUrl,
+                            },
+                        };
+                    }),
+                    logger,
+                }),
+                ...targets.map(async (target) => {
+                    const environment = await ufgClient.getActualEnvironment({
+                        settings: { environment: target.environment },
+                        logger,
+                    });
+                    return { ...environment, properties: target.environment.properties };
+                }),
+            ]);
+            return renders.map((render, index) => ({
+                render,
+                settings: targets[index].settings,
+                environment: environments[index],
+                account: targets[index].account,
+            }));
+        }));
+        return renders.flat();
+    };
+}
+exports.makeStartRenders = makeStartRenders;

package/dist/autonomous/take-snapshots.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTakeSnapshots = void 0;
+const driver_1 = require("@applitools/driver");
+const populate_eyes_server_settings_1 = require("../utils/populate-eyes-server-settings");
+const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
+function makeTakeSnapshots({ core, spec, logger: defaultLogger }) {
+    return async function takeSnapshots({ target, settings, logger = defaultLogger, }) {
+        (0, populate_eyes_server_settings_1.populateEyesServerSettings)(settings);
+        const account = await core.base.getAccountInfo({ settings: settings, logger });
+        settings.environments = (0, uniquify_environments_1.uniquifyEnvironments)(settings.environments);
+        const driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
+        return core.takeSnapshots({ driver, settings, account, logger });
+    };
+}
+exports.makeTakeSnapshots = makeTakeSnapshots;

package/dist/autonomous/types.js

@@ -0,0 +1,17 @@
+"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("../ufg/types"), exports);

package/dist/check-and-close.js

@@ -1,23 +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.makeCheckAndClose = void 0;
 const driver_1 = require("@applitools/driver");
-function makeCheckAndClose({ type: defaultType = 'classic', eyes, target: defaultTarget, spec, logger: defaultLogger, }) {
-    return async function checkAndClose({ type = defaultType, target = defaultTarget, settings = {}, config, logger = defaultLogger, } = {}) {
-        var _a;
+const utils = __importStar(require("@applitools/utils"));
+function makeCheckAndClose({ type: defaultType = 'classic', eyes, target: defaultTarget, spec, logger: mainLogger, }) {
+    return async function checkAndClose({ type = defaultType, target = defaultTarget, settings = {}, config, logger = mainLogger, } = {}) {
+        logger = logger.extend(mainLogger, { tags: [`check-and-close-${type}-${utils.general.shortid()}`] });
         settings = { ...config === null || config === void 0 ? void 0 : config.screenshot, ...config === null || config === void 0 ? void 0 : config.check, ...config === null || config === void 0 ? void 0 : config.close, ...settings };
-        const driver = (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
-        const environment = await (driver === null || driver === void 0 ? void 0 : driver.getEnvironment());
-        const typedEyes = await eyes.getTypedEyes({
-            type,
-            settings: (_a = settings.renderers) === null || _a === void 0 ? void 0 : _a.map(renderer => ({
-                type: (environment === null || environment === void 0 ? void 0 : environment.isNative) ? 'native' : 'web',
-                renderer,
-            })),
-            logger,
-        });
-        const results = await typedEyes.checkAndClose({ target: driver !== null && driver !== void 0 ? driver : target, settings, logger });
-        return results;
+        const driver = (0, driver_1.isDriver)(target, spec)
+            ? await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger })
+            : null;
+        const typedEyes = await eyes.getTypedEyes({ type, logger });
+        await typedEyes.checkAndClose({ target: driver !== null && driver !== void 0 ? driver : target, settings, logger });
     };
 }
 exports.makeCheckAndClose = makeCheckAndClose;

package/dist/check.js

@@ -29,48 +29,51 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheck = void 0;
 const driver_1 = require("@applitools/driver");
 const utils = __importStar(require("@applitools/utils"));
+const lang = __importStar(require("./lang"));
 const chalk_1 = __importDefault(require("chalk"));
-function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget, spec, logger: defaultLogger, }) {
+function makeCheck({ type: defaultType = 'classic', eyes, target: defaultTarget, spec, logger: mainLogger, }) {
     let stepIndex = 0;
-    return async function check({ type = defaultType, target = defaultTarget, settings, config, logger = defaultLogger, } = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-        var _s, _t, _u, _v;
+    return async function check({ type = defaultType, target = defaultTarget, settings, config, logger = mainLogger, } = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        var _r, _s, _t, _u, _v;
+        logger = logger.extend(mainLogger, { tags: [`check-${type}-${utils.general.shortid()}`] });
         settings = { ...config === null || config === void 0 ? void 0 : config.screenshot, ...config === null || config === void 0 ? void 0 : config.check, ...settings };
         (_a = settings.fully) !== null && _a !== void 0 ? _a : (settings.fully = !settings.region && (!settings.frames || settings.frames.length === 0));
         (_b = settings.waitBeforeCapture) !== null && _b !== void 0 ? _b : (settings.waitBeforeCapture = 100);
-        (_c = settings.stitchMode) !== null && _c !== void 0 ? _c : (settings.stitchMode = 'Scroll');
-        (_d = settings.hideScrollbars) !== null && _d !== void 0 ? _d : (settings.hideScrollbars = true);
-        (_e = settings.hideCaret) !== null && _e !== void 0 ? _e : (settings.hideCaret = true);
+        (_c = settings.hideScrollbars) !== null && _c !== void 0 ? _c : (settings.hideScrollbars = true);
+        (_d = settings.hideCaret) !== null && _d !== void 0 ? _d : (settings.hideCaret = true);
         settings.overlap = { top: 10, bottom: 50, ...settings === null || settings === void 0 ? void 0 : settings.overlap };
-        (_f = settings.matchLevel) !== null && _f !== void 0 ? _f : (settings.matchLevel = 'Strict');
-        (_g = settings.ignoreCaret) !== null && _g !== void 0 ? _g : (settings.ignoreCaret = true);
-        (_h = settings.sendDom) !== null && _h !== void 0 ? _h : (settings.sendDom = eyes.test.account.rcaEnabled || settings.matchLevel === 'Layout' || settings.enablePatterns || settings.useDom);
-        (_j = settings.autProxy) !== null && _j !== void 0 ? _j : (settings.autProxy = eyes.test.server.proxy);
-        (_k = settings.useDom) !== null && _k !== void 0 ? _k : (settings.useDom = false);
-        (_l = (_s = settings).retryTimeout) !== null && _l !== void 0 ? _l : (_s.retryTimeout = 2000);
+        (_e = settings.matchLevel) !== null && _e !== void 0 ? _e : (settings.matchLevel = 'Strict');
+        (_f = settings.ignoreCaret) !== null && _f !== void 0 ? _f : (settings.ignoreCaret = true);
+        (_g = settings.sendDom) !== null && _g !== void 0 ? _g : (settings.sendDom = eyes.test.account.rcaEnabled ||
+            settings.matchLevel === 'Layout' ||
+            settings.matchLevel === 'Dynamic' ||
+            settings.enablePatterns ||
+            settings.useDom ||
+            !utils.types.isEmpty(settings.dynamicRegions) ||
+            !utils.types.isEmpty(settings.layoutRegions));
+        (_h = settings.autProxy) !== null && _h !== void 0 ? _h : (settings.autProxy = eyes.test.eyesServer.proxy);
+        (_j = settings.useDom) !== null && _j !== void 0 ? _j : (settings.useDom = false);
+        (_k = (_r = settings).retryTimeout) !== null && _k !== void 0 ? _k : (_r.retryTimeout = 0);
         settings.lazyLoad = settings.lazyLoad === true ? {} : settings.lazyLoad;
         if (settings.lazyLoad) {
-            (_m = (_t = settings.lazyLoad).scrollLength) !== null && _m !== void 0 ? _m : (_t.scrollLength = 300);
-            (_o = (_u = settings.lazyLoad).waitingTime) !== null && _o !== void 0 ? _o : (_u.waitingTime = 2000);
-            (_p = (_v = settings.lazyLoad).maxAmountToScroll) !== null && _p !== void 0 ? _p : (_v.maxAmountToScroll = 15000);
+            (_l = (_s = settings.lazyLoad).scrollLength) !== null && _l !== void 0 ? _l : (_s.scrollLength = 300);
+            (_m = (_t = settings.lazyLoad).waitingTime) !== null && _m !== void 0 ? _m : (_t.waitingTime = 2000);
+            (_o = (_u = settings.lazyLoad).maxAmountToScroll) !== null && _o !== void 0 ? _o : (_u.maxAmountToScroll = 15000);
         }
         settings.stepIndex = stepIndex++;
-        (_q = settings.waitBetweenStitches) !== null && _q !== void 0 ? _q : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad) ? settings.lazyLoad.waitingTime : 100);
+        (_p = settings.waitBetweenStitches) !== null && _p !== void 0 ? _p : (settings.waitBetweenStitches = utils.types.isObject(settings.lazyLoad) ? settings.lazyLoad.waitingTime : 100);
+        if (settings.mobileOptions) {
+            (_q = (_v = settings.mobileOptions).keepNavigationBar) !== null && _q !== void 0 ? _q : (_v.keepNavigationBar = false);
+        }
         if (settings.matchLevel === 'Content') {
-            logger.console.log(chalk_1.default.yellow(`The "Content" match level value has been deprecated, use "IgnoreColors" instead.`));
+            logger.console.log(chalk_1.default.yellow(lang.matchLevelContentDeprecatedWarning));
         }
-        const driver = (0, driver_1.isDriver)(target, spec) ? await (0, driver_1.makeDriver)({ spec, driver: target, logger }) : null;
-        const environment = await (driver === null || driver === void 0 ? void 0 : driver.getEnvironment());
-        const typedEyes = await eyes.getTypedEyes({
-            type,
-            settings: (_r = settings.renderers) === null || _r === void 0 ? void 0 : _r.map(renderer => ({
-                type: (environment === null || environment === void 0 ? void 0 : environment.isNative) ? 'native' : 'web',
-                renderer,
-            })),
-            logger,
-        });
-        const results = await typedEyes.check({ target: driver !== null && driver !== void 0 ? driver : target, settings, logger });
-        return results;
+        const driver = (0, driver_1.isDriver)(target, spec)
+            ? await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger })
+            : null;
+        const typedEyes = await eyes.getTypedEyes({ type, logger });
+        return typedEyes.check({ target: driver !== null && driver !== void 0 ? driver : target, settings, logger });
     };
 }
 exports.makeCheck = makeCheck;

package/dist/classic/check-and-close.js

@@ -22,65 +22,208 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCheckAndClose = void 0;
+const nml_client_1 = require("@applitools/nml-client");
 const driver_1 = require("@applitools/driver");
-const take_screenshot_1 = require("../automation/utils/take-screenshot");
-const take_dom_capture_1 = require("./utils/take-dom-capture");
+const take_screenshots_1 = require("./utils/take-screenshots");
 const to_base_check_settings_1 = require("../automation/utils/to-base-check-settings");
 const wait_for_lazy_load_1 = require("../automation/utils/wait-for-lazy-load");
+const uniquify_environments_1 = require("../automation/utils/uniquify-environments");
+const to_environment_key_1 = require("../automation/utils/to-environment-key");
+const abort_error_1 = require("../errors/abort-error");
+const chalk_1 = __importDefault(require("chalk"));
 const utils = __importStar(require("@applitools/utils"));
-function makeCheckAndClose({ eyes, target: defaultTarget, spec, logger: defaultLogger, }) {
-    return async function checkAndClose({ target = defaultTarget, settings = {}, logger = defaultLogger, } = {}) {
-        var _a;
+const lang = __importStar(require("../lang"));
+function makeCheckAndClose({ eyes, target: defaultTarget, environments: defaultEnvironments = [], spec, signal, logger: mainLogger, }) {
+    return async function checkAndClose({ target = defaultTarget, settings = {}, logger = mainLogger, } = {}) {
+        var _a, _b, _c;
+        logger = logger.extend(mainLogger);
         logger.log('Command "checkAndClose" is called with settings', settings);
         if (!target)
             throw new Error('Method was called with no target');
-        const baseEyes = await eyes.getBaseEyes({ logger });
-        if (!(0, driver_1.isDriver)(target, spec)) {
-            const baseSettings = settings;
-            return (await Promise.all(baseEyes.map(baseEyes => baseEyes.checkAndClose({ target, settings: baseSettings, logger })))).flat();
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            logger.warn('Command "checkAndClose" was called after test was already aborted');
+            throw new abort_error_1.AbortError('Command "checkAndClose" was called after test was already aborted');
         }
-        const driver = await (0, driver_1.makeDriver)({ spec, driver: target, logger });
-        const environment = await driver.getEnvironment();
-        if (settings.lazyLoad && environment.isWeb) {
-            await (0, wait_for_lazy_load_1.waitForLazyLoad)({
-                context: driver.currentContext,
-                settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
-                logger,
+        const uniqueEnvironments = (0, uniquify_environments_1.uniquifyEnvironments)((_a = settings.environments) !== null && _a !== void 0 ? _a : defaultEnvironments);
+        const baseTargets = [];
+        const baseSettings = [];
+        const exactEnvironments = [];
+        let driver;
+        if ((0, driver_1.isDriver)(target, spec)) {
+            driver = await (0, driver_1.makeDriver)({ spec, driver: target, reset: target === defaultTarget, logger });
+            await driver.currentContext.setScrollingElement((_b = settings.scrollRootElement) !== null && _b !== void 0 ? _b : null);
+            const driverEnvironment = await driver.getEnvironment();
+            uniqueEnvironments.forEach(environment => {
+                var _a, _b;
+                var _c, _d;
+                if (utils.types.has(environment, 'iosDeviceInfo')) {
+                    (_a = (_c = environment.iosDeviceInfo).version) !== null && _a !== void 0 ? _a : (_c.version = driverEnvironment.platformVersion);
+                }
+                else if (utils.types.has(environment, 'androidDeviceInfo')) {
+                    (_b = (_d = environment.androidDeviceInfo).version) !== null && _b !== void 0 ? _b : (_d.version = driverEnvironment.platformVersion);
+                }
+                return environment;
             });
+            if (settings.lazyLoad && driverEnvironment.isWeb) {
+                await (0, wait_for_lazy_load_1.waitForLazyLoad)({
+                    context: driver.currentContext,
+                    settings: settings.lazyLoad !== true ? settings.lazyLoad : {},
+                    logger,
+                });
+            }
+            const { elementReferences, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
+            if (driverEnvironment.isWeb ||
+                !((_c = driverEnvironment.applitoolsLib) === null || _c === void 0 ? void 0 : _c.instrumented) ||
+                settings.screenshotMode === 'default') {
+                let actualEnvironments;
+                if (settings.screenshotMode === 'default') {
+                    if (!uniqueEnvironments.every(environment => {
+                        return (!utils.types.has(environment, 'iosDeviceInfo') && !utils.types.has(environment, 'androidDeviceInfo'));
+                    })) {
+                        const nmlEnvironmentsInfo = await (0, nml_client_1.getNMLEnvironmentsInfo)({
+                            environments: uniqueEnvironments,
+                            supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl,
+                            proxy: eyes.test.eyesServer.proxy,
+                            logger,
+                        });
+                        actualEnvironments = nmlEnvironmentsInfo.renderEnvironments;
+                    }
+                }
+                const screenshots = await (0, take_screenshots_1.takeScreenshots)({
+                    driver,
+                    settings: {
+                        ...settings,
+                        environments: actualEnvironments !== null && actualEnvironments !== void 0 ? actualEnvironments : uniqueEnvironments,
+                        regionsToCalculate: elementReferences.calculate,
+                        calculateView: !!settings.pageId,
+                        domSettings: settings.sendDom ? { proxy: eyes.test.eyesServer.proxy } : undefined,
+                    },
+                    logger,
+                });
+                if (actualEnvironments)
+                    exactEnvironments.push(...actualEnvironments);
+                else
+                    exactEnvironments.push(...uniqueEnvironments);
+                screenshots.forEach(({ calculatedRegions, ...baseTarget }) => {
+                    baseTargets.push(baseTarget);
+                    baseSettings.push(getBaseCheckSettings({ calculatedRegions }));
+                });
+            }
+            else {
+                if (driverEnvironment.applitoolsLib.conflictingCapabilities) {
+                    const message = lang.applitoolsLibConflictingCapabilitiesWarning({
+                        conflictingCapabilities: driverEnvironment.applitoolsLib.conflictingCapabilities,
+                    });
+                    logger.console.log(chalk_1.default.yellow(message));
+                    logger.log(message);
+                }
+                const nmlClient = await eyes.core.getNMLClient({
+                    driver,
+                    settings: { ...eyes.test.eyesServer, supportedEnvironmentsUrl: eyes.test.supportedEnvironmentsUrl },
+                    logger,
+                });
+                const screenshots = await nmlClient.takeScreenshots({
+                    settings: {
+                        environments: uniqueEnvironments,
+                        fully: settings.fully,
+                        stitchMode: settings.stitchMode,
+                        hideScrollbars: settings.hideScrollbars,
+                        hideCaret: settings.hideScrollbars,
+                        overlap: settings.overlap,
+                        waitBeforeCapture: settings.waitBeforeCapture,
+                        waitBetweenStitches: settings.waitBetweenStitches,
+                        lazyLoad: settings.lazyLoad,
+                        name: settings.name,
+                    },
+                    logger,
+                });
+                screenshots.forEach(({ environment, ...baseTarget }) => {
+                    exactEnvironments.push(environment);
+                    baseTargets.push({ ...baseTarget, isTransformed: true });
+                    baseSettings.push(getBaseCheckSettings({ calculatedRegions: [] }));
+                });
+            }
         }
-        const { elementReferencesToCalculate, getBaseCheckSettings } = (0, to_base_check_settings_1.toBaseCheckSettings)({ settings });
-        const screenshot = await (0, take_screenshot_1.takeScreenshot)({
-            driver,
-            settings: { ...settings, regionsToCalculate: elementReferencesToCalculate },
-            logger,
-        });
-        const baseTarget = {
-            name: await driver.getTitle(),
-            source: await driver.getUrl(),
-            image: await screenshot.image.toPng(),
-            locationInViewport: utils.geometry.location(screenshot.region),
-            isTransformed: true,
-        };
-        const baseSettings = getBaseCheckSettings({ calculatedRegions: screenshot.calculatedRegions });
-        if (environment.isWeb && settings.sendDom) {
-            if (settings.fully)
-                await screenshot.scrollingElement.setAttribute('data-applitools-scroll', 'true');
-            else
-                await ((_a = screenshot.element) === null || _a === void 0 ? void 0 : _a.setAttribute('data-applitools-scroll', 'true'));
-            baseTarget.dom = await (0, take_dom_capture_1.takeDomCapture)({ driver, settings: { proxy: eyes.test.server.proxy }, logger }).catch(() => undefined);
-        }
-        if (settings.pageId) {
-            const scrollingElement = await driver.mainContext.getScrollingElement();
-            const scrollingOffset = !scrollingElement || environment.isNative ? { x: 0, y: 0 } : await scrollingElement.getScrollOffset();
-            baseTarget.locationInView = utils.geometry.offset(scrollingOffset, screenshot.region);
-            baseTarget.fullViewSize = scrollingElement
-                ? await scrollingElement.getContentSize()
-                : await driver.getViewportSize();
+        else {
+            exactEnvironments.push(...uniqueEnvironments);
+            baseTargets.push(target);
+            baseSettings.push(settings);
         }
-        await screenshot.restoreState();
-        return (await Promise.all(baseEyes.map(baseEyes => baseEyes.checkAndClose({ target: baseTarget, settings: baseSettings, logger })))).flat();
+        const promises = exactEnvironments.map(async (environment, index) => {
+            var _a, _b, _c, _d;
+            const environmentLogger = logger.extend({ tags: [`environment-${utils.general.shortid()}`] });
+            try {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    environmentLogger.warn('Command "checkAndClose" was aborted before checking');
+                    throw new abort_error_1.AbortError('Command "checkAndClose" was aborted before checking');
+                }
+                const baseEyes = await eyes.getBaseEyes({ settings: { environment, driver }, logger: environmentLogger });
+                try {
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                        environmentLogger.warn('Command "checkAndClose" was aborted before checking');
+                        throw new abort_error_1.AbortError('Command "checkAndClose" was aborted before checking');
+                    }
+                    else if (!baseEyes.running) {
+                        environmentLogger.warn(`Check on environment with id "${(_a = baseEyes.test.environment) === null || _a === void 0 ? void 0 : _a.environmentId}" was aborted during one of the previous steps`);
+                        throw new abort_error_1.AbortError(`Check on environment with id "${(_b = baseEyes.test.environment) === null || _b === void 0 ? void 0 : _b.environmentId}" was aborted during one of the previous steps`);
+                    }
+                    if (settings.assumesMutability) {
+                        void eyes.core.logEvent({
+                            settings: {
+                                level: 'Notice',
+                                event: {
+                                    type: 'eyes.check',
+                                    message: 'Assuming mutability for check Target',
+                                    test: {
+                                        checkName: settings.name,
+                                        batchId: baseEyes.test.batchId,
+                                        sessionId: baseEyes.test.sessionId,
+                                        testName: baseEyes.test.testName,
+                                        testId: baseEyes.test.testId,
+                                        userTestId: baseEyes.test.userTestId,
+                                        appId: baseEyes.test.appId,
+                                        baselineId: baseEyes.test.baselineId,
+                                        environmentId: (_c = baseEyes.test.environment) === null || _c === void 0 ? void 0 : _c.environmentId,
+                                    },
+                                    isNew: baseEyes.test.isNew,
+                                    resultsUrl: baseEyes.test.resultsUrl,
+                                },
+                                ...eyes.test.eyesServer,
+                            },
+                        });
+                    }
+                    await baseEyes.checkAndClose({
+                        target: baseTargets[index],
+                        settings: baseSettings[index],
+                        logger: environmentLogger,
+                    });
+                }
+                catch (error) {
+                    environmentLogger.error(`Check on environment with id "${(_d = baseEyes.test.environment) === null || _d === void 0 ? void 0 : _d.environmentId}" failed due to an error`, error);
+                    if (baseEyes.running && !(signal === null || signal === void 0 ? void 0 : signal.aborted))
+                        await baseEyes.abort({ logger: environmentLogger, settings: { reason: error } });
+                }
+            }
+            catch (error) {
+                environmentLogger.error(`Environment with id ${environment.environmentId} failed before checking started due to an error`, error);
+                error.info = { ...error.info, userTestId: eyes.test.userTestId, environment: environment };
+                throw error;
+            }
+        });
+        exactEnvironments.forEach((environment, index) => {
+            const key = (0, to_environment_key_1.toEnvironmentKey)(environment);
+            let item = eyes.storage.get(key);
+            if (!item) {
+                item = { eyes: utils.promises.makeControlledPromise(), jobs: [] };
+                eyes.storage.set(key, item);
+            }
+            item.jobs.push(promises[index]);
+        });
     };
 }
 exports.makeCheckAndClose = makeCheckAndClose;